diff --git a/README.md b/README.md index 4192ea3..b3ed879 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,5 @@ # sdk-python Python SDK for the Authorize.Net API + +Python - demo version commit +06/25/2015 diff --git a/src/contract/__init__.py b/src/contract/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/contract/binding.py b/src/contract/binding.py new file mode 100644 index 0000000..06a5358 --- /dev/null +++ b/src/contract/binding.py @@ -0,0 +1,25093 @@ +# .\binding.py +# -*- coding: utf-8 -*- +# PyXB bindings for NM:0fc19dc0c6315668ca059fd5839cdad268ce84d3 +# Generated 2015-06-01 09:16:28.293000 by PyXB version 1.2.4 using Python 2.7.10.final.0 +# Namespace AnetApi/xml/v1/schema/AnetApiSchema.xsd + + +#classes generated from pyxbgen. Url: https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd + +from __future__ import unicode_literals +import pyxb +import pyxb.binding +import pyxb.binding.saxer +import io +import pyxb.utils.utility +import pyxb.utils.domutils +import sys +import pyxb.utils.six as _six + +# Unique identifier for bindings created at the same time +_GenerationUID = pyxb.utils.utility.UniqueIdentifier('urn:uuid:8dba9af0-0879-11e5-a7f5-d8fc93b712b2') + +# Version of PyXB used to generate the bindings +_PyXBVersion = '1.2.4' +# Generated bindings are not compatible across PyXB versions +if pyxb.__version__ != _PyXBVersion: + raise pyxb.PyXBVersionError(_PyXBVersion) + +# Import bindings for namespaces imported into schema +import pyxb.binding.datatypes + +# NOTE: All namespace declarations are reserved within the binding +Namespace = pyxb.namespace.NamespaceForURI('AnetApi/xml/v1/schema/AnetApiSchema.xsd', create_if_missing=True) +Namespace.configureCategories(['typeBinding', 'elementBinding']) + +def CreateFromDocument (xml_text, default_namespace=None, location_base=None): + """Parse the given XML and use the document element to create a + Python instance. + + @param xml_text An XML document. This should be data (Python 2 + str or Python 3 bytes), or a text (Python 2 unicode or Python 3 + str) in the L{pyxb._InputEncoding} encoding. + + @keyword default_namespace The L{pyxb.Namespace} instance to use as the + default namespace where there is no default namespace in scope. + If unspecified or C{None}, the namespace of the module containing + this function will be used. + + @keyword location_base: An object to be recorded as the base of all + L{pyxb.utils.utility.Location} instances associated with events and + objects handled by the parser. You might pass the URI from which + the document was obtained. + """ + + if pyxb.XMLStyle_saxer != pyxb._XMLStyle: + dom = pyxb.utils.domutils.StringToDOM(xml_text) + return CreateFromDOM(dom.documentElement, default_namespace=default_namespace) + if default_namespace is None: + default_namespace = Namespace.fallbackNamespace() + saxer = pyxb.binding.saxer.make_parser(fallback_namespace=default_namespace, location_base=location_base) + handler = saxer.getContentHandler() + xmld = xml_text + if isinstance(xmld, _six.text_type): + xmld = xmld.encode(pyxb._InputEncoding) + saxer.parse(io.BytesIO(xmld)) + instance = handler.rootObject() + return instance + +def CreateFromDOM (node, default_namespace=None): + """Create a Python instance from the given DOM node. + The node tag must correspond to an element declaration in this module. + + @deprecated: Forcing use of DOM interface is unnecessary; use L{CreateFromDocument}.""" + if default_namespace is None: + default_namespace = Namespace.fallbackNamespace() + return pyxb.binding.basis.element.AnyCreateFromDOM(node, default_namespace) + + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}numericString +class numericString (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'numericString') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 9, 1) + _Documentation = None +numericString._CF_pattern = pyxb.binding.facets.CF_pattern() +numericString._CF_pattern.addPattern(pattern='[0-9]+') +numericString._InitializeFacetMap(numericString._CF_pattern) +Namespace.addCategoryObject('typeBinding', 'numericString', numericString) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankAccountTypeEnum +class bankAccountTypeEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'bankAccountTypeEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 75, 1) + _Documentation = None +bankAccountTypeEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=bankAccountTypeEnum, enum_prefix=None) +bankAccountTypeEnum.checking = bankAccountTypeEnum._CF_enumeration.addEnumeration(unicode_value='checking', tag='checking') +bankAccountTypeEnum.savings = bankAccountTypeEnum._CF_enumeration.addEnumeration(unicode_value='savings', tag='savings') +bankAccountTypeEnum.businessChecking = bankAccountTypeEnum._CF_enumeration.addEnumeration(unicode_value='businessChecking', tag='businessChecking') +bankAccountTypeEnum._InitializeFacetMap(bankAccountTypeEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'bankAccountTypeEnum', bankAccountTypeEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}echeckTypeEnum +class echeckTypeEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'echeckTypeEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 83, 1) + _Documentation = None +echeckTypeEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=echeckTypeEnum, enum_prefix=None) +echeckTypeEnum.PPD = echeckTypeEnum._CF_enumeration.addEnumeration(unicode_value='PPD', tag='PPD') +echeckTypeEnum.WEB = echeckTypeEnum._CF_enumeration.addEnumeration(unicode_value='WEB', tag='WEB') +echeckTypeEnum.CCD = echeckTypeEnum._CF_enumeration.addEnumeration(unicode_value='CCD', tag='CCD') +echeckTypeEnum.TEL = echeckTypeEnum._CF_enumeration.addEnumeration(unicode_value='TEL', tag='TEL') +echeckTypeEnum.ARC = echeckTypeEnum._CF_enumeration.addEnumeration(unicode_value='ARC', tag='ARC') +echeckTypeEnum.BOC = echeckTypeEnum._CF_enumeration.addEnumeration(unicode_value='BOC', tag='BOC') +echeckTypeEnum._InitializeFacetMap(echeckTypeEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'echeckTypeEnum', echeckTypeEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentMethodEnum +class paymentMethodEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'paymentMethodEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 94, 1) + _Documentation = None +paymentMethodEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=paymentMethodEnum, enum_prefix=None) +paymentMethodEnum.creditCard = paymentMethodEnum._CF_enumeration.addEnumeration(unicode_value='creditCard', tag='creditCard') +paymentMethodEnum.eCheck = paymentMethodEnum._CF_enumeration.addEnumeration(unicode_value='eCheck', tag='eCheck') +paymentMethodEnum.payPal = paymentMethodEnum._CF_enumeration.addEnumeration(unicode_value='payPal', tag='payPal') +paymentMethodEnum._InitializeFacetMap(paymentMethodEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'paymentMethodEnum', paymentMethodEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardTypeEnum +class cardTypeEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'cardTypeEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 102, 1) + _Documentation = None +cardTypeEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=cardTypeEnum, enum_prefix=None) +cardTypeEnum.Visa = cardTypeEnum._CF_enumeration.addEnumeration(unicode_value='Visa', tag='Visa') +cardTypeEnum.MasterCard = cardTypeEnum._CF_enumeration.addEnumeration(unicode_value='MasterCard', tag='MasterCard') +cardTypeEnum.AmericanExpress = cardTypeEnum._CF_enumeration.addEnumeration(unicode_value='AmericanExpress', tag='AmericanExpress') +cardTypeEnum.Discover = cardTypeEnum._CF_enumeration.addEnumeration(unicode_value='Discover', tag='Discover') +cardTypeEnum.JCB = cardTypeEnum._CF_enumeration.addEnumeration(unicode_value='JCB', tag='JCB') +cardTypeEnum.DinersClub = cardTypeEnum._CF_enumeration.addEnumeration(unicode_value='DinersClub', tag='DinersClub') +cardTypeEnum._InitializeFacetMap(cardTypeEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'cardTypeEnum', cardTypeEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountTypeEnum +class accountTypeEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'accountTypeEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 113, 1) + _Documentation = None +accountTypeEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=accountTypeEnum, enum_prefix=None) +accountTypeEnum.Visa = accountTypeEnum._CF_enumeration.addEnumeration(unicode_value='Visa', tag='Visa') +accountTypeEnum.MasterCard = accountTypeEnum._CF_enumeration.addEnumeration(unicode_value='MasterCard', tag='MasterCard') +accountTypeEnum.AmericanExpress = accountTypeEnum._CF_enumeration.addEnumeration(unicode_value='AmericanExpress', tag='AmericanExpress') +accountTypeEnum.Discover = accountTypeEnum._CF_enumeration.addEnumeration(unicode_value='Discover', tag='Discover') +accountTypeEnum.JCB = accountTypeEnum._CF_enumeration.addEnumeration(unicode_value='JCB', tag='JCB') +accountTypeEnum.DinersClub = accountTypeEnum._CF_enumeration.addEnumeration(unicode_value='DinersClub', tag='DinersClub') +accountTypeEnum.eCheck = accountTypeEnum._CF_enumeration.addEnumeration(unicode_value='eCheck', tag='eCheck') +accountTypeEnum._InitializeFacetMap(accountTypeEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'accountTypeEnum', accountTypeEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerTypeEnum +class customerTypeEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerTypeEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 125, 1) + _Documentation = None +customerTypeEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=customerTypeEnum, enum_prefix=None) +customerTypeEnum.individual = customerTypeEnum._CF_enumeration.addEnumeration(unicode_value='individual', tag='individual') +customerTypeEnum.business = customerTypeEnum._CF_enumeration.addEnumeration(unicode_value='business', tag='business') +customerTypeEnum._InitializeFacetMap(customerTypeEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'customerTypeEnum', customerTypeEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ARBSubscriptionUnitEnum +class ARBSubscriptionUnitEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ARBSubscriptionUnitEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 132, 1) + _Documentation = None +ARBSubscriptionUnitEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=ARBSubscriptionUnitEnum, enum_prefix=None) +ARBSubscriptionUnitEnum.days = ARBSubscriptionUnitEnum._CF_enumeration.addEnumeration(unicode_value='days', tag='days') +ARBSubscriptionUnitEnum.months = ARBSubscriptionUnitEnum._CF_enumeration.addEnumeration(unicode_value='months', tag='months') +ARBSubscriptionUnitEnum._InitializeFacetMap(ARBSubscriptionUnitEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'ARBSubscriptionUnitEnum', ARBSubscriptionUnitEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}validationModeEnum +class validationModeEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'validationModeEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 139, 1) + _Documentation = None +validationModeEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=validationModeEnum, enum_prefix=None) +validationModeEnum.none = validationModeEnum._CF_enumeration.addEnumeration(unicode_value='none', tag='none') +validationModeEnum.testMode = validationModeEnum._CF_enumeration.addEnumeration(unicode_value='testMode', tag='testMode') +validationModeEnum.liveMode = validationModeEnum._CF_enumeration.addEnumeration(unicode_value='liveMode', tag='liveMode') +validationModeEnum.oldLiveMode = validationModeEnum._CF_enumeration.addEnumeration(unicode_value='oldLiveMode', tag='oldLiveMode') +validationModeEnum._InitializeFacetMap(validationModeEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'validationModeEnum', validationModeEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderStatusEnum +class splitTenderStatusEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'splitTenderStatusEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 148, 1) + _Documentation = None +splitTenderStatusEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=splitTenderStatusEnum, enum_prefix=None) +splitTenderStatusEnum.completed = splitTenderStatusEnum._CF_enumeration.addEnumeration(unicode_value='completed', tag='completed') +splitTenderStatusEnum.held = splitTenderStatusEnum._CF_enumeration.addEnumeration(unicode_value='held', tag='held') +splitTenderStatusEnum.voided = splitTenderStatusEnum._CF_enumeration.addEnumeration(unicode_value='voided', tag='voided') +splitTenderStatusEnum._InitializeFacetMap(splitTenderStatusEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'splitTenderStatusEnum', splitTenderStatusEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ARBSubscriptionStatusEnum +class ARBSubscriptionStatusEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ARBSubscriptionStatusEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 156, 1) + _Documentation = None +ARBSubscriptionStatusEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=ARBSubscriptionStatusEnum, enum_prefix=None) +ARBSubscriptionStatusEnum.active = ARBSubscriptionStatusEnum._CF_enumeration.addEnumeration(unicode_value='active', tag='active') +ARBSubscriptionStatusEnum.expired = ARBSubscriptionStatusEnum._CF_enumeration.addEnumeration(unicode_value='expired', tag='expired') +ARBSubscriptionStatusEnum.suspended = ARBSubscriptionStatusEnum._CF_enumeration.addEnumeration(unicode_value='suspended', tag='suspended') +ARBSubscriptionStatusEnum.canceled = ARBSubscriptionStatusEnum._CF_enumeration.addEnumeration(unicode_value='canceled', tag='canceled') +ARBSubscriptionStatusEnum.terminated = ARBSubscriptionStatusEnum._CF_enumeration.addEnumeration(unicode_value='terminated', tag='terminated') +ARBSubscriptionStatusEnum._InitializeFacetMap(ARBSubscriptionStatusEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'ARBSubscriptionStatusEnum', ARBSubscriptionStatusEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionTypeEnum +class transactionTypeEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'transactionTypeEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 166, 1) + _Documentation = None +transactionTypeEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=transactionTypeEnum, enum_prefix=None) +transactionTypeEnum.authOnlyTransaction = transactionTypeEnum._CF_enumeration.addEnumeration(unicode_value='authOnlyTransaction', tag='authOnlyTransaction') +transactionTypeEnum.authCaptureTransaction = transactionTypeEnum._CF_enumeration.addEnumeration(unicode_value='authCaptureTransaction', tag='authCaptureTransaction') +transactionTypeEnum.captureOnlyTransaction = transactionTypeEnum._CF_enumeration.addEnumeration(unicode_value='captureOnlyTransaction', tag='captureOnlyTransaction') +transactionTypeEnum.refundTransaction = transactionTypeEnum._CF_enumeration.addEnumeration(unicode_value='refundTransaction', tag='refundTransaction') +transactionTypeEnum.priorAuthCaptureTransaction = transactionTypeEnum._CF_enumeration.addEnumeration(unicode_value='priorAuthCaptureTransaction', tag='priorAuthCaptureTransaction') +transactionTypeEnum.voidTransaction = transactionTypeEnum._CF_enumeration.addEnumeration(unicode_value='voidTransaction', tag='voidTransaction') +transactionTypeEnum.getDetailsTransaction = transactionTypeEnum._CF_enumeration.addEnumeration(unicode_value='getDetailsTransaction', tag='getDetailsTransaction') +transactionTypeEnum.authOnlyContinueTransaction = transactionTypeEnum._CF_enumeration.addEnumeration(unicode_value='authOnlyContinueTransaction', tag='authOnlyContinueTransaction') +transactionTypeEnum.authCaptureContinueTransaction = transactionTypeEnum._CF_enumeration.addEnumeration(unicode_value='authCaptureContinueTransaction', tag='authCaptureContinueTransaction') +transactionTypeEnum._InitializeFacetMap(transactionTypeEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'transactionTypeEnum', transactionTypeEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionStatusEnum +class transactionStatusEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'transactionStatusEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 180, 1) + _Documentation = None +transactionStatusEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=transactionStatusEnum, enum_prefix=None) +transactionStatusEnum.authorizedPendingCapture = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='authorizedPendingCapture', tag='authorizedPendingCapture') +transactionStatusEnum.capturedPendingSettlement = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='capturedPendingSettlement', tag='capturedPendingSettlement') +transactionStatusEnum.communicationError = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='communicationError', tag='communicationError') +transactionStatusEnum.refundSettledSuccessfully = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='refundSettledSuccessfully', tag='refundSettledSuccessfully') +transactionStatusEnum.refundPendingSettlement = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='refundPendingSettlement', tag='refundPendingSettlement') +transactionStatusEnum.approvedReview = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='approvedReview', tag='approvedReview') +transactionStatusEnum.declined = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='declined', tag='declined') +transactionStatusEnum.couldNotVoid = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='couldNotVoid', tag='couldNotVoid') +transactionStatusEnum.expired = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='expired', tag='expired') +transactionStatusEnum.generalError = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='generalError', tag='generalError') +transactionStatusEnum.pendingFinalSettlement = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='pendingFinalSettlement', tag='pendingFinalSettlement') +transactionStatusEnum.pendingSettlement = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='pendingSettlement', tag='pendingSettlement') +transactionStatusEnum.failedReview = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='failedReview', tag='failedReview') +transactionStatusEnum.settledSuccessfully = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='settledSuccessfully', tag='settledSuccessfully') +transactionStatusEnum.settlementError = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='settlementError', tag='settlementError') +transactionStatusEnum.underReview = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='underReview', tag='underReview') +transactionStatusEnum.updatingSettlement = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='updatingSettlement', tag='updatingSettlement') +transactionStatusEnum.voided = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='voided', tag='voided') +transactionStatusEnum.FDSPendingReview = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='FDSPendingReview', tag='FDSPendingReview') +transactionStatusEnum.FDSAuthorizedPendingReview = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='FDSAuthorizedPendingReview', tag='FDSAuthorizedPendingReview') +transactionStatusEnum.returnedItem = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='returnedItem', tag='returnedItem') +transactionStatusEnum.chargeback = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='chargeback', tag='chargeback') +transactionStatusEnum.chargebackReversal = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='chargebackReversal', tag='chargebackReversal') +transactionStatusEnum.authorizedPendingRelease = transactionStatusEnum._CF_enumeration.addEnumeration(unicode_value='authorizedPendingRelease', tag='authorizedPendingRelease') +transactionStatusEnum._InitializeFacetMap(transactionStatusEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'transactionStatusEnum', transactionStatusEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settlementStateEnum +class settlementStateEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'settlementStateEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 209, 1) + _Documentation = None +settlementStateEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=settlementStateEnum, enum_prefix=None) +settlementStateEnum.settledSuccessfully = settlementStateEnum._CF_enumeration.addEnumeration(unicode_value='settledSuccessfully', tag='settledSuccessfully') +settlementStateEnum.settlementError = settlementStateEnum._CF_enumeration.addEnumeration(unicode_value='settlementError', tag='settlementError') +settlementStateEnum.pendingSettlement = settlementStateEnum._CF_enumeration.addEnumeration(unicode_value='pendingSettlement', tag='pendingSettlement') +settlementStateEnum._InitializeFacetMap(settlementStateEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'settlementStateEnum', settlementStateEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}FDSFilterActionEnum +class FDSFilterActionEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FDSFilterActionEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 217, 1) + _Documentation = None +FDSFilterActionEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=FDSFilterActionEnum, enum_prefix=None) +FDSFilterActionEnum.reject = FDSFilterActionEnum._CF_enumeration.addEnumeration(unicode_value='reject', tag='reject') +FDSFilterActionEnum.decline = FDSFilterActionEnum._CF_enumeration.addEnumeration(unicode_value='decline', tag='decline') +FDSFilterActionEnum.hold = FDSFilterActionEnum._CF_enumeration.addEnumeration(unicode_value='hold', tag='hold') +FDSFilterActionEnum.authAndHold = FDSFilterActionEnum._CF_enumeration.addEnumeration(unicode_value='authAndHold', tag='authAndHold') +FDSFilterActionEnum.report = FDSFilterActionEnum._CF_enumeration.addEnumeration(unicode_value='report', tag='report') +FDSFilterActionEnum._InitializeFacetMap(FDSFilterActionEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'FDSFilterActionEnum', FDSFilterActionEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}permissionsEnum +class permissionsEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'permissionsEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 227, 1) + _Documentation = None +permissionsEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=permissionsEnum, enum_prefix=None) +permissionsEnum.API_Merchant_BasicReporting = permissionsEnum._CF_enumeration.addEnumeration(unicode_value='API_Merchant_BasicReporting', tag='API_Merchant_BasicReporting') +permissionsEnum.Submit_Charge = permissionsEnum._CF_enumeration.addEnumeration(unicode_value='Submit_Charge', tag='Submit_Charge') +permissionsEnum.Submit_Refund = permissionsEnum._CF_enumeration.addEnumeration(unicode_value='Submit_Refund', tag='Submit_Refund') +permissionsEnum.Submit_Update = permissionsEnum._CF_enumeration.addEnumeration(unicode_value='Submit_Update', tag='Submit_Update') +permissionsEnum.Mobile_Admin = permissionsEnum._CF_enumeration.addEnumeration(unicode_value='Mobile_Admin', tag='Mobile_Admin') +permissionsEnum._InitializeFacetMap(permissionsEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'permissionsEnum', permissionsEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}deviceActivationEnum +class deviceActivationEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'deviceActivationEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 237, 2) + _Documentation = None +deviceActivationEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=deviceActivationEnum, enum_prefix=None) +deviceActivationEnum.Activate = deviceActivationEnum._CF_enumeration.addEnumeration(unicode_value='Activate', tag='Activate') +deviceActivationEnum.Disable = deviceActivationEnum._CF_enumeration.addEnumeration(unicode_value='Disable', tag='Disable') +deviceActivationEnum._InitializeFacetMap(deviceActivationEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'deviceActivationEnum', deviceActivationEnum) + +# Atomic simple type: [anonymous] +class STD_ANON (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 248, 4) + _Documentation = None +STD_ANON._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(20)) +STD_ANON._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(5)) +STD_ANON._InitializeFacetMap(STD_ANON._CF_maxLength, + STD_ANON._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_ (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 256, 4) + _Documentation = None +STD_ANON_._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(2)) +STD_ANON_._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(2)) +STD_ANON_._InitializeFacetMap(STD_ANON_._CF_maxLength, + STD_ANON_._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_2 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 265, 4) + _Documentation = None +STD_ANON_2._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(10)) +STD_ANON_2._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_2._InitializeFacetMap(STD_ANON_2._CF_maxLength, + STD_ANON_2._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_3 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 278, 4) + _Documentation = None +STD_ANON_3._CF_length = pyxb.binding.facets.CF_length(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_3._InitializeFacetMap(STD_ANON_3._CF_length) + +# Atomic simple type: [anonymous] +class STD_ANON_4 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 285, 4) + _Documentation = None +STD_ANON_4._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(2)) +STD_ANON_4._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(2)) +STD_ANON_4._InitializeFacetMap(STD_ANON_4._CF_maxLength, + STD_ANON_4._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_5 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 293, 4) + _Documentation = None +STD_ANON_5._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(10)) +STD_ANON_5._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_5._InitializeFacetMap(STD_ANON_5._CF_maxLength, + STD_ANON_5._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_6 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 306, 4) + _Documentation = None +STD_ANON_6._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(50)) +STD_ANON_6._InitializeFacetMap(STD_ANON_6._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_7 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 313, 4) + _Documentation = None +STD_ANON_7._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(50)) +STD_ANON_7._InitializeFacetMap(STD_ANON_7._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_8 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 320, 4) + _Documentation = None +STD_ANON_8._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(50)) +STD_ANON_8._InitializeFacetMap(STD_ANON_8._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_9 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 327, 4) + _Documentation = None +STD_ANON_9._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(60)) +STD_ANON_9._InitializeFacetMap(STD_ANON_9._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_10 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 334, 4) + _Documentation = None +STD_ANON_10._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(40)) +STD_ANON_10._InitializeFacetMap(STD_ANON_10._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_11 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 341, 4) + _Documentation = None +STD_ANON_11._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(40)) +STD_ANON_11._InitializeFacetMap(STD_ANON_11._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_12 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 348, 4) + _Documentation = None +STD_ANON_12._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(20)) +STD_ANON_12._InitializeFacetMap(STD_ANON_12._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_13 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 355, 4) + _Documentation = None +STD_ANON_13._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(60)) +STD_ANON_13._InitializeFacetMap(STD_ANON_13._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_14 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 386, 4) + _Documentation = None +STD_ANON_14._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(16)) +STD_ANON_14._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_14._InitializeFacetMap(STD_ANON_14._CF_maxLength, + STD_ANON_14._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_15 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 395, 4) + _Documentation = None +STD_ANON_15._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(7)) +STD_ANON_15._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_15._InitializeFacetMap(STD_ANON_15._CF_maxLength, + STD_ANON_15._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_16 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 438, 4) + _Documentation = None +STD_ANON_16._CF_length = pyxb.binding.facets.CF_length(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_16._InitializeFacetMap(STD_ANON_16._CF_length) + +# Atomic simple type: [anonymous] +class STD_ANON_17 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 445, 4) + _Documentation = None +STD_ANON_17._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(7)) +STD_ANON_17._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_17._InitializeFacetMap(STD_ANON_17._CF_maxLength, + STD_ANON_17._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_18 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 469, 4) + _Documentation = None +STD_ANON_18._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(9)) +STD_ANON_18._InitializeFacetMap(STD_ANON_18._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_19 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 477, 4) + _Documentation = None +STD_ANON_19._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(17)) +STD_ANON_19._InitializeFacetMap(STD_ANON_19._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_20 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 484, 4) + _Documentation = None +STD_ANON_20._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(22)) +STD_ANON_20._InitializeFacetMap(STD_ANON_20._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_21 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 492, 4) + _Documentation = None +STD_ANON_21._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(50)) +STD_ANON_21._InitializeFacetMap(STD_ANON_21._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_22 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 499, 4) + _Documentation = None +STD_ANON_22._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(15)) +STD_ANON_22._InitializeFacetMap(STD_ANON_22._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_23 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 512, 4) + _Documentation = None +STD_ANON_23._CF_length = pyxb.binding.facets.CF_length(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_23._InitializeFacetMap(STD_ANON_23._CF_length) + +# Atomic simple type: [anonymous] +class STD_ANON_24 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 519, 4) + _Documentation = None +STD_ANON_24._CF_length = pyxb.binding.facets.CF_length(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_24._InitializeFacetMap(STD_ANON_24._CF_length) + +# Atomic simple type: [anonymous] +class STD_ANON_25 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 526, 4) + _Documentation = None +STD_ANON_25._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(22)) +STD_ANON_25._InitializeFacetMap(STD_ANON_25._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_26 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 534, 4) + _Documentation = None +STD_ANON_26._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(50)) +STD_ANON_26._InitializeFacetMap(STD_ANON_26._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_27 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 588, 8) + _Documentation = None +STD_ANON_27._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(7)) +STD_ANON_27._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_27._InitializeFacetMap(STD_ANON_27._CF_maxLength, + STD_ANON_27._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_28 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 601, 4) + _Documentation = None +STD_ANON_28._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(20)) +STD_ANON_28._InitializeFacetMap(STD_ANON_28._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_29 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 608, 4) + _Documentation = None +STD_ANON_29._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_29._InitializeFacetMap(STD_ANON_29._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_30 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 622, 6) + _Documentation = None +STD_ANON_30._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(25)) +STD_ANON_30._InitializeFacetMap(STD_ANON_30._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_31 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 637, 4) + _Documentation = None +STD_ANON_31._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(20)) +STD_ANON_31._InitializeFacetMap(STD_ANON_31._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_32 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 644, 4) + _Documentation = None +STD_ANON_32._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_32._InitializeFacetMap(STD_ANON_32._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_33 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 651, 4) + _Documentation = None +STD_ANON_33._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(25)) +STD_ANON_33._InitializeFacetMap(STD_ANON_33._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_34 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 658, 4) + _Documentation = None +STD_ANON_34._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(25)) +STD_ANON_34._InitializeFacetMap(STD_ANON_34._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_35 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 680, 4) + _Documentation = None +STD_ANON_35._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(20)) +STD_ANON_35._InitializeFacetMap(STD_ANON_35._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_36 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 687, 4) + _Documentation = None +STD_ANON_36._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_36._InitializeFacetMap(STD_ANON_36._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_37 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 695, 4) + _Documentation = None +STD_ANON_37._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(9)) +STD_ANON_37._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_37._InitializeFacetMap(STD_ANON_37._CF_maxLength, + STD_ANON_37._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_38 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 708, 4) + _Documentation = None +STD_ANON_38._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(25)) +STD_ANON_38._InitializeFacetMap(STD_ANON_38._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_39 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 717, 5) + _Documentation = None +STD_ANON_39._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(16)) +STD_ANON_39._InitializeFacetMap(STD_ANON_39._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_40 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 725, 5) + _Documentation = None +STD_ANON_40._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(40)) +STD_ANON_40._InitializeFacetMap(STD_ANON_40._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_41 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 735, 4) + _Documentation = None +STD_ANON_41._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(60)) +STD_ANON_41._InitializeFacetMap(STD_ANON_41._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_42 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 814, 8) + _Documentation = None +STD_ANON_42._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(25)) +STD_ANON_42._InitializeFacetMap(STD_ANON_42._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_43 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 821, 8) + _Documentation = None +STD_ANON_43._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(16)) +STD_ANON_43._InitializeFacetMap(STD_ANON_43._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_44 (pyxb.binding.datatypes.short): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 837, 7) + _Documentation = None +STD_ANON_44._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_44, value=pyxb.binding.datatypes.short(32000)) +STD_ANON_44._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_44, value=pyxb.binding.datatypes.short(1)) +STD_ANON_44._InitializeFacetMap(STD_ANON_44._CF_maxInclusive, + STD_ANON_44._CF_minInclusive) + +# Atomic simple type: [anonymous] +class STD_ANON_45 (pyxb.binding.datatypes.short): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 852, 4) + _Documentation = None +STD_ANON_45._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_45, value=pyxb.binding.datatypes.short(32000)) +STD_ANON_45._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_45, value=pyxb.binding.datatypes.short(1)) +STD_ANON_45._InitializeFacetMap(STD_ANON_45._CF_maxInclusive, + STD_ANON_45._CF_minInclusive) + +# Atomic simple type: [anonymous] +class STD_ANON_46 (pyxb.binding.datatypes.short): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 861, 4) + _Documentation = None +STD_ANON_46._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_46, value=pyxb.binding.datatypes.short(32000)) +STD_ANON_46._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_46, value=pyxb.binding.datatypes.short(0)) +STD_ANON_46._InitializeFacetMap(STD_ANON_46._CF_maxInclusive, + STD_ANON_46._CF_minInclusive) + +# Atomic simple type: [anonymous] +class STD_ANON_47 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 874, 4) + _Documentation = None +STD_ANON_47._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(50)) +STD_ANON_47._InitializeFacetMap(STD_ANON_47._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_48 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 883, 4) + _Documentation = None +STD_ANON_48._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_48, value=pyxb.binding.datatypes.decimal('0.01')) +STD_ANON_48._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_48._InitializeFacetMap(STD_ANON_48._CF_minInclusive, + STD_ANON_48._CF_fractionDigits) + +# Atomic simple type: [anonymous] +class STD_ANON_49 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 891, 4) + _Documentation = None +STD_ANON_49._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_49, value=pyxb.binding.datatypes.decimal('0.0')) +STD_ANON_49._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_49._InitializeFacetMap(STD_ANON_49._CF_minInclusive, + STD_ANON_49._CF_fractionDigits) + +# Atomic simple type: [anonymous] +class STD_ANON_50 (pyxb.binding.datatypes.int): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 910, 8) + _Documentation = None +STD_ANON_50._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_50, value=pyxb.binding.datatypes.int(0)) +STD_ANON_50._InitializeFacetMap(STD_ANON_50._CF_minInclusive) + +# Atomic simple type: [anonymous] +class STD_ANON_51 (pyxb.binding.datatypes.int): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 917, 8) + _Documentation = None +STD_ANON_51._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_51, value=pyxb.binding.datatypes.int(0)) +STD_ANON_51._InitializeFacetMap(STD_ANON_51._CF_minInclusive) + +# Atomic simple type: [anonymous] +class STD_ANON_52 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 929, 4) + _Documentation = None +STD_ANON_52._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(60)) +STD_ANON_52._InitializeFacetMap(STD_ANON_52._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_53 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 936, 4) + _Documentation = None +STD_ANON_53._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(60)) +STD_ANON_53._InitializeFacetMap(STD_ANON_53._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_54 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 943, 4) + _Documentation = None +STD_ANON_54._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(20)) +STD_ANON_54._InitializeFacetMap(STD_ANON_54._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_55 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 950, 8) + _Documentation = None +STD_ANON_55._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_55._InitializeFacetMap(STD_ANON_55._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_56 (pyxb.binding.datatypes.boolean): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 983, 4) + _Documentation = None +STD_ANON_56._InitializeFacetMap() + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}OperationType +class OperationType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'OperationType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1043, 3) + _Documentation = None +OperationType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=OperationType, enum_prefix=None) +OperationType.DECRYPT = OperationType._CF_enumeration.addEnumeration(unicode_value='DECRYPT', tag='DECRYPT') +OperationType._InitializeFacetMap(OperationType._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'OperationType', OperationType) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}EncryptionAlgorithmType +class EncryptionAlgorithmType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'EncryptionAlgorithmType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1048, 3) + _Documentation = None +EncryptionAlgorithmType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=EncryptionAlgorithmType, enum_prefix=None) +EncryptionAlgorithmType.TDES = EncryptionAlgorithmType._CF_enumeration.addEnumeration(unicode_value='TDES', tag='TDES') +EncryptionAlgorithmType.AES = EncryptionAlgorithmType._CF_enumeration.addEnumeration(unicode_value='AES', tag='AES') +EncryptionAlgorithmType.RSA = EncryptionAlgorithmType._CF_enumeration.addEnumeration(unicode_value='RSA', tag='RSA') +EncryptionAlgorithmType._InitializeFacetMap(EncryptionAlgorithmType._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'EncryptionAlgorithmType', EncryptionAlgorithmType) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}EncodingType +class EncodingType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'EncodingType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1055, 3) + _Documentation = None +EncodingType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=EncodingType, enum_prefix=None) +EncodingType.Base64 = EncodingType._CF_enumeration.addEnumeration(unicode_value='Base64', tag='Base64') +EncodingType.Hex = EncodingType._CF_enumeration.addEnumeration(unicode_value='Hex', tag='Hex') +EncodingType._InitializeFacetMap(EncodingType._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'EncodingType', EncodingType) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settingNameEnum +class settingNameEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'settingNameEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1092, 1) + _Documentation = None +settingNameEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=settingNameEnum, enum_prefix=None) +settingNameEnum.emailCustomer = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='emailCustomer', tag='emailCustomer') +settingNameEnum.merchantEmail = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='merchantEmail', tag='merchantEmail') +settingNameEnum.allowPartialAuth = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='allowPartialAuth', tag='allowPartialAuth') +settingNameEnum.headerEmailReceipt = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='headerEmailReceipt', tag='headerEmailReceipt') +settingNameEnum.footerEmailReceipt = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='footerEmailReceipt', tag='footerEmailReceipt') +settingNameEnum.recurringBilling = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='recurringBilling', tag='recurringBilling') +settingNameEnum.duplicateWindow = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='duplicateWindow', tag='duplicateWindow') +settingNameEnum.testRequest = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='testRequest', tag='testRequest') +settingNameEnum.hostedProfileReturnUrl = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='hostedProfileReturnUrl', tag='hostedProfileReturnUrl') +settingNameEnum.hostedProfileReturnUrlText = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='hostedProfileReturnUrlText', tag='hostedProfileReturnUrlText') +settingNameEnum.hostedProfilePageBorderVisible = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='hostedProfilePageBorderVisible', tag='hostedProfilePageBorderVisible') +settingNameEnum.hostedProfileIFrameCommunicatorUrl = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='hostedProfileIFrameCommunicatorUrl', tag='hostedProfileIFrameCommunicatorUrl') +settingNameEnum.hostedProfileHeadingBgColor = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='hostedProfileHeadingBgColor', tag='hostedProfileHeadingBgColor') +settingNameEnum.hostedProfileValidationMode = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='hostedProfileValidationMode', tag='hostedProfileValidationMode') +settingNameEnum.hostedProfileBillingAddressRequired = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='hostedProfileBillingAddressRequired', tag='hostedProfileBillingAddressRequired') +settingNameEnum.hostedProfileCardCodeRequired = settingNameEnum._CF_enumeration.addEnumeration(unicode_value='hostedProfileCardCodeRequired', tag='hostedProfileCardCodeRequired') +settingNameEnum._InitializeFacetMap(settingNameEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'settingNameEnum', settingNameEnum) + +# Atomic simple type: [anonymous] +class STD_ANON_57 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1204, 6) + _Documentation = None +STD_ANON_57._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(9)) +STD_ANON_57._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_57._InitializeFacetMap(STD_ANON_57._CF_maxLength, + STD_ANON_57._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_58 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1234, 6) + _Documentation = None +STD_ANON_58._CF_length = pyxb.binding.facets.CF_length(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_58._InitializeFacetMap(STD_ANON_58._CF_length) + +# Atomic simple type: [anonymous] +class STD_ANON_59 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1248, 4) + _Documentation = None +STD_ANON_59._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(20)) +STD_ANON_59._InitializeFacetMap(STD_ANON_59._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_60 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1255, 4) + _Documentation = None +STD_ANON_60._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_60._InitializeFacetMap(STD_ANON_60._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_61 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1262, 4) + _Documentation = None +STD_ANON_61._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_61._InitializeFacetMap(STD_ANON_61._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_62 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1308, 6) + _Documentation = None +STD_ANON_62._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_62._InitializeFacetMap(STD_ANON_62._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_63 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1315, 6) + _Documentation = None +STD_ANON_63._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_63._InitializeFacetMap(STD_ANON_63._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_64 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1340, 4) + _Documentation = None +STD_ANON_64._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_64, value=pyxb.binding.datatypes.decimal('0.0')) +STD_ANON_64._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_64._InitializeFacetMap(STD_ANON_64._CF_minInclusive, + STD_ANON_64._CF_fractionDigits) + +# Atomic simple type: [anonymous] +class STD_ANON_65 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1348, 4) + _Documentation = None +STD_ANON_65._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(31)) +STD_ANON_65._InitializeFacetMap(STD_ANON_65._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_66 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1355, 4) + _Documentation = None +STD_ANON_66._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_66._InitializeFacetMap(STD_ANON_66._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_67 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1367, 4) + _Documentation = None +STD_ANON_67._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(31)) +STD_ANON_67._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(1)) +STD_ANON_67._InitializeFacetMap(STD_ANON_67._CF_maxLength, + STD_ANON_67._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_68 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1375, 4) + _Documentation = None +STD_ANON_68._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(31)) +STD_ANON_68._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(1)) +STD_ANON_68._InitializeFacetMap(STD_ANON_68._CF_maxLength, + STD_ANON_68._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_69 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1383, 4) + _Documentation = None +STD_ANON_69._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_69._InitializeFacetMap(STD_ANON_69._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_70 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1390, 4) + _Documentation = None +STD_ANON_70._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_70, value=pyxb.binding.datatypes.decimal('0.0')) +STD_ANON_70._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_70._InitializeFacetMap(STD_ANON_70._CF_minInclusive, + STD_ANON_70._CF_fractionDigits) + +# Atomic simple type: [anonymous] +class STD_ANON_71 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1398, 4) + _Documentation = None +STD_ANON_71._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_71, value=pyxb.binding.datatypes.decimal('0.0')) +STD_ANON_71._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_71._InitializeFacetMap(STD_ANON_71._CF_minInclusive, + STD_ANON_71._CF_fractionDigits) + +# Atomic simple type: [anonymous] +class STD_ANON_72 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1412, 4) + _Documentation = None +STD_ANON_72._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_72, value=pyxb.binding.datatypes.decimal('0.01')) +STD_ANON_72._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_72._InitializeFacetMap(STD_ANON_72._CF_minInclusive, + STD_ANON_72._CF_fractionDigits) + +# Atomic simple type: [anonymous] +class STD_ANON_73 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1475, 6) + _Documentation = None +STD_ANON_73._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(6)) +STD_ANON_73._InitializeFacetMap(STD_ANON_73._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_74 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1495, 6) + _Documentation = None +STD_ANON_74._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_74._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_74._InitializeFacetMap(STD_ANON_74._CF_maxLength, + STD_ANON_74._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_75 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1504, 6) + _Documentation = None +STD_ANON_75._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_75._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_75._InitializeFacetMap(STD_ANON_75._CF_maxLength, + STD_ANON_75._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_76 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1513, 6) + _Documentation = None +STD_ANON_76._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_76._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(8)) +STD_ANON_76._InitializeFacetMap(STD_ANON_76._CF_maxLength, + STD_ANON_76._CF_minLength) + +# Atomic simple type: [anonymous] +class STD_ANON_77 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1581, 4) + _Documentation = None +STD_ANON_77._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(6)) +STD_ANON_77._InitializeFacetMap(STD_ANON_77._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_78 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1588, 4) + _Documentation = None +STD_ANON_78._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(1)) +STD_ANON_78._InitializeFacetMap(STD_ANON_78._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_79 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1595, 4) + _Documentation = None +STD_ANON_79._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(1)) +STD_ANON_79._InitializeFacetMap(STD_ANON_79._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_80 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1602, 4) + _Documentation = None +STD_ANON_80._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(1)) +STD_ANON_80._InitializeFacetMap(STD_ANON_80._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_81 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1613, 4) + _Documentation = None +STD_ANON_81._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_81, value=pyxb.binding.datatypes.decimal('0.0')) +STD_ANON_81._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_81._InitializeFacetMap(STD_ANON_81._CF_minInclusive, + STD_ANON_81._CF_fractionDigits) + +# Atomic simple type: [anonymous] +class STD_ANON_82 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1621, 4) + _Documentation = None +STD_ANON_82._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_82, value=pyxb.binding.datatypes.decimal('0.0')) +STD_ANON_82._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_82._InitializeFacetMap(STD_ANON_82._CF_minInclusive, + STD_ANON_82._CF_fractionDigits) + +# Atomic simple type: [anonymous] +class STD_ANON_83 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1629, 4) + _Documentation = None +STD_ANON_83._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_83, value=pyxb.binding.datatypes.decimal('0.0')) +STD_ANON_83._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_83._InitializeFacetMap(STD_ANON_83._CF_minInclusive, + STD_ANON_83._CF_fractionDigits) + +# Atomic simple type: [anonymous] +class STD_ANON_84 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1641, 4) + _Documentation = None +STD_ANON_84._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_84._InitializeFacetMap(STD_ANON_84._CF_fractionDigits) + +# Atomic simple type: [anonymous] +class STD_ANON_85 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1832, 4) + _Documentation = None +STD_ANON_85._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(20)) +STD_ANON_85._InitializeFacetMap(STD_ANON_85._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_86 (pyxb.binding.datatypes.integer): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1848, 10) + _Documentation = None +STD_ANON_86._InitializeFacetMap() + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}messageTypeEnum +class messageTypeEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'messageTypeEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1872, 1) + _Documentation = None +messageTypeEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=messageTypeEnum, enum_prefix=None) +messageTypeEnum.Ok = messageTypeEnum._CF_enumeration.addEnumeration(unicode_value='Ok', tag='Ok') +messageTypeEnum.Error = messageTypeEnum._CF_enumeration.addEnumeration(unicode_value='Error', tag='Error') +messageTypeEnum._InitializeFacetMap(messageTypeEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'messageTypeEnum', messageTypeEnum) + +# Atomic simple type: [anonymous] +class STD_ANON_87 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1929, 5) + _Documentation = None +STD_ANON_87._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(20)) +STD_ANON_87._InitializeFacetMap(STD_ANON_87._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_88 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2209, 7) + _Documentation = None +STD_ANON_88._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(2048)) +STD_ANON_88._InitializeFacetMap(STD_ANON_88._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_89 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2451, 14) + _Documentation = None +STD_ANON_89._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(2048)) +STD_ANON_89._InitializeFacetMap(STD_ANON_89._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_90 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2608, 14) + _Documentation = None +STD_ANON_90._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(1024)) +STD_ANON_90._InitializeFacetMap(STD_ANON_90._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_91 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2632, 14) + _Documentation = None +STD_ANON_91._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(2048)) +STD_ANON_91._InitializeFacetMap(STD_ANON_91._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_92 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2677, 14) + _Documentation = None +STD_ANON_92._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(2048)) +STD_ANON_92._InitializeFacetMap(STD_ANON_92._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_93 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3127, 4) + _Documentation = None +STD_ANON_93._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(2048)) +STD_ANON_93._InitializeFacetMap(STD_ANON_93._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_94 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3134, 4) + _Documentation = None +STD_ANON_94._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(2048)) +STD_ANON_94._InitializeFacetMap(STD_ANON_94._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_95 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3141, 4) + _Documentation = None +STD_ANON_95._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(2)) +STD_ANON_95._InitializeFacetMap(STD_ANON_95._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_96 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3148, 4) + _Documentation = None +STD_ANON_96._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(127)) +STD_ANON_96._InitializeFacetMap(STD_ANON_96._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_97 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3155, 4) + _Documentation = None +STD_ANON_97._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(6)) +STD_ANON_97._InitializeFacetMap(STD_ANON_97._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_98 (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3162, 4) + _Documentation = None +STD_ANON_98._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(255)) +STD_ANON_98._InitializeFacetMap(STD_ANON_98._CF_maxLength) + +# Atomic simple type: [anonymous] +class STD_ANON_99 (pyxb.binding.datatypes.int): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3186, 16) + _Documentation = None +STD_ANON_99._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_99, value=pyxb.binding.datatypes.int(1000)) +STD_ANON_99._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_99, value=pyxb.binding.datatypes.int(1)) +STD_ANON_99._InitializeFacetMap(STD_ANON_99._CF_maxInclusive, + STD_ANON_99._CF_minInclusive) + +# Atomic simple type: [anonymous] +class STD_ANON_100 (pyxb.binding.datatypes.int): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3194, 16) + _Documentation = None +STD_ANON_100._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_100, value=pyxb.binding.datatypes.int(100000)) +STD_ANON_100._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_100, value=pyxb.binding.datatypes.int(1)) +STD_ANON_100._InitializeFacetMap(STD_ANON_100._CF_maxInclusive, + STD_ANON_100._CF_minInclusive) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ARBGetSubscriptionListSearchTypeEnum +class ARBGetSubscriptionListSearchTypeEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ARBGetSubscriptionListSearchTypeEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3209, 1) + _Documentation = None +ARBGetSubscriptionListSearchTypeEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=ARBGetSubscriptionListSearchTypeEnum, enum_prefix=None) +ARBGetSubscriptionListSearchTypeEnum.cardExpiringThisMonth = ARBGetSubscriptionListSearchTypeEnum._CF_enumeration.addEnumeration(unicode_value='cardExpiringThisMonth', tag='cardExpiringThisMonth') +ARBGetSubscriptionListSearchTypeEnum.subscriptionActive = ARBGetSubscriptionListSearchTypeEnum._CF_enumeration.addEnumeration(unicode_value='subscriptionActive', tag='subscriptionActive') +ARBGetSubscriptionListSearchTypeEnum.subscriptionExpiringThisMonth = ARBGetSubscriptionListSearchTypeEnum._CF_enumeration.addEnumeration(unicode_value='subscriptionExpiringThisMonth', tag='subscriptionExpiringThisMonth') +ARBGetSubscriptionListSearchTypeEnum.subscriptionInactive = ARBGetSubscriptionListSearchTypeEnum._CF_enumeration.addEnumeration(unicode_value='subscriptionInactive', tag='subscriptionInactive') +ARBGetSubscriptionListSearchTypeEnum._InitializeFacetMap(ARBGetSubscriptionListSearchTypeEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'ARBGetSubscriptionListSearchTypeEnum', ARBGetSubscriptionListSearchTypeEnum) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ARBGetSubscriptionListOrderFieldEnum +class ARBGetSubscriptionListOrderFieldEnum (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ARBGetSubscriptionListOrderFieldEnum') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3217, 1) + _Documentation = None +ARBGetSubscriptionListOrderFieldEnum._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=ARBGetSubscriptionListOrderFieldEnum, enum_prefix=None) +ARBGetSubscriptionListOrderFieldEnum.id = ARBGetSubscriptionListOrderFieldEnum._CF_enumeration.addEnumeration(unicode_value='id', tag='id') +ARBGetSubscriptionListOrderFieldEnum.name = ARBGetSubscriptionListOrderFieldEnum._CF_enumeration.addEnumeration(unicode_value='name', tag='name') +ARBGetSubscriptionListOrderFieldEnum.status = ARBGetSubscriptionListOrderFieldEnum._CF_enumeration.addEnumeration(unicode_value='status', tag='status') +ARBGetSubscriptionListOrderFieldEnum.createTimeStampUTC = ARBGetSubscriptionListOrderFieldEnum._CF_enumeration.addEnumeration(unicode_value='createTimeStampUTC', tag='createTimeStampUTC') +ARBGetSubscriptionListOrderFieldEnum.lastName = ARBGetSubscriptionListOrderFieldEnum._CF_enumeration.addEnumeration(unicode_value='lastName', tag='lastName') +ARBGetSubscriptionListOrderFieldEnum.firstName = ARBGetSubscriptionListOrderFieldEnum._CF_enumeration.addEnumeration(unicode_value='firstName', tag='firstName') +ARBGetSubscriptionListOrderFieldEnum.accountNumber = ARBGetSubscriptionListOrderFieldEnum._CF_enumeration.addEnumeration(unicode_value='accountNumber', tag='accountNumber') +ARBGetSubscriptionListOrderFieldEnum.amount = ARBGetSubscriptionListOrderFieldEnum._CF_enumeration.addEnumeration(unicode_value='amount', tag='amount') +ARBGetSubscriptionListOrderFieldEnum.pastOccurrences = ARBGetSubscriptionListOrderFieldEnum._CF_enumeration.addEnumeration(unicode_value='pastOccurrences', tag='pastOccurrences') +ARBGetSubscriptionListOrderFieldEnum._InitializeFacetMap(ARBGetSubscriptionListOrderFieldEnum._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'ARBGetSubscriptionListOrderFieldEnum', ARBGetSubscriptionListOrderFieldEnum) + +# Atomic simple type: [anonymous] +class STD_ANON_101 (pyxb.binding.datatypes.decimal): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3261, 16) + _Documentation = None +STD_ANON_101._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_101, value=pyxb.binding.datatypes.decimal('0.0')) +STD_ANON_101._CF_fractionDigits = pyxb.binding.facets.CF_fractionDigits(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +STD_ANON_101._InitializeFacetMap(STD_ANON_101._CF_minInclusive, + STD_ANON_101._CF_fractionDigits) + +# Atomic simple type: {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardCode +class cardCode (numericString): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'cardCode') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 412, 1) + _Documentation = None +cardCode._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(4)) +cardCode._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(3)) +cardCode._InitializeFacetMap(cardCode._CF_maxLength, + cardCode._CF_minLength) +Namespace.addCategoryObject('typeBinding', 'cardCode', cardCode) + +# Atomic simple type: [anonymous] +class STD_ANON_102 (numericString): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 666, 4) + _Documentation = None +STD_ANON_102._CF_maxLength = pyxb.binding.facets.CF_maxLength(value=pyxb.binding.datatypes.nonNegativeInteger(9)) +STD_ANON_102._CF_minLength = pyxb.binding.facets.CF_minLength(value=pyxb.binding.datatypes.nonNegativeInteger(9)) +STD_ANON_102._InitializeFacetMap(STD_ANON_102._CF_maxLength, + STD_ANON_102._CF_minLength) + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfLong with content type ELEMENT_ONLY +class ArrayOfLong (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfLong with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfLong') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 15, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}long uses Python identifier long + __long = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'long'), 'long', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfLong_AnetApixmlv1schemaAnetApiSchema_xsdlong', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 17, 3), ) + + + long = property(__long.value, __long.set, None, None) + + _ElementMap.update({ + __long.name() : __long + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfLong', ArrayOfLong) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfNumericString with content type ELEMENT_ONLY +class ArrayOfNumericString (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfNumericString with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfNumericString') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 21, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}numericString uses Python identifier numericString + __numericString = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'numericString'), 'numericString', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfNumericString_AnetApixmlv1schemaAnetApiSchema_xsdnumericString', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 23, 3), ) + + + numericString = property(__numericString.value, __numericString.set, None, None) + + _ElementMap.update({ + __numericString.name() : __numericString + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfNumericString', ArrayOfNumericString) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfString with content type ELEMENT_ONLY +class ArrayOfString (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfString with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfString') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 27, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}string uses Python identifier string + __string = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'string'), 'string', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfString_AnetApixmlv1schemaAnetApiSchema_xsdstring', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 29, 3), ) + + + string = property(__string.value, __string.set, None, None) + + _ElementMap.update({ + __string.name() : __string + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfString', ArrayOfString) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfLineItem with content type ELEMENT_ONLY +class ArrayOfLineItem (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfLineItem with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfLineItem') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 33, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItem uses Python identifier lineItem + __lineItem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'lineItem'), 'lineItem', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfLineItem_AnetApixmlv1schemaAnetApiSchema_xsdlineItem', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 35, 3), ) + + + lineItem = property(__lineItem.value, __lineItem.set, None, None) + + _ElementMap.update({ + __lineItem.name() : __lineItem + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfLineItem', ArrayOfLineItem) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfBatchStatisticType with content type ELEMENT_ONLY +class ArrayOfBatchStatisticType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfBatchStatisticType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfBatchStatisticType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 39, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}statistic uses Python identifier statistic + __statistic = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'statistic'), 'statistic', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfBatchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdstatistic', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 41, 3), ) + + + statistic = property(__statistic.value, __statistic.set, None, None) + + _ElementMap.update({ + __statistic.name() : __statistic + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfBatchStatisticType', ArrayOfBatchStatisticType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfBatchDetailsType with content type ELEMENT_ONLY +class ArrayOfBatchDetailsType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfBatchDetailsType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfBatchDetailsType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 45, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batch uses Python identifier batch + __batch = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'batch'), 'batch', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfBatchDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdbatch', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 47, 3), ) + + + batch = property(__batch.value, __batch.set, None, None) + + _ElementMap.update({ + __batch.name() : __batch + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfBatchDetailsType', ArrayOfBatchDetailsType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfTransactionSummaryType with content type ELEMENT_ONLY +class ArrayOfTransactionSummaryType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfTransactionSummaryType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfTransactionSummaryType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 51, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transaction uses Python identifier transaction + __transaction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transaction'), 'transaction', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfTransactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdtransaction', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 53, 3), ) + + + transaction = property(__transaction.value, __transaction.set, None, None) + + _ElementMap.update({ + __transaction.name() : __transaction + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfTransactionSummaryType', ArrayOfTransactionSummaryType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfSetting with content type ELEMENT_ONLY +class ArrayOfSetting (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfSetting with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfSetting') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 57, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}setting uses Python identifier setting + __setting = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'setting'), 'setting', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfSetting_AnetApixmlv1schemaAnetApiSchema_xsdsetting', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 59, 3), ) + + + setting = property(__setting.value, __setting.set, None, None) + + _ElementMap.update({ + __setting.name() : __setting + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfSetting', ArrayOfSetting) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfFDSFilter with content type ELEMENT_ONLY +class ArrayOfFDSFilter (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfFDSFilter with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfFDSFilter') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 63, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}FDSFilter uses Python identifier FDSFilter + __FDSFilter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FDSFilter'), 'FDSFilter', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfFDSFilter_AnetApixmlv1schemaAnetApiSchema_xsdFDSFilter', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 65, 3), ) + + + FDSFilter = property(__FDSFilter.value, __FDSFilter.set, None, None) + + _ElementMap.update({ + __FDSFilter.name() : __FDSFilter + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfFDSFilter', ArrayOfFDSFilter) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfPermissionType with content type ELEMENT_ONLY +class ArrayOfPermissionType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfPermissionType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfPermissionType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 69, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}permission uses Python identifier permission + __permission = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'permission'), 'permission', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfPermissionType_AnetApixmlv1schemaAnetApiSchema_xsdpermission', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 71, 3), ) + + + permission = property(__permission.value, __permission.set, None, None) + + _ElementMap.update({ + __permission.name() : __permission + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfPermissionType', ArrayOfPermissionType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}driversLicenseType with content type ELEMENT_ONLY +class driversLicenseType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}driversLicenseType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'driversLicenseType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 244, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}number uses Python identifier number + __number = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'number'), 'number', '__AnetApixmlv1schemaAnetApiSchema_xsd_driversLicenseType_AnetApixmlv1schemaAnetApiSchema_xsdnumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 247, 3), ) + + + number = property(__number.value, __number.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}state uses Python identifier state + __state = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'state'), 'state', '__AnetApixmlv1schemaAnetApiSchema_xsd_driversLicenseType_AnetApixmlv1schemaAnetApiSchema_xsdstate', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 255, 3), ) + + + state = property(__state.value, __state.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}dateOfBirth uses Python identifier dateOfBirth + __dateOfBirth = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'dateOfBirth'), 'dateOfBirth', '__AnetApixmlv1schemaAnetApiSchema_xsd_driversLicenseType_AnetApixmlv1schemaAnetApiSchema_xsddateOfBirth', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 264, 3), ) + + + dateOfBirth = property(__dateOfBirth.value, __dateOfBirth.set, None, None) + + _ElementMap.update({ + __number.name() : __number, + __state.name() : __state, + __dateOfBirth.name() : __dateOfBirth + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'driversLicenseType', driversLicenseType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}driversLicenseMaskedType with content type ELEMENT_ONLY +class driversLicenseMaskedType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}driversLicenseMaskedType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'driversLicenseMaskedType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 275, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}number uses Python identifier number + __number = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'number'), 'number', '__AnetApixmlv1schemaAnetApiSchema_xsd_driversLicenseMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdnumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 277, 3), ) + + + number = property(__number.value, __number.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}state uses Python identifier state + __state = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'state'), 'state', '__AnetApixmlv1schemaAnetApiSchema_xsd_driversLicenseMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdstate', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 284, 3), ) + + + state = property(__state.value, __state.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}dateOfBirth uses Python identifier dateOfBirth + __dateOfBirth = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'dateOfBirth'), 'dateOfBirth', '__AnetApixmlv1schemaAnetApiSchema_xsd_driversLicenseMaskedType_AnetApixmlv1schemaAnetApiSchema_xsddateOfBirth', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 292, 3), ) + + + dateOfBirth = property(__dateOfBirth.value, __dateOfBirth.set, None, None) + + _ElementMap.update({ + __number.name() : __number, + __state.name() : __state, + __dateOfBirth.name() : __dateOfBirth + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'driversLicenseMaskedType', driversLicenseMaskedType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType with content type ELEMENT_ONLY +class nameAndAddressType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'nameAndAddressType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 303, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}firstName uses Python identifier firstName + __firstName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'firstName'), 'firstName', '__AnetApixmlv1schemaAnetApiSchema_xsd_nameAndAddressType_AnetApixmlv1schemaAnetApiSchema_xsdfirstName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 305, 3), ) + + + firstName = property(__firstName.value, __firstName.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}lastName uses Python identifier lastName + __lastName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'lastName'), 'lastName', '__AnetApixmlv1schemaAnetApiSchema_xsd_nameAndAddressType_AnetApixmlv1schemaAnetApiSchema_xsdlastName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 312, 3), ) + + + lastName = property(__lastName.value, __lastName.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}company uses Python identifier company + __company = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'company'), 'company', '__AnetApixmlv1schemaAnetApiSchema_xsd_nameAndAddressType_AnetApixmlv1schemaAnetApiSchema_xsdcompany', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 319, 3), ) + + + company = property(__company.value, __company.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}address uses Python identifier address + __address = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'address'), 'address', '__AnetApixmlv1schemaAnetApiSchema_xsd_nameAndAddressType_AnetApixmlv1schemaAnetApiSchema_xsdaddress', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 326, 3), ) + + + address = property(__address.value, __address.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}city uses Python identifier city + __city = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'city'), 'city', '__AnetApixmlv1schemaAnetApiSchema_xsd_nameAndAddressType_AnetApixmlv1schemaAnetApiSchema_xsdcity', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 333, 3), ) + + + city = property(__city.value, __city.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}state uses Python identifier state + __state = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'state'), 'state', '__AnetApixmlv1schemaAnetApiSchema_xsd_nameAndAddressType_AnetApixmlv1schemaAnetApiSchema_xsdstate', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 340, 3), ) + + + state = property(__state.value, __state.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}zip uses Python identifier zip + __zip = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'zip'), 'zip', '__AnetApixmlv1schemaAnetApiSchema_xsd_nameAndAddressType_AnetApixmlv1schemaAnetApiSchema_xsdzip', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 347, 3), ) + + + zip = property(__zip.value, __zip.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}country uses Python identifier country + __country = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'country'), 'country', '__AnetApixmlv1schemaAnetApiSchema_xsd_nameAndAddressType_AnetApixmlv1schemaAnetApiSchema_xsdcountry', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 354, 3), ) + + + country = property(__country.value, __country.set, None, None) + + _ElementMap.update({ + __firstName.name() : __firstName, + __lastName.name() : __lastName, + __company.name() : __company, + __address.name() : __address, + __city.name() : __city, + __state.name() : __state, + __zip.name() : __zip, + __country.name() : __country + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'nameAndAddressType', nameAndAddressType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantContactType with content type ELEMENT_ONLY +class merchantContactType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantContactType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'merchantContactType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 364, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantName uses Python identifier merchantName + __merchantName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantName'), 'merchantName', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantContactType_AnetApixmlv1schemaAnetApiSchema_xsdmerchantName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 366, 3), ) + + + merchantName = property(__merchantName.value, __merchantName.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAddress uses Python identifier merchantAddress + __merchantAddress = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantAddress'), 'merchantAddress', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantContactType_AnetApixmlv1schemaAnetApiSchema_xsdmerchantAddress', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 367, 3), ) + + + merchantAddress = property(__merchantAddress.value, __merchantAddress.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantCity uses Python identifier merchantCity + __merchantCity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantCity'), 'merchantCity', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantContactType_AnetApixmlv1schemaAnetApiSchema_xsdmerchantCity', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 368, 3), ) + + + merchantCity = property(__merchantCity.value, __merchantCity.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantState uses Python identifier merchantState + __merchantState = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantState'), 'merchantState', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantContactType_AnetApixmlv1schemaAnetApiSchema_xsdmerchantState', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 369, 3), ) + + + merchantState = property(__merchantState.value, __merchantState.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantZip uses Python identifier merchantZip + __merchantZip = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantZip'), 'merchantZip', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantContactType_AnetApixmlv1schemaAnetApiSchema_xsdmerchantZip', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 370, 3), ) + + + merchantZip = property(__merchantZip.value, __merchantZip.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantPhone uses Python identifier merchantPhone + __merchantPhone = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantPhone'), 'merchantPhone', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantContactType_AnetApixmlv1schemaAnetApiSchema_xsdmerchantPhone', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 371, 3), ) + + + merchantPhone = property(__merchantPhone.value, __merchantPhone.set, None, None) + + _ElementMap.update({ + __merchantName.name() : __merchantName, + __merchantAddress.name() : __merchantAddress, + __merchantCity.name() : __merchantCity, + __merchantState.name() : __merchantState, + __merchantZip.name() : __merchantZip, + __merchantPhone.name() : __merchantPhone + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'merchantContactType', merchantContactType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transRetailInfoType with content type ELEMENT_ONLY +class transRetailInfoType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transRetailInfoType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'transRetailInfoType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 375, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}marketType uses Python identifier marketType + __marketType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'marketType'), 'marketType', '__AnetApixmlv1schemaAnetApiSchema_xsd_transRetailInfoType_AnetApixmlv1schemaAnetApiSchema_xsdmarketType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 377, 3), ) + + + marketType = property(__marketType.value, __marketType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}deviceType uses Python identifier deviceType + __deviceType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'deviceType'), 'deviceType', '__AnetApixmlv1schemaAnetApiSchema_xsd_transRetailInfoType_AnetApixmlv1schemaAnetApiSchema_xsddeviceType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 378, 3), ) + + + deviceType = property(__deviceType.value, __deviceType.set, None, None) + + _ElementMap.update({ + __marketType.name() : __marketType, + __deviceType.name() : __deviceType + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'transRetailInfoType', transRetailInfoType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardSimpleType with content type ELEMENT_ONLY +class creditCardSimpleType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardSimpleType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'creditCardSimpleType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 382, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardNumber uses Python identifier cardNumber + __cardNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardNumber'), 'cardNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardSimpleType_AnetApixmlv1schemaAnetApiSchema_xsdcardNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 385, 3), ) + + + cardNumber = property(__cardNumber.value, __cardNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}expirationDate uses Python identifier expirationDate + __expirationDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'expirationDate'), 'expirationDate', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardSimpleType_AnetApixmlv1schemaAnetApiSchema_xsdexpirationDate', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 394, 3), ) + + + expirationDate = property(__expirationDate.value, __expirationDate.set, None, None) + + _ElementMap.update({ + __cardNumber.name() : __cardNumber, + __expirationDate.name() : __expirationDate + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'creditCardSimpleType', creditCardSimpleType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardTrackType with content type ELEMENT_ONLY +class creditCardTrackType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardTrackType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'creditCardTrackType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 405, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}track1 uses Python identifier track1 + __track1 = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'track1'), 'track1', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardTrackType_AnetApixmlv1schemaAnetApiSchema_xsdtrack1', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 407, 3), ) + + + track1 = property(__track1.value, __track1.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}track2 uses Python identifier track2 + __track2 = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'track2'), 'track2', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardTrackType_AnetApixmlv1schemaAnetApiSchema_xsdtrack2', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 408, 3), ) + + + track2 = property(__track2.value, __track2.set, None, None) + + _ElementMap.update({ + __track1.name() : __track1, + __track2.name() : __track2 + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'creditCardTrackType', creditCardTrackType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardMaskedType with content type ELEMENT_ONLY +class creditCardMaskedType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardMaskedType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'creditCardMaskedType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 435, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardNumber uses Python identifier cardNumber + __cardNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardNumber'), 'cardNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdcardNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 437, 3), ) + + + cardNumber = property(__cardNumber.value, __cardNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}expirationDate uses Python identifier expirationDate + __expirationDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'expirationDate'), 'expirationDate', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdexpirationDate', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 444, 3), ) + + + expirationDate = property(__expirationDate.value, __expirationDate.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardType uses Python identifier cardType + __cardType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardType'), 'cardType', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdcardType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 452, 3), ) + + + cardType = property(__cardType.value, __cardType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardArt uses Python identifier cardArt + __cardArt = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardArt'), 'cardArt', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdcardArt', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 453, 3), ) + + + cardArt = property(__cardArt.value, __cardArt.set, None, None) + + _ElementMap.update({ + __cardNumber.name() : __cardNumber, + __expirationDate.name() : __expirationDate, + __cardType.name() : __cardType, + __cardArt.name() : __cardArt + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'creditCardMaskedType', creditCardMaskedType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ccAuthenticationType with content type ELEMENT_ONLY +class ccAuthenticationType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ccAuthenticationType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ccAuthenticationType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 457, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}authenticationIndicator uses Python identifier authenticationIndicator + __authenticationIndicator = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'authenticationIndicator'), 'authenticationIndicator', '__AnetApixmlv1schemaAnetApiSchema_xsd_ccAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdauthenticationIndicator', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 459, 3), ) + + + authenticationIndicator = property(__authenticationIndicator.value, __authenticationIndicator.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardholderAuthenticationValue uses Python identifier cardholderAuthenticationValue + __cardholderAuthenticationValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardholderAuthenticationValue'), 'cardholderAuthenticationValue', '__AnetApixmlv1schemaAnetApiSchema_xsd_ccAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdcardholderAuthenticationValue', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 460, 3), ) + + + cardholderAuthenticationValue = property(__cardholderAuthenticationValue.value, __cardholderAuthenticationValue.set, None, None) + + _ElementMap.update({ + __authenticationIndicator.name() : __authenticationIndicator, + __cardholderAuthenticationValue.name() : __cardholderAuthenticationValue + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ccAuthenticationType', ccAuthenticationType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankAccountType with content type ELEMENT_ONLY +class bankAccountType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankAccountType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'bankAccountType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 464, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountType uses Python identifier accountType + __accountType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountType'), 'accountType', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountType_AnetApixmlv1schemaAnetApiSchema_xsdaccountType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 466, 3), ) + + + accountType = property(__accountType.value, __accountType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}routingNumber uses Python identifier routingNumber + __routingNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'routingNumber'), 'routingNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountType_AnetApixmlv1schemaAnetApiSchema_xsdroutingNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 468, 3), ) + + + routingNumber = property(__routingNumber.value, __routingNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountNumber uses Python identifier accountNumber + __accountNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), 'accountNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountType_AnetApixmlv1schemaAnetApiSchema_xsdaccountNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 476, 3), ) + + + accountNumber = property(__accountNumber.value, __accountNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameOnAccount uses Python identifier nameOnAccount + __nameOnAccount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'nameOnAccount'), 'nameOnAccount', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountType_AnetApixmlv1schemaAnetApiSchema_xsdnameOnAccount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 483, 3), ) + + + nameOnAccount = property(__nameOnAccount.value, __nameOnAccount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}echeckType uses Python identifier echeckType + __echeckType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'echeckType'), 'echeckType', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountType_AnetApixmlv1schemaAnetApiSchema_xsdecheckType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 490, 3), ) + + + echeckType = property(__echeckType.value, __echeckType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankName uses Python identifier bankName + __bankName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'bankName'), 'bankName', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountType_AnetApixmlv1schemaAnetApiSchema_xsdbankName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 491, 3), ) + + + bankName = property(__bankName.value, __bankName.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}checkNumber uses Python identifier checkNumber + __checkNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'checkNumber'), 'checkNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountType_AnetApixmlv1schemaAnetApiSchema_xsdcheckNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 498, 3), ) + + + checkNumber = property(__checkNumber.value, __checkNumber.set, None, None) + + _ElementMap.update({ + __accountType.name() : __accountType, + __routingNumber.name() : __routingNumber, + __accountNumber.name() : __accountNumber, + __nameOnAccount.name() : __nameOnAccount, + __echeckType.name() : __echeckType, + __bankName.name() : __bankName, + __checkNumber.name() : __checkNumber + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'bankAccountType', bankAccountType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankAccountMaskedType with content type ELEMENT_ONLY +class bankAccountMaskedType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankAccountMaskedType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'bankAccountMaskedType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 508, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountType uses Python identifier accountType + __accountType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountType'), 'accountType', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdaccountType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 510, 3), ) + + + accountType = property(__accountType.value, __accountType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}routingNumber uses Python identifier routingNumber + __routingNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'routingNumber'), 'routingNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdroutingNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 511, 3), ) + + + routingNumber = property(__routingNumber.value, __routingNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountNumber uses Python identifier accountNumber + __accountNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), 'accountNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdaccountNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 518, 3), ) + + + accountNumber = property(__accountNumber.value, __accountNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameOnAccount uses Python identifier nameOnAccount + __nameOnAccount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'nameOnAccount'), 'nameOnAccount', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdnameOnAccount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 525, 3), ) + + + nameOnAccount = property(__nameOnAccount.value, __nameOnAccount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}echeckType uses Python identifier echeckType + __echeckType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'echeckType'), 'echeckType', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdecheckType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 532, 3), ) + + + echeckType = property(__echeckType.value, __echeckType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankName uses Python identifier bankName + __bankName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'bankName'), 'bankName', '__AnetApixmlv1schemaAnetApiSchema_xsd_bankAccountMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdbankName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 533, 3), ) + + + bankName = property(__bankName.value, __bankName.set, None, None) + + _ElementMap.update({ + __accountType.name() : __accountType, + __routingNumber.name() : __routingNumber, + __accountNumber.name() : __accountNumber, + __nameOnAccount.name() : __nameOnAccount, + __echeckType.name() : __echeckType, + __bankName.name() : __bankName + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'bankAccountMaskedType', bankAccountMaskedType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}opaqueDataType with content type ELEMENT_ONLY +class opaqueDataType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}opaqueDataType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'opaqueDataType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 543, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}dataDescriptor uses Python identifier dataDescriptor + __dataDescriptor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'dataDescriptor'), 'dataDescriptor', '__AnetApixmlv1schemaAnetApiSchema_xsd_opaqueDataType_AnetApixmlv1schemaAnetApiSchema_xsddataDescriptor', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 545, 6), ) + + + dataDescriptor = property(__dataDescriptor.value, __dataDescriptor.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}dataValue uses Python identifier dataValue + __dataValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'dataValue'), 'dataValue', '__AnetApixmlv1schemaAnetApiSchema_xsd_opaqueDataType_AnetApixmlv1schemaAnetApiSchema_xsddataValue', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 546, 6), ) + + + dataValue = property(__dataValue.value, __dataValue.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}dataKey uses Python identifier dataKey + __dataKey = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'dataKey'), 'dataKey', '__AnetApixmlv1schemaAnetApiSchema_xsd_opaqueDataType_AnetApixmlv1schemaAnetApiSchema_xsddataKey', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 547, 6), ) + + + dataKey = property(__dataKey.value, __dataKey.set, None, None) + + _ElementMap.update({ + __dataDescriptor.name() : __dataDescriptor, + __dataValue.name() : __dataValue, + __dataKey.name() : __dataKey + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'opaqueDataType', opaqueDataType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentSimpleType with content type ELEMENT_ONLY +class paymentSimpleType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentSimpleType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'paymentSimpleType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 551, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCard uses Python identifier creditCard + __creditCard = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'creditCard'), 'creditCard', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentSimpleType_AnetApixmlv1schemaAnetApiSchema_xsdcreditCard', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 554, 4), ) + + + creditCard = property(__creditCard.value, __creditCard.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankAccount uses Python identifier bankAccount + __bankAccount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'bankAccount'), 'bankAccount', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentSimpleType_AnetApixmlv1schemaAnetApiSchema_xsdbankAccount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 555, 4), ) + + + bankAccount = property(__bankAccount.value, __bankAccount.set, None, None) + + _ElementMap.update({ + __creditCard.name() : __creditCard, + __bankAccount.name() : __bankAccount + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'paymentSimpleType', paymentSimpleType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentType with content type ELEMENT_ONLY +class paymentType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'paymentType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 560, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCard uses Python identifier creditCard + __creditCard = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'creditCard'), 'creditCard', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentType_AnetApixmlv1schemaAnetApiSchema_xsdcreditCard', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 563, 4), ) + + + creditCard = property(__creditCard.value, __creditCard.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankAccount uses Python identifier bankAccount + __bankAccount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'bankAccount'), 'bankAccount', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentType_AnetApixmlv1schemaAnetApiSchema_xsdbankAccount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 564, 4), ) + + + bankAccount = property(__bankAccount.value, __bankAccount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}trackData uses Python identifier trackData + __trackData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'trackData'), 'trackData', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentType_AnetApixmlv1schemaAnetApiSchema_xsdtrackData', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 565, 4), ) + + + trackData = property(__trackData.value, __trackData.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}encryptedTrackData uses Python identifier encryptedTrackData + __encryptedTrackData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'encryptedTrackData'), 'encryptedTrackData', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentType_AnetApixmlv1schemaAnetApiSchema_xsdencryptedTrackData', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 566, 4), ) + + + encryptedTrackData = property(__encryptedTrackData.value, __encryptedTrackData.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}payPal uses Python identifier payPal + __payPal = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'payPal'), 'payPal', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentType_AnetApixmlv1schemaAnetApiSchema_xsdpayPal', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 567, 4), ) + + + payPal = property(__payPal.value, __payPal.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}opaqueData uses Python identifier opaqueData + __opaqueData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'opaqueData'), 'opaqueData', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentType_AnetApixmlv1schemaAnetApiSchema_xsdopaqueData', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 568, 8), ) + + + opaqueData = property(__opaqueData.value, __opaqueData.set, None, None) + + _ElementMap.update({ + __creditCard.name() : __creditCard, + __bankAccount.name() : __bankAccount, + __trackData.name() : __trackData, + __encryptedTrackData.name() : __encryptedTrackData, + __payPal.name() : __payPal, + __opaqueData.name() : __opaqueData + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'paymentType', paymentType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentMaskedType with content type ELEMENT_ONLY +class paymentMaskedType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentMaskedType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'paymentMaskedType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 573, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCard uses Python identifier creditCard + __creditCard = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'creditCard'), 'creditCard', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdcreditCard', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 576, 4), ) + + + creditCard = property(__creditCard.value, __creditCard.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankAccount uses Python identifier bankAccount + __bankAccount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'bankAccount'), 'bankAccount', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdbankAccount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 577, 4), ) + + + bankAccount = property(__bankAccount.value, __bankAccount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}tokenInformation uses Python identifier tokenInformation + __tokenInformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'tokenInformation'), 'tokenInformation', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdtokenInformation', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 578, 8), ) + + + tokenInformation = property(__tokenInformation.value, __tokenInformation.set, None, None) + + _ElementMap.update({ + __creditCard.name() : __creditCard, + __bankAccount.name() : __bankAccount, + __tokenInformation.name() : __tokenInformation + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'paymentMaskedType', paymentMaskedType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}tokenMaskedType with content type ELEMENT_ONLY +class tokenMaskedType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}tokenMaskedType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'tokenMaskedType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 583, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}tokenSource uses Python identifier tokenSource + __tokenSource = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'tokenSource'), 'tokenSource', '__AnetApixmlv1schemaAnetApiSchema_xsd_tokenMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdtokenSource', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 585, 6), ) + + + tokenSource = property(__tokenSource.value, __tokenSource.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}tokenNumber uses Python identifier tokenNumber + __tokenNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'tokenNumber'), 'tokenNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_tokenMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdtokenNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 586, 6), ) + + + tokenNumber = property(__tokenNumber.value, __tokenNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}expirationDate uses Python identifier expirationDate + __expirationDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'expirationDate'), 'expirationDate', '__AnetApixmlv1schemaAnetApiSchema_xsd_tokenMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdexpirationDate', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 587, 6), ) + + + expirationDate = property(__expirationDate.value, __expirationDate.set, None, None) + + _ElementMap.update({ + __tokenSource.name() : __tokenSource, + __tokenNumber.name() : __tokenNumber, + __expirationDate.name() : __expirationDate + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'tokenMaskedType', tokenMaskedType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}orderType with content type ELEMENT_ONLY +class orderType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}orderType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'orderType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 598, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}invoiceNumber uses Python identifier invoiceNumber + __invoiceNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'invoiceNumber'), 'invoiceNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_orderType_AnetApixmlv1schemaAnetApiSchema_xsdinvoiceNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 600, 3), ) + + + invoiceNumber = property(__invoiceNumber.value, __invoiceNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}description uses Python identifier description + __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'description'), 'description', '__AnetApixmlv1schemaAnetApiSchema_xsd_orderType_AnetApixmlv1schemaAnetApiSchema_xsddescription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 607, 3), ) + + + description = property(__description.value, __description.set, None, None) + + _ElementMap.update({ + __invoiceNumber.name() : __invoiceNumber, + __description.name() : __description + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'orderType', orderType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerType with content type ELEMENT_ONLY +class customerType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 633, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}type uses Python identifier type + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'type'), 'type', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerType_AnetApixmlv1schemaAnetApiSchema_xsdtype', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 635, 3), ) + + + type = property(__type.value, __type.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}id uses Python identifier id + __id = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'id'), 'id', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerType_AnetApixmlv1schemaAnetApiSchema_xsdid', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 636, 3), ) + + + id = property(__id.value, __id.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}email uses Python identifier email + __email = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'email'), 'email', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerType_AnetApixmlv1schemaAnetApiSchema_xsdemail', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 643, 3), ) + + + email = property(__email.value, __email.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}phoneNumber uses Python identifier phoneNumber + __phoneNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'phoneNumber'), 'phoneNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerType_AnetApixmlv1schemaAnetApiSchema_xsdphoneNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 650, 3), ) + + + phoneNumber = property(__phoneNumber.value, __phoneNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}faxNumber uses Python identifier faxNumber + __faxNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'faxNumber'), 'faxNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerType_AnetApixmlv1schemaAnetApiSchema_xsdfaxNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 657, 3), ) + + + faxNumber = property(__faxNumber.value, __faxNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}driversLicense uses Python identifier driversLicense + __driversLicense = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'driversLicense'), 'driversLicense', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerType_AnetApixmlv1schemaAnetApiSchema_xsddriversLicense', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 664, 3), ) + + + driversLicense = property(__driversLicense.value, __driversLicense.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxId uses Python identifier taxId + __taxId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'taxId'), 'taxId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerType_AnetApixmlv1schemaAnetApiSchema_xsdtaxId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 665, 3), ) + + + taxId = property(__taxId.value, __taxId.set, None, None) + + _ElementMap.update({ + __type.name() : __type, + __id.name() : __id, + __email.name() : __email, + __phoneNumber.name() : __phoneNumber, + __faxNumber.name() : __faxNumber, + __driversLicense.name() : __driversLicense, + __taxId.name() : __taxId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerType', customerType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerDataType with content type ELEMENT_ONLY +class customerDataType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerDataType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerDataType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 676, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}type uses Python identifier type + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'type'), 'type', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerDataType_AnetApixmlv1schemaAnetApiSchema_xsdtype', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 678, 3), ) + + + type = property(__type.value, __type.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}id uses Python identifier id + __id = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'id'), 'id', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerDataType_AnetApixmlv1schemaAnetApiSchema_xsdid', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 679, 3), ) + + + id = property(__id.value, __id.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}email uses Python identifier email + __email = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'email'), 'email', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerDataType_AnetApixmlv1schemaAnetApiSchema_xsdemail', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 686, 3), ) + + + email = property(__email.value, __email.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}driversLicense uses Python identifier driversLicense + __driversLicense = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'driversLicense'), 'driversLicense', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerDataType_AnetApixmlv1schemaAnetApiSchema_xsddriversLicense', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 693, 3), ) + + + driversLicense = property(__driversLicense.value, __driversLicense.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxId uses Python identifier taxId + __taxId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'taxId'), 'taxId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerDataType_AnetApixmlv1schemaAnetApiSchema_xsdtaxId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 694, 3), ) + + + taxId = property(__taxId.value, __taxId.set, None, None) + + _ElementMap.update({ + __type.name() : __type, + __id.name() : __id, + __email.name() : __email, + __driversLicense.name() : __driversLicense, + __taxId.name() : __taxId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerDataType', customerDataType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthenticationType with content type ELEMENT_ONLY +class merchantAuthenticationType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthenticationType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'merchantAuthenticationType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 705, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}name uses Python identifier name + __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'name'), 'name', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdname', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 707, 3), ) + + + name = property(__name.value, __name.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionKey uses Python identifier transactionKey + __transactionKey = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionKey'), 'transactionKey', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdtransactionKey', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 716, 4), ) + + + transactionKey = property(__transactionKey.value, __transactionKey.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken uses Python identifier sessionToken + __sessionToken = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'sessionToken'), 'sessionToken', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdsessionToken', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 723, 16), ) + + + sessionToken = property(__sessionToken.value, __sessionToken.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}password uses Python identifier password + __password = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'password'), 'password', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdpassword', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 724, 4), ) + + + password = property(__password.value, __password.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}impersonationAuthentication uses Python identifier impersonationAuthentication + __impersonationAuthentication = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'impersonationAuthentication'), 'impersonationAuthentication', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdimpersonationAuthentication', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 731, 8), ) + + + impersonationAuthentication = property(__impersonationAuthentication.value, __impersonationAuthentication.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}fingerPrint uses Python identifier fingerPrint + __fingerPrint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'fingerPrint'), 'fingerPrint', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdfingerPrint', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 732, 8), ) + + + fingerPrint = property(__fingerPrint.value, __fingerPrint.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}mobileDeviceId uses Python identifier mobileDeviceId + __mobileDeviceId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId'), 'mobileDeviceId', '__AnetApixmlv1schemaAnetApiSchema_xsd_merchantAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdmobileDeviceId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 734, 3), ) + + + mobileDeviceId = property(__mobileDeviceId.value, __mobileDeviceId.set, None, None) + + _ElementMap.update({ + __name.name() : __name, + __transactionKey.name() : __transactionKey, + __sessionToken.name() : __sessionToken, + __password.name() : __password, + __impersonationAuthentication.name() : __impersonationAuthentication, + __fingerPrint.name() : __fingerPrint, + __mobileDeviceId.name() : __mobileDeviceId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'merchantAuthenticationType', merchantAuthenticationType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}fingerPrintType with content type ELEMENT_ONLY +class fingerPrintType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}fingerPrintType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'fingerPrintType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 744, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}hashValue uses Python identifier hashValue + __hashValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'hashValue'), 'hashValue', '__AnetApixmlv1schemaAnetApiSchema_xsd_fingerPrintType_AnetApixmlv1schemaAnetApiSchema_xsdhashValue', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 746, 6), ) + + + hashValue = property(__hashValue.value, __hashValue.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}sequence uses Python identifier sequence + __sequence = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'sequence'), 'sequence', '__AnetApixmlv1schemaAnetApiSchema_xsd_fingerPrintType_AnetApixmlv1schemaAnetApiSchema_xsdsequence', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 747, 6), ) + + + sequence = property(__sequence.value, __sequence.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}timestamp uses Python identifier timestamp + __timestamp = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'timestamp'), 'timestamp', '__AnetApixmlv1schemaAnetApiSchema_xsd_fingerPrintType_AnetApixmlv1schemaAnetApiSchema_xsdtimestamp', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 748, 6), ) + + + timestamp = property(__timestamp.value, __timestamp.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}currencyCode uses Python identifier currencyCode + __currencyCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'currencyCode'), 'currencyCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_fingerPrintType_AnetApixmlv1schemaAnetApiSchema_xsdcurrencyCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 749, 6), ) + + + currencyCode = property(__currencyCode.value, __currencyCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount uses Python identifier amount + __amount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'amount'), 'amount', '__AnetApixmlv1schemaAnetApiSchema_xsd_fingerPrintType_AnetApixmlv1schemaAnetApiSchema_xsdamount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 750, 6), ) + + + amount = property(__amount.value, __amount.set, None, None) + + _ElementMap.update({ + __hashValue.name() : __hashValue, + __sequence.name() : __sequence, + __timestamp.name() : __timestamp, + __currencyCode.name() : __currencyCode, + __amount.name() : __amount + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'fingerPrintType', fingerPrintType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardArt with content type ELEMENT_ONLY +class cardArt (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardArt with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'cardArt') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 755, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardBrand uses Python identifier cardBrand + __cardBrand = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardBrand'), 'cardBrand', '__AnetApixmlv1schemaAnetApiSchema_xsd_cardArt_AnetApixmlv1schemaAnetApiSchema_xsdcardBrand', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 757, 6), ) + + + cardBrand = property(__cardBrand.value, __cardBrand.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardImageHeight uses Python identifier cardImageHeight + __cardImageHeight = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardImageHeight'), 'cardImageHeight', '__AnetApixmlv1schemaAnetApiSchema_xsd_cardArt_AnetApixmlv1schemaAnetApiSchema_xsdcardImageHeight', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 758, 6), ) + + + cardImageHeight = property(__cardImageHeight.value, __cardImageHeight.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardImageUrl uses Python identifier cardImageUrl + __cardImageUrl = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardImageUrl'), 'cardImageUrl', '__AnetApixmlv1schemaAnetApiSchema_xsd_cardArt_AnetApixmlv1schemaAnetApiSchema_xsdcardImageUrl', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 759, 6), ) + + + cardImageUrl = property(__cardImageUrl.value, __cardImageUrl.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardImageWidth uses Python identifier cardImageWidth + __cardImageWidth = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardImageWidth'), 'cardImageWidth', '__AnetApixmlv1schemaAnetApiSchema_xsd_cardArt_AnetApixmlv1schemaAnetApiSchema_xsdcardImageWidth', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 760, 6), ) + + + cardImageWidth = property(__cardImageWidth.value, __cardImageWidth.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardType uses Python identifier cardType + __cardType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardType'), 'cardType', '__AnetApixmlv1schemaAnetApiSchema_xsd_cardArt_AnetApixmlv1schemaAnetApiSchema_xsdcardType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 761, 6), ) + + + cardType = property(__cardType.value, __cardType.set, None, None) + + _ElementMap.update({ + __cardBrand.name() : __cardBrand, + __cardImageHeight.name() : __cardImageHeight, + __cardImageUrl.name() : __cardImageUrl, + __cardImageWidth.name() : __cardImageWidth, + __cardType.name() : __cardType + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'cardArt', cardArt) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentDetails with content type ELEMENT_ONLY +class paymentDetails (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentDetails with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'paymentDetails') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 765, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}currency uses Python identifier currency + __currency = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'currency'), 'currency', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentDetails_AnetApixmlv1schemaAnetApiSchema_xsdcurrency', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 767, 6), ) + + + currency = property(__currency.value, __currency.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}promoCode uses Python identifier promoCode + __promoCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'promoCode'), 'promoCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentDetails_AnetApixmlv1schemaAnetApiSchema_xsdpromoCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 768, 6), ) + + + promoCode = property(__promoCode.value, __promoCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}misc uses Python identifier misc + __misc = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'misc'), 'misc', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentDetails_AnetApixmlv1schemaAnetApiSchema_xsdmisc', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 769, 6), ) + + + misc = property(__misc.value, __misc.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}giftWrap uses Python identifier giftWrap + __giftWrap = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'giftWrap'), 'giftWrap', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentDetails_AnetApixmlv1schemaAnetApiSchema_xsdgiftWrap', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 770, 6), ) + + + giftWrap = property(__giftWrap.value, __giftWrap.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}discount uses Python identifier discount + __discount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'discount'), 'discount', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentDetails_AnetApixmlv1schemaAnetApiSchema_xsddiscount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 771, 6), ) + + + discount = property(__discount.value, __discount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}tax uses Python identifier tax + __tax = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'tax'), 'tax', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentDetails_AnetApixmlv1schemaAnetApiSchema_xsdtax', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 772, 6), ) + + + tax = property(__tax.value, __tax.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shippingHandling uses Python identifier shippingHandling + __shippingHandling = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shippingHandling'), 'shippingHandling', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentDetails_AnetApixmlv1schemaAnetApiSchema_xsdshippingHandling', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 773, 6), ) + + + shippingHandling = property(__shippingHandling.value, __shippingHandling.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subTotal uses Python identifier subTotal + __subTotal = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subTotal'), 'subTotal', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentDetails_AnetApixmlv1schemaAnetApiSchema_xsdsubTotal', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 774, 6), ) + + + subTotal = property(__subTotal.value, __subTotal.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}orderID uses Python identifier orderID + __orderID = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'orderID'), 'orderID', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentDetails_AnetApixmlv1schemaAnetApiSchema_xsdorderID', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 775, 6), ) + + + orderID = property(__orderID.value, __orderID.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount uses Python identifier amount + __amount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'amount'), 'amount', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentDetails_AnetApixmlv1schemaAnetApiSchema_xsdamount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 776, 6), ) + + + amount = property(__amount.value, __amount.set, None, None) + + _ElementMap.update({ + __currency.name() : __currency, + __promoCode.name() : __promoCode, + __misc.name() : __misc, + __giftWrap.name() : __giftWrap, + __discount.name() : __discount, + __tax.name() : __tax, + __shippingHandling.name() : __shippingHandling, + __subTotal.name() : __subTotal, + __orderID.name() : __orderID, + __amount.name() : __amount + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'paymentDetails', paymentDetails) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}impersonationAuthenticationType with content type ELEMENT_ONLY +class impersonationAuthenticationType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}impersonationAuthenticationType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'impersonationAuthenticationType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 811, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}partnerLoginId uses Python identifier partnerLoginId + __partnerLoginId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'partnerLoginId'), 'partnerLoginId', '__AnetApixmlv1schemaAnetApiSchema_xsd_impersonationAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdpartnerLoginId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 813, 6), ) + + + partnerLoginId = property(__partnerLoginId.value, __partnerLoginId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}partnerTransactionKey uses Python identifier partnerTransactionKey + __partnerTransactionKey = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'partnerTransactionKey'), 'partnerTransactionKey', '__AnetApixmlv1schemaAnetApiSchema_xsd_impersonationAuthenticationType_AnetApixmlv1schemaAnetApiSchema_xsdpartnerTransactionKey', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 820, 6), ) + + + partnerTransactionKey = property(__partnerTransactionKey.value, __partnerTransactionKey.set, None, None) + + _ElementMap.update({ + __partnerLoginId.name() : __partnerLoginId, + __partnerTransactionKey.name() : __partnerTransactionKey + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'impersonationAuthenticationType', impersonationAuthenticationType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentScheduleType with content type ELEMENT_ONLY +class paymentScheduleType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentScheduleType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'paymentScheduleType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 830, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}interval uses Python identifier interval + __interval = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'interval'), 'interval', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentScheduleType_AnetApixmlv1schemaAnetApiSchema_xsdinterval', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 833, 3), ) + + + interval = property(__interval.value, __interval.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}startDate uses Python identifier startDate + __startDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'startDate'), 'startDate', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentScheduleType_AnetApixmlv1schemaAnetApiSchema_xsdstartDate', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 849, 3), ) + + + startDate = property(__startDate.value, __startDate.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}totalOccurrences uses Python identifier totalOccurrences + __totalOccurrences = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'totalOccurrences'), 'totalOccurrences', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentScheduleType_AnetApixmlv1schemaAnetApiSchema_xsdtotalOccurrences', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 851, 3), ) + + + totalOccurrences = property(__totalOccurrences.value, __totalOccurrences.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}trialOccurrences uses Python identifier trialOccurrences + __trialOccurrences = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'trialOccurrences'), 'trialOccurrences', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentScheduleType_AnetApixmlv1schemaAnetApiSchema_xsdtrialOccurrences', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 860, 3), ) + + + trialOccurrences = property(__trialOccurrences.value, __trialOccurrences.set, None, None) + + _ElementMap.update({ + __interval.name() : __interval, + __startDate.name() : __startDate, + __totalOccurrences.name() : __totalOccurrences, + __trialOccurrences.name() : __trialOccurrences + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'paymentScheduleType', paymentScheduleType) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 834, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}length uses Python identifier length + __length = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'length'), 'length', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_AnetApixmlv1schemaAnetApiSchema_xsdlength', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 836, 6), ) + + + length = property(__length.value, __length.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}unit uses Python identifier unit + __unit = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'unit'), 'unit', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_AnetApixmlv1schemaAnetApiSchema_xsdunit', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 844, 6), ) + + + unit = property(__unit.value, __unit.set, None, None) + + _ElementMap.update({ + __length.name() : __length, + __unit.name() : __unit + }) + _AttributeMap.update({ + + }) + + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ARBSubscriptionType with content type ELEMENT_ONLY +class ARBSubscriptionType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ARBSubscriptionType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ARBSubscriptionType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 871, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}name uses Python identifier name + __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'name'), 'name', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBSubscriptionType_AnetApixmlv1schemaAnetApiSchema_xsdname', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 873, 3), ) + + + name = property(__name.value, __name.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentSchedule uses Python identifier paymentSchedule + __paymentSchedule = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentSchedule'), 'paymentSchedule', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBSubscriptionType_AnetApixmlv1schemaAnetApiSchema_xsdpaymentSchedule', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 881, 3), ) + + + paymentSchedule = property(__paymentSchedule.value, __paymentSchedule.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount uses Python identifier amount + __amount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'amount'), 'amount', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBSubscriptionType_AnetApixmlv1schemaAnetApiSchema_xsdamount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 882, 3), ) + + + amount = property(__amount.value, __amount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}trialAmount uses Python identifier trialAmount + __trialAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'trialAmount'), 'trialAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBSubscriptionType_AnetApixmlv1schemaAnetApiSchema_xsdtrialAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 890, 3), ) + + + trialAmount = property(__trialAmount.value, __trialAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}payment uses Python identifier payment + __payment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'payment'), 'payment', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBSubscriptionType_AnetApixmlv1schemaAnetApiSchema_xsdpayment', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 899, 3), ) + + + payment = property(__payment.value, __payment.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}order uses Python identifier order + __order = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'order'), 'order', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBSubscriptionType_AnetApixmlv1schemaAnetApiSchema_xsdorder', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 900, 3), ) + + + order = property(__order.value, __order.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customer uses Python identifier customer + __customer = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customer'), 'customer', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBSubscriptionType_AnetApixmlv1schemaAnetApiSchema_xsdcustomer', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 901, 3), ) + + + customer = property(__customer.value, __customer.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}billTo uses Python identifier billTo + __billTo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'billTo'), 'billTo', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBSubscriptionType_AnetApixmlv1schemaAnetApiSchema_xsdbillTo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 902, 3), ) + + + billTo = property(__billTo.value, __billTo.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipTo uses Python identifier shipTo + __shipTo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shipTo'), 'shipTo', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBSubscriptionType_AnetApixmlv1schemaAnetApiSchema_xsdshipTo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 903, 3), ) + + + shipTo = property(__shipTo.value, __shipTo.set, None, None) + + _ElementMap.update({ + __name.name() : __name, + __paymentSchedule.name() : __paymentSchedule, + __amount.name() : __amount, + __trialAmount.name() : __trialAmount, + __payment.name() : __payment, + __order.name() : __order, + __customer.name() : __customer, + __billTo.name() : __billTo, + __shipTo.name() : __shipTo + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ARBSubscriptionType', ARBSubscriptionType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscriptionPaymentType with content type ELEMENT_ONLY +class subscriptionPaymentType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscriptionPaymentType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'subscriptionPaymentType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 907, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}id uses Python identifier id + __id = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'id'), 'id', '__AnetApixmlv1schemaAnetApiSchema_xsd_subscriptionPaymentType_AnetApixmlv1schemaAnetApiSchema_xsdid', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 909, 6), ) + + + id = property(__id.value, __id.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}payNum uses Python identifier payNum + __payNum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'payNum'), 'payNum', '__AnetApixmlv1schemaAnetApiSchema_xsd_subscriptionPaymentType_AnetApixmlv1schemaAnetApiSchema_xsdpayNum', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 916, 6), ) + + + payNum = property(__payNum.value, __payNum.set, None, None) + + _ElementMap.update({ + __id.name() : __id, + __payNum.name() : __payNum + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'subscriptionPaymentType', subscriptionPaymentType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}mobileDeviceType with content type ELEMENT_ONLY +class mobileDeviceType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}mobileDeviceType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 926, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}mobileDeviceId uses Python identifier mobileDeviceId + __mobileDeviceId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId'), 'mobileDeviceId', '__AnetApixmlv1schemaAnetApiSchema_xsd_mobileDeviceType_AnetApixmlv1schemaAnetApiSchema_xsdmobileDeviceId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 928, 3), ) + + + mobileDeviceId = property(__mobileDeviceId.value, __mobileDeviceId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}description uses Python identifier description + __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'description'), 'description', '__AnetApixmlv1schemaAnetApiSchema_xsd_mobileDeviceType_AnetApixmlv1schemaAnetApiSchema_xsddescription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 935, 3), ) + + + description = property(__description.value, __description.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}phoneNumber uses Python identifier phoneNumber + __phoneNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'phoneNumber'), 'phoneNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_mobileDeviceType_AnetApixmlv1schemaAnetApiSchema_xsdphoneNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 942, 3), ) + + + phoneNumber = property(__phoneNumber.value, __phoneNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}devicePlatform uses Python identifier devicePlatform + __devicePlatform = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'devicePlatform'), 'devicePlatform', '__AnetApixmlv1schemaAnetApiSchema_xsd_mobileDeviceType_AnetApixmlv1schemaAnetApiSchema_xsddevicePlatform', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 949, 6), ) + + + devicePlatform = property(__devicePlatform.value, __devicePlatform.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}deviceActivation uses Python identifier deviceActivation + __deviceActivation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'deviceActivation'), 'deviceActivation', '__AnetApixmlv1schemaAnetApiSchema_xsd_mobileDeviceType_AnetApixmlv1schemaAnetApiSchema_xsddeviceActivation', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 956, 6), ) + + + deviceActivation = property(__deviceActivation.value, __deviceActivation.set, None, None) + + _ElementMap.update({ + __mobileDeviceId.name() : __mobileDeviceId, + __description.name() : __description, + __phoneNumber.name() : __phoneNumber, + __devicePlatform.name() : __devicePlatform, + __deviceActivation.name() : __deviceActivation + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'mobileDeviceType', mobileDeviceType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionRequestType with content type ELEMENT_ONLY +class transactionRequestType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionRequestType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'transactionRequestType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 965, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionType uses Python identifier transactionType + __transactionType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionType'), 'transactionType', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdtransactionType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 967, 3), ) + + + transactionType = property(__transactionType.value, __transactionType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount uses Python identifier amount + __amount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'amount'), 'amount', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdamount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 968, 3), ) + + + amount = property(__amount.value, __amount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}currencyCode uses Python identifier currencyCode + __currencyCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'currencyCode'), 'currencyCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdcurrencyCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 969, 6), ) + + + currencyCode = property(__currencyCode.value, __currencyCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}payment uses Python identifier payment + __payment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'payment'), 'payment', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdpayment', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 970, 3), ) + + + payment = property(__payment.value, __payment.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profile uses Python identifier profile + __profile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profile'), 'profile', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdprofile', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 971, 6), ) + + + profile = property(__profile.value, __profile.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}solution uses Python identifier solution + __solution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'solution'), 'solution', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdsolution', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 972, 6), ) + + + solution = property(__solution.value, __solution.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}callId uses Python identifier callId + __callId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'callId'), 'callId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdcallId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 973, 6), ) + + + callId = property(__callId.value, __callId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}authCode uses Python identifier authCode + __authCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'authCode'), 'authCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdauthCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 974, 3), ) + + + authCode = property(__authCode.value, __authCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refTransId uses Python identifier refTransId + __refTransId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refTransId'), 'refTransId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdrefTransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 975, 3), ) + + + refTransId = property(__refTransId.value, __refTransId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderId uses Python identifier splitTenderId + __splitTenderId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId'), 'splitTenderId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdsplitTenderId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 976, 3), ) + + + splitTenderId = property(__splitTenderId.value, __splitTenderId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}order uses Python identifier order + __order = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'order'), 'order', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdorder', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 977, 3), ) + + + order = property(__order.value, __order.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItems uses Python identifier lineItems + __lineItems = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'lineItems'), 'lineItems', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdlineItems', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 978, 3), ) + + + lineItems = property(__lineItems.value, __lineItems.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}tax uses Python identifier tax + __tax = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'tax'), 'tax', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdtax', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 979, 3), ) + + + tax = property(__tax.value, __tax.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}duty uses Python identifier duty + __duty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'duty'), 'duty', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdduty', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 980, 3), ) + + + duty = property(__duty.value, __duty.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipping uses Python identifier shipping + __shipping = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shipping'), 'shipping', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdshipping', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 981, 3), ) + + + shipping = property(__shipping.value, __shipping.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxExempt uses Python identifier taxExempt + __taxExempt = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'taxExempt'), 'taxExempt', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdtaxExempt', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 982, 3), ) + + + taxExempt = property(__taxExempt.value, __taxExempt.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}poNumber uses Python identifier poNumber + __poNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'poNumber'), 'poNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdpoNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 987, 3), ) + + + poNumber = property(__poNumber.value, __poNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customer uses Python identifier customer + __customer = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customer'), 'customer', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdcustomer', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 988, 3), ) + + + customer = property(__customer.value, __customer.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}billTo uses Python identifier billTo + __billTo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'billTo'), 'billTo', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdbillTo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 989, 3), ) + + + billTo = property(__billTo.value, __billTo.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipTo uses Python identifier shipTo + __shipTo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shipTo'), 'shipTo', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdshipTo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 990, 3), ) + + + shipTo = property(__shipTo.value, __shipTo.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerIP uses Python identifier customerIP + __customerIP = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerIP'), 'customerIP', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerIP', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 991, 3), ) + + + customerIP = property(__customerIP.value, __customerIP.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardholderAuthentication uses Python identifier cardholderAuthentication + __cardholderAuthentication = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardholderAuthentication'), 'cardholderAuthentication', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdcardholderAuthentication', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 992, 3), ) + + + cardholderAuthentication = property(__cardholderAuthentication.value, __cardholderAuthentication.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}retail uses Python identifier retail + __retail = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'retail'), 'retail', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdretail', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 993, 3), ) + + + retail = property(__retail.value, __retail.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}employeeId uses Python identifier employeeId + __employeeId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'employeeId'), 'employeeId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdemployeeId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 994, 6), ) + + + employeeId = property(__employeeId.value, __employeeId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionSettings uses Python identifier transactionSettings + __transactionSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionSettings'), 'transactionSettings', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsdtransactionSettings', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 995, 3), ) + + + transactionSettings = property(__transactionSettings.value, __transactionSettings.set, None, 'Allowed values for settingName are: emailCustomer, merchantEmail, allowPartialAuth, headerEmailReceipt, footerEmailReceipt, recurringBilling, duplicateWindow, testRequest.') + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}userFields uses Python identifier userFields + __userFields = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'userFields'), 'userFields', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionRequestType_AnetApixmlv1schemaAnetApiSchema_xsduserFields', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1000, 3), ) + + + userFields = property(__userFields.value, __userFields.set, None, None) + + _ElementMap.update({ + __transactionType.name() : __transactionType, + __amount.name() : __amount, + __currencyCode.name() : __currencyCode, + __payment.name() : __payment, + __profile.name() : __profile, + __solution.name() : __solution, + __callId.name() : __callId, + __authCode.name() : __authCode, + __refTransId.name() : __refTransId, + __splitTenderId.name() : __splitTenderId, + __order.name() : __order, + __lineItems.name() : __lineItems, + __tax.name() : __tax, + __duty.name() : __duty, + __shipping.name() : __shipping, + __taxExempt.name() : __taxExempt, + __poNumber.name() : __poNumber, + __customer.name() : __customer, + __billTo.name() : __billTo, + __shipTo.name() : __shipTo, + __customerIP.name() : __customerIP, + __cardholderAuthentication.name() : __cardholderAuthentication, + __retail.name() : __retail, + __employeeId.name() : __employeeId, + __transactionSettings.name() : __transactionSettings, + __userFields.name() : __userFields + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'transactionRequestType', transactionRequestType) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_ (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1001, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}userField uses Python identifier userField + __userField = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'userField'), 'userField', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON__AnetApixmlv1schemaAnetApiSchema_xsduserField', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1003, 6), ) + + + userField = property(__userField.value, __userField.set, None, None) + + _ElementMap.update({ + __userField.name() : __userField + }) + _AttributeMap.update({ + + }) + + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}KeyManagementScheme with content type ELEMENT_ONLY +class KeyManagementScheme (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}KeyManagementScheme with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'KeyManagementScheme') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1010, 3) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}DUKPT uses Python identifier DUKPT + __DUKPT = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DUKPT'), 'DUKPT', '__AnetApixmlv1schemaAnetApiSchema_xsd_KeyManagementScheme_AnetApixmlv1schemaAnetApiSchema_xsdDUKPT', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1012, 7), ) + + + DUKPT = property(__DUKPT.value, __DUKPT.set, None, None) + + _ElementMap.update({ + __DUKPT.name() : __DUKPT + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'KeyManagementScheme', KeyManagementScheme) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_2 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1013, 9) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}Operation uses Python identifier Operation + __Operation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Operation'), 'Operation', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_2_AnetApixmlv1schemaAnetApiSchema_xsdOperation', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1015, 13), ) + + + Operation = property(__Operation.value, __Operation.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}Mode uses Python identifier Mode + __Mode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Mode'), 'Mode', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_2_AnetApixmlv1schemaAnetApiSchema_xsdMode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1016, 13), ) + + + Mode = property(__Mode.value, __Mode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}DeviceInfo uses Python identifier DeviceInfo + __DeviceInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DeviceInfo'), 'DeviceInfo', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_2_AnetApixmlv1schemaAnetApiSchema_xsdDeviceInfo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1024, 13), ) + + + DeviceInfo = property(__DeviceInfo.value, __DeviceInfo.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}EncryptedData uses Python identifier EncryptedData + __EncryptedData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'EncryptedData'), 'EncryptedData', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_2_AnetApixmlv1schemaAnetApiSchema_xsdEncryptedData', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1031, 13), ) + + + EncryptedData = property(__EncryptedData.value, __EncryptedData.set, None, None) + + _ElementMap.update({ + __Operation.name() : __Operation, + __Mode.name() : __Mode, + __DeviceInfo.name() : __DeviceInfo, + __EncryptedData.name() : __EncryptedData + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_3 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1017, 15) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}PIN uses Python identifier PIN + __PIN = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'PIN'), 'PIN', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_3_AnetApixmlv1schemaAnetApiSchema_xsdPIN', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1019, 19), ) + + + PIN = property(__PIN.value, __PIN.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}Data uses Python identifier Data + __Data = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Data'), 'Data', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_3_AnetApixmlv1schemaAnetApiSchema_xsdData', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1020, 19), ) + + + Data = property(__Data.value, __Data.set, None, None) + + _ElementMap.update({ + __PIN.name() : __PIN, + __Data.name() : __Data + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_4 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1025, 15) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}Description uses Python identifier Description + __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_4_AnetApixmlv1schemaAnetApiSchema_xsdDescription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1027, 19), ) + + + Description = property(__Description.value, __Description.set, None, None) + + _ElementMap.update({ + __Description.name() : __Description + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_5 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1032, 15) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}Value uses Python identifier Value + __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_5_AnetApixmlv1schemaAnetApiSchema_xsdValue', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1034, 19), ) + + + Value = property(__Value.value, __Value.set, None, None) + + _ElementMap.update({ + __Value.name() : __Value + }) + _AttributeMap.update({ + + }) + + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}KeyValue with content type ELEMENT_ONLY +class KeyValue (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}KeyValue with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'KeyValue') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1061, 3) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}Encoding uses Python identifier Encoding + __Encoding = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Encoding'), 'Encoding', '__AnetApixmlv1schemaAnetApiSchema_xsd_KeyValue_AnetApixmlv1schemaAnetApiSchema_xsdEncoding', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1063, 7), ) + + + Encoding = property(__Encoding.value, __Encoding.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}EncryptionAlgorithm uses Python identifier EncryptionAlgorithm + __EncryptionAlgorithm = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'EncryptionAlgorithm'), 'EncryptionAlgorithm', '__AnetApixmlv1schemaAnetApiSchema_xsd_KeyValue_AnetApixmlv1schemaAnetApiSchema_xsdEncryptionAlgorithm', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1064, 7), ) + + + EncryptionAlgorithm = property(__EncryptionAlgorithm.value, __EncryptionAlgorithm.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}Scheme uses Python identifier Scheme + __Scheme = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Scheme'), 'Scheme', '__AnetApixmlv1schemaAnetApiSchema_xsd_KeyValue_AnetApixmlv1schemaAnetApiSchema_xsdScheme', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1065, 7), ) + + + Scheme = property(__Scheme.value, __Scheme.set, None, None) + + _ElementMap.update({ + __Encoding.name() : __Encoding, + __EncryptionAlgorithm.name() : __EncryptionAlgorithm, + __Scheme.name() : __Scheme + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'KeyValue', KeyValue) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}KeyBlock with content type ELEMENT_ONLY +class KeyBlock (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}KeyBlock with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'KeyBlock') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1068, 3) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}Value uses Python identifier Value + __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__AnetApixmlv1schemaAnetApiSchema_xsd_KeyBlock_AnetApixmlv1schemaAnetApiSchema_xsdValue', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1070, 12), ) + + + Value = property(__Value.value, __Value.set, None, None) + + _ElementMap.update({ + __Value.name() : __Value + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'KeyBlock', KeyBlock) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}encryptedTrackDataType with content type ELEMENT_ONLY +class encryptedTrackDataType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}encryptedTrackDataType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'encryptedTrackDataType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1073, 3) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}FormOfPayment uses Python identifier FormOfPayment + __FormOfPayment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FormOfPayment'), 'FormOfPayment', '__AnetApixmlv1schemaAnetApiSchema_xsd_encryptedTrackDataType_AnetApixmlv1schemaAnetApiSchema_xsdFormOfPayment', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1075, 7), ) + + + FormOfPayment = property(__FormOfPayment.value, __FormOfPayment.set, None, None) + + _ElementMap.update({ + __FormOfPayment.name() : __FormOfPayment + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'encryptedTrackDataType', encryptedTrackDataType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settingType with content type ELEMENT_ONLY +class settingType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settingType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'settingType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1079, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settingName uses Python identifier settingName + __settingName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'settingName'), 'settingName', '__AnetApixmlv1schemaAnetApiSchema_xsd_settingType_AnetApixmlv1schemaAnetApiSchema_xsdsettingName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1081, 3), ) + + + settingName = property(__settingName.value, __settingName.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settingValue uses Python identifier settingValue + __settingValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'settingValue'), 'settingValue', '__AnetApixmlv1schemaAnetApiSchema_xsd_settingType_AnetApixmlv1schemaAnetApiSchema_xsdsettingValue', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1082, 3), ) + + + settingValue = property(__settingValue.value, __settingValue.set, None, None) + + _ElementMap.update({ + __settingName.name() : __settingName, + __settingValue.name() : __settingValue + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'settingType', settingType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}permissionType with content type ELEMENT_ONLY +class permissionType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}permissionType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'permissionType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1086, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}permissionName uses Python identifier permissionName + __permissionName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'permissionName'), 'permissionName', '__AnetApixmlv1schemaAnetApiSchema_xsd_permissionType_AnetApixmlv1schemaAnetApiSchema_xsdpermissionName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1088, 3), ) + + + permissionName = property(__permissionName.value, __permissionName.set, None, None) + + _ElementMap.update({ + __permissionName.name() : __permissionName + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'permissionType', permissionType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}userField with content type ELEMENT_ONLY +class userField (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}userField with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'userField') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1182, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}name uses Python identifier name + __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'name'), 'name', '__AnetApixmlv1schemaAnetApiSchema_xsd_userField_AnetApixmlv1schemaAnetApiSchema_xsdname', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1184, 3), ) + + + name = property(__name.value, __name.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}value uses Python identifier value_ + __value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'value'), 'value_', '__AnetApixmlv1schemaAnetApiSchema_xsd_userField_AnetApixmlv1schemaAnetApiSchema_xsdvalue', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1185, 3), ) + + + value_ = property(__value.value, __value.set, None, None) + + _ElementMap.update({ + __name.name() : __name, + __value.name() : __value + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'userField', userField) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileBaseType with content type ELEMENT_ONLY +class customerPaymentProfileBaseType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileBaseType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileBaseType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1189, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerType uses Python identifier customerType + __customerType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerType'), 'customerType', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerPaymentProfileBaseType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1191, 3), ) + + + customerType = property(__customerType.value, __customerType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}billTo uses Python identifier billTo + __billTo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'billTo'), 'billTo', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerPaymentProfileBaseType_AnetApixmlv1schemaAnetApiSchema_xsdbillTo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1192, 3), ) + + + billTo = property(__billTo.value, __billTo.set, None, None) + + _ElementMap.update({ + __customerType.name() : __customerType, + __billTo.name() : __billTo + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerPaymentProfileBaseType', customerPaymentProfileBaseType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType with content type ELEMENT_ONLY +class customerProfileBaseType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerProfileBaseType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1245, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantCustomerId uses Python identifier merchantCustomerId + __merchantCustomerId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantCustomerId'), 'merchantCustomerId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfileBaseType_AnetApixmlv1schemaAnetApiSchema_xsdmerchantCustomerId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1247, 3), ) + + + merchantCustomerId = property(__merchantCustomerId.value, __merchantCustomerId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}description uses Python identifier description + __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'description'), 'description', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfileBaseType_AnetApixmlv1schemaAnetApiSchema_xsddescription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1254, 3), ) + + + description = property(__description.value, __description.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}email uses Python identifier email + __email = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'email'), 'email', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfileBaseType_AnetApixmlv1schemaAnetApiSchema_xsdemail', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1261, 3), ) + + + email = property(__email.value, __email.set, None, None) + + _ElementMap.update({ + __merchantCustomerId.name() : __merchantCustomerId, + __description.name() : __description, + __email.name() : __email + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerProfileBaseType', customerProfileBaseType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}extendedAmountType with content type ELEMENT_ONLY +class extendedAmountType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}extendedAmountType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'extendedAmountType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1337, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount uses Python identifier amount + __amount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'amount'), 'amount', '__AnetApixmlv1schemaAnetApiSchema_xsd_extendedAmountType_AnetApixmlv1schemaAnetApiSchema_xsdamount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1339, 3), ) + + + amount = property(__amount.value, __amount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}name uses Python identifier name + __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'name'), 'name', '__AnetApixmlv1schemaAnetApiSchema_xsd_extendedAmountType_AnetApixmlv1schemaAnetApiSchema_xsdname', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1347, 3), ) + + + name = property(__name.value, __name.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}description uses Python identifier description + __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'description'), 'description', '__AnetApixmlv1schemaAnetApiSchema_xsd_extendedAmountType_AnetApixmlv1schemaAnetApiSchema_xsddescription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1354, 3), ) + + + description = property(__description.value, __description.set, None, None) + + _ElementMap.update({ + __amount.name() : __amount, + __name.name() : __name, + __description.name() : __description + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'extendedAmountType', extendedAmountType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItemType with content type ELEMENT_ONLY +class lineItemType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItemType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'lineItemType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1364, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}itemId uses Python identifier itemId + __itemId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'itemId'), 'itemId', '__AnetApixmlv1schemaAnetApiSchema_xsd_lineItemType_AnetApixmlv1schemaAnetApiSchema_xsditemId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1366, 3), ) + + + itemId = property(__itemId.value, __itemId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}name uses Python identifier name + __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'name'), 'name', '__AnetApixmlv1schemaAnetApiSchema_xsd_lineItemType_AnetApixmlv1schemaAnetApiSchema_xsdname', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1374, 3), ) + + + name = property(__name.value, __name.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}description uses Python identifier description + __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'description'), 'description', '__AnetApixmlv1schemaAnetApiSchema_xsd_lineItemType_AnetApixmlv1schemaAnetApiSchema_xsddescription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1382, 3), ) + + + description = property(__description.value, __description.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}quantity uses Python identifier quantity + __quantity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'quantity'), 'quantity', '__AnetApixmlv1schemaAnetApiSchema_xsd_lineItemType_AnetApixmlv1schemaAnetApiSchema_xsdquantity', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1389, 3), ) + + + quantity = property(__quantity.value, __quantity.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}unitPrice uses Python identifier unitPrice + __unitPrice = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'unitPrice'), 'unitPrice', '__AnetApixmlv1schemaAnetApiSchema_xsd_lineItemType_AnetApixmlv1schemaAnetApiSchema_xsdunitPrice', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1397, 3), ) + + + unitPrice = property(__unitPrice.value, __unitPrice.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxable uses Python identifier taxable + __taxable = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'taxable'), 'taxable', '__AnetApixmlv1schemaAnetApiSchema_xsd_lineItemType_AnetApixmlv1schemaAnetApiSchema_xsdtaxable', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1405, 3), ) + + + taxable = property(__taxable.value, __taxable.set, None, None) + + _ElementMap.update({ + __itemId.name() : __itemId, + __name.name() : __name, + __description.name() : __description, + __quantity.name() : __quantity, + __unitPrice.name() : __unitPrice, + __taxable.name() : __taxable + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'lineItemType', lineItemType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType with content type ELEMENT_ONLY +class profileTransAmountType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'profileTransAmountType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1409, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount uses Python identifier amount + __amount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'amount'), 'amount', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransAmountType_AnetApixmlv1schemaAnetApiSchema_xsdamount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1411, 3), ) + + + amount = property(__amount.value, __amount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}tax uses Python identifier tax + __tax = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'tax'), 'tax', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransAmountType_AnetApixmlv1schemaAnetApiSchema_xsdtax', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3), ) + + + tax = property(__tax.value, __tax.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipping uses Python identifier shipping + __shipping = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shipping'), 'shipping', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransAmountType_AnetApixmlv1schemaAnetApiSchema_xsdshipping', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3), ) + + + shipping = property(__shipping.value, __shipping.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}duty uses Python identifier duty + __duty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'duty'), 'duty', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransAmountType_AnetApixmlv1schemaAnetApiSchema_xsdduty', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3), ) + + + duty = property(__duty.value, __duty.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItems uses Python identifier lineItems + __lineItems = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'lineItems'), 'lineItems', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransAmountType_AnetApixmlv1schemaAnetApiSchema_xsdlineItems', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3), ) + + + lineItems = property(__lineItems.value, __lineItems.set, None, None) + + _ElementMap.update({ + __amount.name() : __amount, + __tax.name() : __tax, + __shipping.name() : __shipping, + __duty.name() : __duty, + __lineItems.name() : __lineItems + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'profileTransAmountType', profileTransAmountType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransVoidType with content type ELEMENT_ONLY +class profileTransVoidType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransVoidType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'profileTransVoidType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1527, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransVoidType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1529, 3), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId uses Python identifier customerPaymentProfileId + __customerPaymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), 'customerPaymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransVoidType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1530, 3), ) + + + customerPaymentProfileId = property(__customerPaymentProfileId.value, __customerPaymentProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerShippingAddressId uses Python identifier customerShippingAddressId + __customerShippingAddressId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId'), 'customerShippingAddressId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransVoidType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerShippingAddressId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1531, 3), ) + + + customerShippingAddressId = property(__customerShippingAddressId.value, __customerShippingAddressId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transId uses Python identifier transId + __transId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transId'), 'transId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransVoidType_AnetApixmlv1schemaAnetApiSchema_xsdtransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1532, 3), ) + + + transId = property(__transId.value, __transId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __customerPaymentProfileId.name() : __customerPaymentProfileId, + __customerShippingAddressId.name() : __customerShippingAddressId, + __transId.name() : __transId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'profileTransVoidType', profileTransVoidType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransactionType with content type ELEMENT_ONLY +class profileTransactionType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransactionType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'profileTransactionType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1536, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAuthCapture uses Python identifier profileTransAuthCapture + __profileTransAuthCapture = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profileTransAuthCapture'), 'profileTransAuthCapture', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransactionType_AnetApixmlv1schemaAnetApiSchema_xsdprofileTransAuthCapture', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1538, 3), ) + + + profileTransAuthCapture = property(__profileTransAuthCapture.value, __profileTransAuthCapture.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAuthOnly uses Python identifier profileTransAuthOnly + __profileTransAuthOnly = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profileTransAuthOnly'), 'profileTransAuthOnly', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransactionType_AnetApixmlv1schemaAnetApiSchema_xsdprofileTransAuthOnly', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1539, 3), ) + + + profileTransAuthOnly = property(__profileTransAuthOnly.value, __profileTransAuthOnly.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransPriorAuthCapture uses Python identifier profileTransPriorAuthCapture + __profileTransPriorAuthCapture = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profileTransPriorAuthCapture'), 'profileTransPriorAuthCapture', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransactionType_AnetApixmlv1schemaAnetApiSchema_xsdprofileTransPriorAuthCapture', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1540, 3), ) + + + profileTransPriorAuthCapture = property(__profileTransPriorAuthCapture.value, __profileTransPriorAuthCapture.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransCaptureOnly uses Python identifier profileTransCaptureOnly + __profileTransCaptureOnly = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profileTransCaptureOnly'), 'profileTransCaptureOnly', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransactionType_AnetApixmlv1schemaAnetApiSchema_xsdprofileTransCaptureOnly', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1541, 3), ) + + + profileTransCaptureOnly = property(__profileTransCaptureOnly.value, __profileTransCaptureOnly.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransRefund uses Python identifier profileTransRefund + __profileTransRefund = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profileTransRefund'), 'profileTransRefund', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransactionType_AnetApixmlv1schemaAnetApiSchema_xsdprofileTransRefund', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1542, 3), ) + + + profileTransRefund = property(__profileTransRefund.value, __profileTransRefund.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransVoid uses Python identifier profileTransVoid + __profileTransVoid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profileTransVoid'), 'profileTransVoid', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransactionType_AnetApixmlv1schemaAnetApiSchema_xsdprofileTransVoid', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1543, 3), ) + + + profileTransVoid = property(__profileTransVoid.value, __profileTransVoid.set, None, None) + + _ElementMap.update({ + __profileTransAuthCapture.name() : __profileTransAuthCapture, + __profileTransAuthOnly.name() : __profileTransAuthOnly, + __profileTransPriorAuthCapture.name() : __profileTransPriorAuthCapture, + __profileTransCaptureOnly.name() : __profileTransCaptureOnly, + __profileTransRefund.name() : __profileTransRefund, + __profileTransVoid.name() : __profileTransVoid + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'profileTransactionType', profileTransactionType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionSummaryType with content type ELEMENT_ONLY +class transactionSummaryType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionSummaryType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'transactionSummaryType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1547, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transId uses Python identifier transId + __transId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transId'), 'transId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdtransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1549, 3), ) + + + transId = property(__transId.value, __transId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}submitTimeUTC uses Python identifier submitTimeUTC + __submitTimeUTC = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'submitTimeUTC'), 'submitTimeUTC', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdsubmitTimeUTC', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1550, 3), ) + + + submitTimeUTC = property(__submitTimeUTC.value, __submitTimeUTC.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}submitTimeLocal uses Python identifier submitTimeLocal + __submitTimeLocal = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'submitTimeLocal'), 'submitTimeLocal', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdsubmitTimeLocal', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1551, 3), ) + + + submitTimeLocal = property(__submitTimeLocal.value, __submitTimeLocal.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionStatus uses Python identifier transactionStatus + __transactionStatus = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionStatus'), 'transactionStatus', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdtransactionStatus', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1552, 3), ) + + + transactionStatus = property(__transactionStatus.value, __transactionStatus.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}invoiceNumber uses Python identifier invoiceNumber + __invoiceNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'invoiceNumber'), 'invoiceNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdinvoiceNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1553, 3), ) + + + invoiceNumber = property(__invoiceNumber.value, __invoiceNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}firstName uses Python identifier firstName + __firstName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'firstName'), 'firstName', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdfirstName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1554, 3), ) + + + firstName = property(__firstName.value, __firstName.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}lastName uses Python identifier lastName + __lastName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'lastName'), 'lastName', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdlastName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1555, 3), ) + + + lastName = property(__lastName.value, __lastName.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountType uses Python identifier accountType + __accountType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountType'), 'accountType', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdaccountType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1556, 3), ) + + + accountType = property(__accountType.value, __accountType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountNumber uses Python identifier accountNumber + __accountNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), 'accountNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdaccountNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1557, 3), ) + + + accountNumber = property(__accountNumber.value, __accountNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settleAmount uses Python identifier settleAmount + __settleAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'settleAmount'), 'settleAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdsettleAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1558, 3), ) + + + settleAmount = property(__settleAmount.value, __settleAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}marketType uses Python identifier marketType + __marketType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'marketType'), 'marketType', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdmarketType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1559, 3), ) + + + marketType = property(__marketType.value, __marketType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}product uses Python identifier product + __product = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'product'), 'product', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdproduct', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1560, 3), ) + + + product = property(__product.value, __product.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}mobileDeviceId uses Python identifier mobileDeviceId + __mobileDeviceId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId'), 'mobileDeviceId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdmobileDeviceId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1561, 3), ) + + + mobileDeviceId = property(__mobileDeviceId.value, __mobileDeviceId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscription uses Python identifier subscription + __subscription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subscription'), 'subscription', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdsubscription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1562, 3), ) + + + subscription = property(__subscription.value, __subscription.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}hasReturnedItems uses Python identifier hasReturnedItems + __hasReturnedItems = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'hasReturnedItems'), 'hasReturnedItems', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdhasReturnedItems', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1563, 9), ) + + + hasReturnedItems = property(__hasReturnedItems.value, __hasReturnedItems.set, None, None) + + _ElementMap.update({ + __transId.name() : __transId, + __submitTimeUTC.name() : __submitTimeUTC, + __submitTimeLocal.name() : __submitTimeLocal, + __transactionStatus.name() : __transactionStatus, + __invoiceNumber.name() : __invoiceNumber, + __firstName.name() : __firstName, + __lastName.name() : __lastName, + __accountType.name() : __accountType, + __accountNumber.name() : __accountNumber, + __settleAmount.name() : __settleAmount, + __marketType.name() : __marketType, + __product.name() : __product, + __mobileDeviceId.name() : __mobileDeviceId, + __subscription.name() : __subscription, + __hasReturnedItems.name() : __hasReturnedItems + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'transactionSummaryType', transactionSummaryType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionDetailsType with content type ELEMENT_ONLY +class transactionDetailsType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionDetailsType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'transactionDetailsType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1567, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transId uses Python identifier transId + __transId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transId'), 'transId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdtransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1569, 3), ) + + + transId = property(__transId.value, __transId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refTransId uses Python identifier refTransId + __refTransId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refTransId'), 'refTransId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdrefTransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1570, 3), ) + + + refTransId = property(__refTransId.value, __refTransId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderId uses Python identifier splitTenderId + __splitTenderId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId'), 'splitTenderId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdsplitTenderId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1571, 3), ) + + + splitTenderId = property(__splitTenderId.value, __splitTenderId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}submitTimeUTC uses Python identifier submitTimeUTC + __submitTimeUTC = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'submitTimeUTC'), 'submitTimeUTC', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdsubmitTimeUTC', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1572, 3), ) + + + submitTimeUTC = property(__submitTimeUTC.value, __submitTimeUTC.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}submitTimeLocal uses Python identifier submitTimeLocal + __submitTimeLocal = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'submitTimeLocal'), 'submitTimeLocal', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdsubmitTimeLocal', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1573, 3), ) + + + submitTimeLocal = property(__submitTimeLocal.value, __submitTimeLocal.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionType uses Python identifier transactionType + __transactionType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionType'), 'transactionType', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdtransactionType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1574, 3), ) + + + transactionType = property(__transactionType.value, __transactionType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionStatus uses Python identifier transactionStatus + __transactionStatus = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionStatus'), 'transactionStatus', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdtransactionStatus', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1575, 3), ) + + + transactionStatus = property(__transactionStatus.value, __transactionStatus.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}responseCode uses Python identifier responseCode + __responseCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'responseCode'), 'responseCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdresponseCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1576, 3), ) + + + responseCode = property(__responseCode.value, __responseCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}responseReasonCode uses Python identifier responseReasonCode + __responseReasonCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'responseReasonCode'), 'responseReasonCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdresponseReasonCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1577, 3), ) + + + responseReasonCode = property(__responseReasonCode.value, __responseReasonCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscription uses Python identifier subscription + __subscription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subscription'), 'subscription', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdsubscription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1578, 3), ) + + + subscription = property(__subscription.value, __subscription.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}responseReasonDescription uses Python identifier responseReasonDescription + __responseReasonDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'responseReasonDescription'), 'responseReasonDescription', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdresponseReasonDescription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1579, 3), ) + + + responseReasonDescription = property(__responseReasonDescription.value, __responseReasonDescription.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}authCode uses Python identifier authCode + __authCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'authCode'), 'authCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdauthCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1580, 6), ) + + + authCode = property(__authCode.value, __authCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}AVSResponse uses Python identifier AVSResponse + __AVSResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AVSResponse'), 'AVSResponse', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdAVSResponse', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1587, 3), ) + + + AVSResponse = property(__AVSResponse.value, __AVSResponse.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardCodeResponse uses Python identifier cardCodeResponse + __cardCodeResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardCodeResponse'), 'cardCodeResponse', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdcardCodeResponse', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1594, 3), ) + + + cardCodeResponse = property(__cardCodeResponse.value, __cardCodeResponse.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}CAVVResponse uses Python identifier CAVVResponse + __CAVVResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'CAVVResponse'), 'CAVVResponse', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdCAVVResponse', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1601, 3), ) + + + CAVVResponse = property(__CAVVResponse.value, __CAVVResponse.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}FDSFilterAction uses Python identifier FDSFilterAction + __FDSFilterAction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FDSFilterAction'), 'FDSFilterAction', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdFDSFilterAction', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1608, 3), ) + + + FDSFilterAction = property(__FDSFilterAction.value, __FDSFilterAction.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}FDSFilters uses Python identifier FDSFilters + __FDSFilters = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FDSFilters'), 'FDSFilters', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdFDSFilters', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1609, 3), ) + + + FDSFilters = property(__FDSFilters.value, __FDSFilters.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batch uses Python identifier batch + __batch = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'batch'), 'batch', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdbatch', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1610, 3), ) + + + batch = property(__batch.value, __batch.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}order uses Python identifier order + __order = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'order'), 'order', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdorder', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1611, 3), ) + + + order = property(__order.value, __order.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}requestedAmount uses Python identifier requestedAmount + __requestedAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'requestedAmount'), 'requestedAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdrequestedAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1612, 3), ) + + + requestedAmount = property(__requestedAmount.value, __requestedAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}authAmount uses Python identifier authAmount + __authAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'authAmount'), 'authAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdauthAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1620, 3), ) + + + authAmount = property(__authAmount.value, __authAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settleAmount uses Python identifier settleAmount + __settleAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'settleAmount'), 'settleAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdsettleAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1628, 3), ) + + + settleAmount = property(__settleAmount.value, __settleAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}tax uses Python identifier tax + __tax = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'tax'), 'tax', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdtax', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1636, 3), ) + + + tax = property(__tax.value, __tax.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipping uses Python identifier shipping + __shipping = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shipping'), 'shipping', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdshipping', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1637, 3), ) + + + shipping = property(__shipping.value, __shipping.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}duty uses Python identifier duty + __duty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'duty'), 'duty', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdduty', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1638, 3), ) + + + duty = property(__duty.value, __duty.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItems uses Python identifier lineItems + __lineItems = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'lineItems'), 'lineItems', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdlineItems', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1639, 3), ) + + + lineItems = property(__lineItems.value, __lineItems.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}prepaidBalanceRemaining uses Python identifier prepaidBalanceRemaining + __prepaidBalanceRemaining = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'prepaidBalanceRemaining'), 'prepaidBalanceRemaining', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdprepaidBalanceRemaining', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1640, 3), ) + + + prepaidBalanceRemaining = property(__prepaidBalanceRemaining.value, __prepaidBalanceRemaining.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxExempt uses Python identifier taxExempt + __taxExempt = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'taxExempt'), 'taxExempt', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdtaxExempt', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1647, 3), ) + + + taxExempt = property(__taxExempt.value, __taxExempt.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}payment uses Python identifier payment + __payment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'payment'), 'payment', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdpayment', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1648, 3), ) + + + payment = property(__payment.value, __payment.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customer uses Python identifier customer + __customer = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customer'), 'customer', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdcustomer', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1649, 3), ) + + + customer = property(__customer.value, __customer.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}billTo uses Python identifier billTo + __billTo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'billTo'), 'billTo', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdbillTo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1650, 3), ) + + + billTo = property(__billTo.value, __billTo.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipTo uses Python identifier shipTo + __shipTo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shipTo'), 'shipTo', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdshipTo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1651, 3), ) + + + shipTo = property(__shipTo.value, __shipTo.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}recurringBilling uses Python identifier recurringBilling + __recurringBilling = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'recurringBilling'), 'recurringBilling', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdrecurringBilling', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1652, 3), ) + + + recurringBilling = property(__recurringBilling.value, __recurringBilling.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerIP uses Python identifier customerIP + __customerIP = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerIP'), 'customerIP', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerIP', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1653, 3), ) + + + customerIP = property(__customerIP.value, __customerIP.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}product uses Python identifier product + __product = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'product'), 'product', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdproduct', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1654, 3), ) + + + product = property(__product.value, __product.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}marketType uses Python identifier marketType + __marketType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'marketType'), 'marketType', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdmarketType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1655, 3), ) + + + marketType = property(__marketType.value, __marketType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}mobileDeviceId uses Python identifier mobileDeviceId + __mobileDeviceId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId'), 'mobileDeviceId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdmobileDeviceId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1656, 3), ) + + + mobileDeviceId = property(__mobileDeviceId.value, __mobileDeviceId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}returnedItems uses Python identifier returnedItems + __returnedItems = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'returnedItems'), 'returnedItems', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdreturnedItems', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1657, 6), ) + + + returnedItems = property(__returnedItems.value, __returnedItems.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}solution uses Python identifier solution + __solution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'solution'), 'solution', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdsolution', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1658, 6), ) + + + solution = property(__solution.value, __solution.set, None, None) + + _ElementMap.update({ + __transId.name() : __transId, + __refTransId.name() : __refTransId, + __splitTenderId.name() : __splitTenderId, + __submitTimeUTC.name() : __submitTimeUTC, + __submitTimeLocal.name() : __submitTimeLocal, + __transactionType.name() : __transactionType, + __transactionStatus.name() : __transactionStatus, + __responseCode.name() : __responseCode, + __responseReasonCode.name() : __responseReasonCode, + __subscription.name() : __subscription, + __responseReasonDescription.name() : __responseReasonDescription, + __authCode.name() : __authCode, + __AVSResponse.name() : __AVSResponse, + __cardCodeResponse.name() : __cardCodeResponse, + __CAVVResponse.name() : __CAVVResponse, + __FDSFilterAction.name() : __FDSFilterAction, + __FDSFilters.name() : __FDSFilters, + __batch.name() : __batch, + __order.name() : __order, + __requestedAmount.name() : __requestedAmount, + __authAmount.name() : __authAmount, + __settleAmount.name() : __settleAmount, + __tax.name() : __tax, + __shipping.name() : __shipping, + __duty.name() : __duty, + __lineItems.name() : __lineItems, + __prepaidBalanceRemaining.name() : __prepaidBalanceRemaining, + __taxExempt.name() : __taxExempt, + __payment.name() : __payment, + __customer.name() : __customer, + __billTo.name() : __billTo, + __shipTo.name() : __shipTo, + __recurringBilling.name() : __recurringBilling, + __customerIP.name() : __customerIP, + __product.name() : __product, + __marketType.name() : __marketType, + __mobileDeviceId.name() : __mobileDeviceId, + __returnedItems.name() : __returnedItems, + __solution.name() : __solution + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'transactionDetailsType', transactionDetailsType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}solutionType with content type ELEMENT_ONLY +class solutionType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}solutionType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'solutionType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1662, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}id uses Python identifier id + __id = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'id'), 'id', '__AnetApixmlv1schemaAnetApiSchema_xsd_solutionType_AnetApixmlv1schemaAnetApiSchema_xsdid', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1664, 6), ) + + + id = property(__id.value, __id.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}name uses Python identifier name + __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'name'), 'name', '__AnetApixmlv1schemaAnetApiSchema_xsd_solutionType_AnetApixmlv1schemaAnetApiSchema_xsdname', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1665, 6), ) + + + name = property(__name.value, __name.set, None, None) + + _ElementMap.update({ + __id.name() : __id, + __name.name() : __name + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'solutionType', solutionType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfReturnedItem with content type ELEMENT_ONLY +class ArrayOfReturnedItem (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfReturnedItem with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfReturnedItem') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1669, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}returnedItem uses Python identifier returnedItem + __returnedItem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'returnedItem'), 'returnedItem', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfReturnedItem_AnetApixmlv1schemaAnetApiSchema_xsdreturnedItem', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1671, 6), ) + + + returnedItem = property(__returnedItem.value, __returnedItem.set, None, None) + + _ElementMap.update({ + __returnedItem.name() : __returnedItem + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfReturnedItem', ArrayOfReturnedItem) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}returnedItemType with content type ELEMENT_ONLY +class returnedItemType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}returnedItemType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'returnedItemType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1675, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}id uses Python identifier id + __id = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'id'), 'id', '__AnetApixmlv1schemaAnetApiSchema_xsd_returnedItemType_AnetApixmlv1schemaAnetApiSchema_xsdid', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1677, 6), ) + + + id = property(__id.value, __id.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}dateUTC uses Python identifier dateUTC + __dateUTC = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'dateUTC'), 'dateUTC', '__AnetApixmlv1schemaAnetApiSchema_xsd_returnedItemType_AnetApixmlv1schemaAnetApiSchema_xsddateUTC', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1678, 6), ) + + + dateUTC = property(__dateUTC.value, __dateUTC.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}dateLocal uses Python identifier dateLocal + __dateLocal = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'dateLocal'), 'dateLocal', '__AnetApixmlv1schemaAnetApiSchema_xsd_returnedItemType_AnetApixmlv1schemaAnetApiSchema_xsddateLocal', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1679, 6), ) + + + dateLocal = property(__dateLocal.value, __dateLocal.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}code uses Python identifier code + __code = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'code'), 'code', '__AnetApixmlv1schemaAnetApiSchema_xsd_returnedItemType_AnetApixmlv1schemaAnetApiSchema_xsdcode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1680, 6), ) + + + code = property(__code.value, __code.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}description uses Python identifier description + __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'description'), 'description', '__AnetApixmlv1schemaAnetApiSchema_xsd_returnedItemType_AnetApixmlv1schemaAnetApiSchema_xsddescription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1681, 6), ) + + + description = property(__description.value, __description.set, None, None) + + _ElementMap.update({ + __id.name() : __id, + __dateUTC.name() : __dateUTC, + __dateLocal.name() : __dateLocal, + __code.name() : __code, + __description.name() : __description + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'returnedItemType', returnedItemType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}FDSFilterType with content type ELEMENT_ONLY +class FDSFilterType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}FDSFilterType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FDSFilterType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1685, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}name uses Python identifier name + __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'name'), 'name', '__AnetApixmlv1schemaAnetApiSchema_xsd_FDSFilterType_AnetApixmlv1schemaAnetApiSchema_xsdname', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1687, 3), ) + + + name = property(__name.value, __name.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}action uses Python identifier action + __action = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'action'), 'action', '__AnetApixmlv1schemaAnetApiSchema_xsd_FDSFilterType_AnetApixmlv1schemaAnetApiSchema_xsdaction', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1688, 3), ) + + + action = property(__action.value, __action.set, None, None) + + _ElementMap.update({ + __name.name() : __name, + __action.name() : __action + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'FDSFilterType', FDSFilterType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batchDetailsType with content type ELEMENT_ONLY +class batchDetailsType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batchDetailsType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'batchDetailsType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1692, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batchId uses Python identifier batchId + __batchId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'batchId'), 'batchId', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdbatchId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1694, 3), ) + + + batchId = property(__batchId.value, __batchId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settlementTimeUTC uses Python identifier settlementTimeUTC + __settlementTimeUTC = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'settlementTimeUTC'), 'settlementTimeUTC', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdsettlementTimeUTC', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1695, 3), ) + + + settlementTimeUTC = property(__settlementTimeUTC.value, __settlementTimeUTC.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settlementTimeLocal uses Python identifier settlementTimeLocal + __settlementTimeLocal = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'settlementTimeLocal'), 'settlementTimeLocal', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdsettlementTimeLocal', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1696, 3), ) + + + settlementTimeLocal = property(__settlementTimeLocal.value, __settlementTimeLocal.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settlementState uses Python identifier settlementState + __settlementState = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'settlementState'), 'settlementState', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdsettlementState', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1697, 3), ) + + + settlementState = property(__settlementState.value, __settlementState.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentMethod uses Python identifier paymentMethod + __paymentMethod = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentMethod'), 'paymentMethod', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdpaymentMethod', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1698, 3), ) + + + paymentMethod = property(__paymentMethod.value, __paymentMethod.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}marketType uses Python identifier marketType + __marketType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'marketType'), 'marketType', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdmarketType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1699, 3), ) + + + marketType = property(__marketType.value, __marketType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}product uses Python identifier product + __product = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'product'), 'product', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdproduct', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1700, 3), ) + + + product = property(__product.value, __product.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}statistics uses Python identifier statistics + __statistics = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'statistics'), 'statistics', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchDetailsType_AnetApixmlv1schemaAnetApiSchema_xsdstatistics', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1701, 3), ) + + + statistics = property(__statistics.value, __statistics.set, None, None) + + _ElementMap.update({ + __batchId.name() : __batchId, + __settlementTimeUTC.name() : __settlementTimeUTC, + __settlementTimeLocal.name() : __settlementTimeLocal, + __settlementState.name() : __settlementState, + __paymentMethod.name() : __paymentMethod, + __marketType.name() : __marketType, + __product.name() : __product, + __statistics.name() : __statistics + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'batchDetailsType', batchDetailsType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batchStatisticType with content type ELEMENT_ONLY +class batchStatisticType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batchStatisticType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'batchStatisticType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1705, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountType uses Python identifier accountType + __accountType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountType'), 'accountType', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdaccountType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1707, 3), ) + + + accountType = property(__accountType.value, __accountType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}chargeAmount uses Python identifier chargeAmount + __chargeAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'chargeAmount'), 'chargeAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdchargeAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1708, 3), ) + + + chargeAmount = property(__chargeAmount.value, __chargeAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}chargeCount uses Python identifier chargeCount + __chargeCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'chargeCount'), 'chargeCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdchargeCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1709, 3), ) + + + chargeCount = property(__chargeCount.value, __chargeCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refundAmount uses Python identifier refundAmount + __refundAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refundAmount'), 'refundAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdrefundAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1710, 3), ) + + + refundAmount = property(__refundAmount.value, __refundAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refundCount uses Python identifier refundCount + __refundCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refundCount'), 'refundCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdrefundCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1711, 3), ) + + + refundCount = property(__refundCount.value, __refundCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}voidCount uses Python identifier voidCount + __voidCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'voidCount'), 'voidCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdvoidCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1712, 3), ) + + + voidCount = property(__voidCount.value, __voidCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}declineCount uses Python identifier declineCount + __declineCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'declineCount'), 'declineCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsddeclineCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1713, 3), ) + + + declineCount = property(__declineCount.value, __declineCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}errorCount uses Python identifier errorCount + __errorCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'errorCount'), 'errorCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsderrorCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1714, 3), ) + + + errorCount = property(__errorCount.value, __errorCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}returnedItemAmount uses Python identifier returnedItemAmount + __returnedItemAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'returnedItemAmount'), 'returnedItemAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdreturnedItemAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1715, 3), ) + + + returnedItemAmount = property(__returnedItemAmount.value, __returnedItemAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}returnedItemCount uses Python identifier returnedItemCount + __returnedItemCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'returnedItemCount'), 'returnedItemCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdreturnedItemCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1716, 3), ) + + + returnedItemCount = property(__returnedItemCount.value, __returnedItemCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}chargebackAmount uses Python identifier chargebackAmount + __chargebackAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'chargebackAmount'), 'chargebackAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdchargebackAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1717, 3), ) + + + chargebackAmount = property(__chargebackAmount.value, __chargebackAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}chargebackCount uses Python identifier chargebackCount + __chargebackCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'chargebackCount'), 'chargebackCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdchargebackCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1718, 3), ) + + + chargebackCount = property(__chargebackCount.value, __chargebackCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}correctionNoticeCount uses Python identifier correctionNoticeCount + __correctionNoticeCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'correctionNoticeCount'), 'correctionNoticeCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdcorrectionNoticeCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1719, 3), ) + + + correctionNoticeCount = property(__correctionNoticeCount.value, __correctionNoticeCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}chargeChargeBackAmount uses Python identifier chargeChargeBackAmount + __chargeChargeBackAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'chargeChargeBackAmount'), 'chargeChargeBackAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdchargeChargeBackAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1720, 3), ) + + + chargeChargeBackAmount = property(__chargeChargeBackAmount.value, __chargeChargeBackAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}chargeChargeBackCount uses Python identifier chargeChargeBackCount + __chargeChargeBackCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'chargeChargeBackCount'), 'chargeChargeBackCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdchargeChargeBackCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1721, 3), ) + + + chargeChargeBackCount = property(__chargeChargeBackCount.value, __chargeChargeBackCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refundChargeBackAmount uses Python identifier refundChargeBackAmount + __refundChargeBackAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refundChargeBackAmount'), 'refundChargeBackAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdrefundChargeBackAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1722, 3), ) + + + refundChargeBackAmount = property(__refundChargeBackAmount.value, __refundChargeBackAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refundChargeBackCount uses Python identifier refundChargeBackCount + __refundChargeBackCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refundChargeBackCount'), 'refundChargeBackCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdrefundChargeBackCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1723, 3), ) + + + refundChargeBackCount = property(__refundChargeBackCount.value, __refundChargeBackCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}chargeReturnedItemsAmount uses Python identifier chargeReturnedItemsAmount + __chargeReturnedItemsAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'chargeReturnedItemsAmount'), 'chargeReturnedItemsAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdchargeReturnedItemsAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1724, 3), ) + + + chargeReturnedItemsAmount = property(__chargeReturnedItemsAmount.value, __chargeReturnedItemsAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}chargeReturnedItemsCount uses Python identifier chargeReturnedItemsCount + __chargeReturnedItemsCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'chargeReturnedItemsCount'), 'chargeReturnedItemsCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdchargeReturnedItemsCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1725, 3), ) + + + chargeReturnedItemsCount = property(__chargeReturnedItemsCount.value, __chargeReturnedItemsCount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refundReturnedItemsAmount uses Python identifier refundReturnedItemsAmount + __refundReturnedItemsAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refundReturnedItemsAmount'), 'refundReturnedItemsAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdrefundReturnedItemsAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1726, 3), ) + + + refundReturnedItemsAmount = property(__refundReturnedItemsAmount.value, __refundReturnedItemsAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refundReturnedItemsCount uses Python identifier refundReturnedItemsCount + __refundReturnedItemsCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refundReturnedItemsCount'), 'refundReturnedItemsCount', '__AnetApixmlv1schemaAnetApiSchema_xsd_batchStatisticType_AnetApixmlv1schemaAnetApiSchema_xsdrefundReturnedItemsCount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1727, 3), ) + + + refundReturnedItemsCount = property(__refundReturnedItemsCount.value, __refundReturnedItemsCount.set, None, None) + + _ElementMap.update({ + __accountType.name() : __accountType, + __chargeAmount.name() : __chargeAmount, + __chargeCount.name() : __chargeCount, + __refundAmount.name() : __refundAmount, + __refundCount.name() : __refundCount, + __voidCount.name() : __voidCount, + __declineCount.name() : __declineCount, + __errorCount.name() : __errorCount, + __returnedItemAmount.name() : __returnedItemAmount, + __returnedItemCount.name() : __returnedItemCount, + __chargebackAmount.name() : __chargebackAmount, + __chargebackCount.name() : __chargebackCount, + __correctionNoticeCount.name() : __correctionNoticeCount, + __chargeChargeBackAmount.name() : __chargeChargeBackAmount, + __chargeChargeBackCount.name() : __chargeChargeBackCount, + __refundChargeBackAmount.name() : __refundChargeBackAmount, + __refundChargeBackCount.name() : __refundChargeBackCount, + __chargeReturnedItemsAmount.name() : __chargeReturnedItemsAmount, + __chargeReturnedItemsCount.name() : __chargeReturnedItemsCount, + __refundReturnedItemsAmount.name() : __refundReturnedItemsAmount, + __refundReturnedItemsCount.name() : __refundReturnedItemsCount + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'batchStatisticType', batchStatisticType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionResponse with content type ELEMENT_ONLY +class transactionResponse (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionResponse with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'transactionResponse') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1731, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}responseCode uses Python identifier responseCode + __responseCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'responseCode'), 'responseCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdresponseCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1733, 3), ) + + + responseCode = property(__responseCode.value, __responseCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}rawResponseCode uses Python identifier rawResponseCode + __rawResponseCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'rawResponseCode'), 'rawResponseCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdrawResponseCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1734, 3), ) + + + rawResponseCode = property(__rawResponseCode.value, __rawResponseCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}authCode uses Python identifier authCode + __authCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'authCode'), 'authCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdauthCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1735, 3), ) + + + authCode = property(__authCode.value, __authCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}avsResultCode uses Python identifier avsResultCode + __avsResultCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'avsResultCode'), 'avsResultCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdavsResultCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1736, 3), ) + + + avsResultCode = property(__avsResultCode.value, __avsResultCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cvvResultCode uses Python identifier cvvResultCode + __cvvResultCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cvvResultCode'), 'cvvResultCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdcvvResultCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1737, 3), ) + + + cvvResultCode = property(__cvvResultCode.value, __cvvResultCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cavvResultCode uses Python identifier cavvResultCode + __cavvResultCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cavvResultCode'), 'cavvResultCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdcavvResultCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1738, 3), ) + + + cavvResultCode = property(__cavvResultCode.value, __cavvResultCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transId uses Python identifier transId + __transId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transId'), 'transId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdtransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1739, 3), ) + + + transId = property(__transId.value, __transId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refTransID uses Python identifier refTransID + __refTransID = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refTransID'), 'refTransID', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdrefTransID', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1740, 3), ) + + + refTransID = property(__refTransID.value, __refTransID.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transHash uses Python identifier transHash + __transHash = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transHash'), 'transHash', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdtransHash', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1741, 3), ) + + + transHash = property(__transHash.value, __transHash.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}testRequest uses Python identifier testRequest + __testRequest = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'testRequest'), 'testRequest', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdtestRequest', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1742, 3), ) + + + testRequest = property(__testRequest.value, __testRequest.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountNumber uses Python identifier accountNumber + __accountNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), 'accountNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdaccountNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1743, 3), ) + + + accountNumber = property(__accountNumber.value, __accountNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountType uses Python identifier accountType + __accountType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountType'), 'accountType', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdaccountType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1744, 3), ) + + + accountType = property(__accountType.value, __accountType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderId uses Python identifier splitTenderId + __splitTenderId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId'), 'splitTenderId', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdsplitTenderId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1745, 3), ) + + + splitTenderId = property(__splitTenderId.value, __splitTenderId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}prePaidCard uses Python identifier prePaidCard + __prePaidCard = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'prePaidCard'), 'prePaidCard', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdprePaidCard', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1746, 3), ) + + + prePaidCard = property(__prePaidCard.value, __prePaidCard.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages uses Python identifier messages + __messages = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'messages'), 'messages', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdmessages', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1755, 3), ) + + + messages = property(__messages.value, __messages.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}errors uses Python identifier errors + __errors = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'errors'), 'errors', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsderrors', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1769, 3), ) + + + errors = property(__errors.value, __errors.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderPayments uses Python identifier splitTenderPayments + __splitTenderPayments = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'splitTenderPayments'), 'splitTenderPayments', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdsplitTenderPayments', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1783, 3), ) + + + splitTenderPayments = property(__splitTenderPayments.value, __splitTenderPayments.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}userFields uses Python identifier userFields + __userFields = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'userFields'), 'userFields', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsduserFields', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1804, 3), ) + + + userFields = property(__userFields.value, __userFields.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipTo uses Python identifier shipTo + __shipTo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shipTo'), 'shipTo', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdshipTo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1811, 6), ) + + + shipTo = property(__shipTo.value, __shipTo.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}secureAcceptance uses Python identifier secureAcceptance + __secureAcceptance = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'secureAcceptance'), 'secureAcceptance', '__AnetApixmlv1schemaAnetApiSchema_xsd_transactionResponse_AnetApixmlv1schemaAnetApiSchema_xsdsecureAcceptance', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1812, 6), ) + + + secureAcceptance = property(__secureAcceptance.value, __secureAcceptance.set, None, None) + + _ElementMap.update({ + __responseCode.name() : __responseCode, + __rawResponseCode.name() : __rawResponseCode, + __authCode.name() : __authCode, + __avsResultCode.name() : __avsResultCode, + __cvvResultCode.name() : __cvvResultCode, + __cavvResultCode.name() : __cavvResultCode, + __transId.name() : __transId, + __refTransID.name() : __refTransID, + __transHash.name() : __transHash, + __testRequest.name() : __testRequest, + __accountNumber.name() : __accountNumber, + __accountType.name() : __accountType, + __splitTenderId.name() : __splitTenderId, + __prePaidCard.name() : __prePaidCard, + __messages.name() : __messages, + __errors.name() : __errors, + __splitTenderPayments.name() : __splitTenderPayments, + __userFields.name() : __userFields, + __shipTo.name() : __shipTo, + __secureAcceptance.name() : __secureAcceptance + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'transactionResponse', transactionResponse) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_6 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1747, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}requestedAmount uses Python identifier requestedAmount + __requestedAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'requestedAmount'), 'requestedAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_6_AnetApixmlv1schemaAnetApiSchema_xsdrequestedAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1749, 6), ) + + + requestedAmount = property(__requestedAmount.value, __requestedAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}approvedAmount uses Python identifier approvedAmount + __approvedAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'approvedAmount'), 'approvedAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_6_AnetApixmlv1schemaAnetApiSchema_xsdapprovedAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1750, 6), ) + + + approvedAmount = property(__approvedAmount.value, __approvedAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}balanceOnCard uses Python identifier balanceOnCard + __balanceOnCard = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'balanceOnCard'), 'balanceOnCard', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_6_AnetApixmlv1schemaAnetApiSchema_xsdbalanceOnCard', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1751, 6), ) + + + balanceOnCard = property(__balanceOnCard.value, __balanceOnCard.set, None, None) + + _ElementMap.update({ + __requestedAmount.name() : __requestedAmount, + __approvedAmount.name() : __approvedAmount, + __balanceOnCard.name() : __balanceOnCard + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_7 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1756, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}message uses Python identifier message + __message = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'message'), 'message', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_7_AnetApixmlv1schemaAnetApiSchema_xsdmessage', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1758, 6), ) + + + message = property(__message.value, __message.set, None, None) + + _ElementMap.update({ + __message.name() : __message + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_8 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1759, 7) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}code uses Python identifier code + __code = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'code'), 'code', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_8_AnetApixmlv1schemaAnetApiSchema_xsdcode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1761, 9), ) + + + code = property(__code.value, __code.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}description uses Python identifier description + __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'description'), 'description', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_8_AnetApixmlv1schemaAnetApiSchema_xsddescription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1762, 9), ) + + + description = property(__description.value, __description.set, None, None) + + _ElementMap.update({ + __code.name() : __code, + __description.name() : __description + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_9 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1770, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}error uses Python identifier error + __error = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'error'), 'error', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_9_AnetApixmlv1schemaAnetApiSchema_xsderror', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1772, 6), ) + + + error = property(__error.value, __error.set, None, None) + + _ElementMap.update({ + __error.name() : __error + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_10 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1773, 7) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}errorCode uses Python identifier errorCode + __errorCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'errorCode'), 'errorCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_10_AnetApixmlv1schemaAnetApiSchema_xsderrorCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1775, 9), ) + + + errorCode = property(__errorCode.value, __errorCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}errorText uses Python identifier errorText + __errorText = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'errorText'), 'errorText', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_10_AnetApixmlv1schemaAnetApiSchema_xsderrorText', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1776, 9), ) + + + errorText = property(__errorText.value, __errorText.set, None, None) + + _ElementMap.update({ + __errorCode.name() : __errorCode, + __errorText.name() : __errorText + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_11 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1784, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderPayment uses Python identifier splitTenderPayment + __splitTenderPayment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'splitTenderPayment'), 'splitTenderPayment', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_11_AnetApixmlv1schemaAnetApiSchema_xsdsplitTenderPayment', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1786, 6), ) + + + splitTenderPayment = property(__splitTenderPayment.value, __splitTenderPayment.set, None, None) + + _ElementMap.update({ + __splitTenderPayment.name() : __splitTenderPayment + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_12 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1787, 7) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transId uses Python identifier transId + __transId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transId'), 'transId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_12_AnetApixmlv1schemaAnetApiSchema_xsdtransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1789, 9), ) + + + transId = property(__transId.value, __transId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}responseCode uses Python identifier responseCode + __responseCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'responseCode'), 'responseCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_12_AnetApixmlv1schemaAnetApiSchema_xsdresponseCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1790, 9), ) + + + responseCode = property(__responseCode.value, __responseCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}responseToCustomer uses Python identifier responseToCustomer + __responseToCustomer = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'responseToCustomer'), 'responseToCustomer', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_12_AnetApixmlv1schemaAnetApiSchema_xsdresponseToCustomer', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1791, 9), ) + + + responseToCustomer = property(__responseToCustomer.value, __responseToCustomer.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}authCode uses Python identifier authCode + __authCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'authCode'), 'authCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_12_AnetApixmlv1schemaAnetApiSchema_xsdauthCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1792, 9), ) + + + authCode = property(__authCode.value, __authCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountNumber uses Python identifier accountNumber + __accountNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), 'accountNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_12_AnetApixmlv1schemaAnetApiSchema_xsdaccountNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1793, 9), ) + + + accountNumber = property(__accountNumber.value, __accountNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountType uses Python identifier accountType + __accountType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountType'), 'accountType', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_12_AnetApixmlv1schemaAnetApiSchema_xsdaccountType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1794, 9), ) + + + accountType = property(__accountType.value, __accountType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}requestedAmount uses Python identifier requestedAmount + __requestedAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'requestedAmount'), 'requestedAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_12_AnetApixmlv1schemaAnetApiSchema_xsdrequestedAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1795, 9), ) + + + requestedAmount = property(__requestedAmount.value, __requestedAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}approvedAmount uses Python identifier approvedAmount + __approvedAmount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'approvedAmount'), 'approvedAmount', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_12_AnetApixmlv1schemaAnetApiSchema_xsdapprovedAmount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1796, 9), ) + + + approvedAmount = property(__approvedAmount.value, __approvedAmount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}balanceOnCard uses Python identifier balanceOnCard + __balanceOnCard = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'balanceOnCard'), 'balanceOnCard', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_12_AnetApixmlv1schemaAnetApiSchema_xsdbalanceOnCard', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1797, 9), ) + + + balanceOnCard = property(__balanceOnCard.value, __balanceOnCard.set, None, None) + + _ElementMap.update({ + __transId.name() : __transId, + __responseCode.name() : __responseCode, + __responseToCustomer.name() : __responseToCustomer, + __authCode.name() : __authCode, + __accountNumber.name() : __accountNumber, + __accountType.name() : __accountType, + __requestedAmount.name() : __requestedAmount, + __approvedAmount.name() : __approvedAmount, + __balanceOnCard.name() : __balanceOnCard + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_13 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1805, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}userField uses Python identifier userField + __userField = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'userField'), 'userField', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_13_AnetApixmlv1schemaAnetApiSchema_xsduserField', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1807, 6), ) + + + userField = property(__userField.value, __userField.set, None, None) + + _ElementMap.update({ + __userField.name() : __userField + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_14 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1813, 8) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}SecureAcceptanceUrl uses Python identifier SecureAcceptanceUrl + __SecureAcceptanceUrl = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'SecureAcceptanceUrl'), 'SecureAcceptanceUrl', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_14_AnetApixmlv1schemaAnetApiSchema_xsdSecureAcceptanceUrl', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1815, 12), ) + + + SecureAcceptanceUrl = property(__SecureAcceptanceUrl.value, __SecureAcceptanceUrl.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}PayerID uses Python identifier PayerID + __PayerID = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'PayerID'), 'PayerID', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_14_AnetApixmlv1schemaAnetApiSchema_xsdPayerID', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1816, 12), ) + + + PayerID = property(__PayerID.value, __PayerID.set, None, None) + + _ElementMap.update({ + __SecureAcceptanceUrl.name() : __SecureAcceptanceUrl, + __PayerID.name() : __PayerID + }) + _AttributeMap.update({ + + }) + + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest with content type ELEMENT_ONLY +class ANetApiRequest (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ANetApiRequest') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1828, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication uses Python identifier merchantAuthentication + __merchantAuthentication = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication'), 'merchantAuthentication', '__AnetApixmlv1schemaAnetApiSchema_xsd_ANetApiRequest_AnetApixmlv1schemaAnetApiSchema_xsdmerchantAuthentication', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3), ) + + + merchantAuthentication = property(__merchantAuthentication.value, __merchantAuthentication.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId uses Python identifier refId + __refId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refId'), 'refId', '__AnetApixmlv1schemaAnetApiSchema_xsd_ANetApiRequest_AnetApixmlv1schemaAnetApiSchema_xsdrefId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3), ) + + + refId = property(__refId.value, __refId.set, None, None) + + _ElementMap.update({ + __merchantAuthentication.name() : __merchantAuthentication, + __refId.name() : __refId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ANetApiRequest', ANetApiRequest) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}messagesType with content type ELEMENT_ONLY +class messagesType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}messagesType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'messagesType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1878, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}resultCode uses Python identifier resultCode + __resultCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'resultCode'), 'resultCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_messagesType_AnetApixmlv1schemaAnetApiSchema_xsdresultCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1880, 3), ) + + + resultCode = property(__resultCode.value, __resultCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}message uses Python identifier message + __message = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'message'), 'message', '__AnetApixmlv1schemaAnetApiSchema_xsd_messagesType_AnetApixmlv1schemaAnetApiSchema_xsdmessage', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1881, 3), ) + + + message = property(__message.value, __message.set, None, None) + + _ElementMap.update({ + __resultCode.name() : __resultCode, + __message.name() : __message + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'messagesType', messagesType) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_15 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1882, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}code uses Python identifier code + __code = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'code'), 'code', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_15_AnetApixmlv1schemaAnetApiSchema_xsdcode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1884, 6), ) + + + code = property(__code.value, __code.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}text uses Python identifier text + __text = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'text'), 'text', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_15_AnetApixmlv1schemaAnetApiSchema_xsdtext', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1885, 6), ) + + + text = property(__text.value, __text.set, None, None) + + _ElementMap.update({ + __code.name() : __code, + __text.name() : __text + }) + _AttributeMap.update({ + + }) + + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse with content type ELEMENT_ONLY +class ANetApiResponse (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ANetApiResponse') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1897, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId uses Python identifier refId + __refId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refId'), 'refId', '__AnetApixmlv1schemaAnetApiSchema_xsd_ANetApiResponse_AnetApixmlv1schemaAnetApiSchema_xsdrefId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3), ) + + + refId = property(__refId.value, __refId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages uses Python identifier messages + __messages = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'messages'), 'messages', '__AnetApixmlv1schemaAnetApiSchema_xsd_ANetApiResponse_AnetApixmlv1schemaAnetApiSchema_xsdmessages', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4), ) + + + messages = property(__messages.value, __messages.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken uses Python identifier sessionToken + __sessionToken = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'sessionToken'), 'sessionToken', '__AnetApixmlv1schemaAnetApiSchema_xsd_ANetApiResponse_AnetApixmlv1schemaAnetApiSchema_xsdsessionToken', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3), ) + + + sessionToken = property(__sessionToken.value, __sessionToken.set, None, None) + + _ElementMap.update({ + __refId.name() : __refId, + __messages.name() : __messages, + __sessionToken.name() : __sessionToken + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ANetApiResponse', ANetApiResponse) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_16 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1926, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId uses Python identifier refId + __refId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'refId'), 'refId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_16_AnetApixmlv1schemaAnetApiSchema_xsdrefId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1928, 4), ) + + + refId = property(__refId.value, __refId.set, None, None) + + _ElementMap.update({ + __refId.name() : __refId + }) + _AttributeMap.update({ + + }) + + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}createProfileResponse with content type ELEMENT_ONLY +class createProfileResponse (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}createProfileResponse with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'createProfileResponse') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2164, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages uses Python identifier messages + __messages = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'messages'), 'messages', '__AnetApixmlv1schemaAnetApiSchema_xsd_createProfileResponse_AnetApixmlv1schemaAnetApiSchema_xsdmessages', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2166, 12), ) + + + messages = property(__messages.value, __messages.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_createProfileResponse_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2168, 12), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileIdList uses Python identifier customerPaymentProfileIdList + __customerPaymentProfileIdList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileIdList'), 'customerPaymentProfileIdList', '__AnetApixmlv1schemaAnetApiSchema_xsd_createProfileResponse_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileIdList', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2169, 12), ) + + + customerPaymentProfileIdList = property(__customerPaymentProfileIdList.value, __customerPaymentProfileIdList.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerShippingAddressIdList uses Python identifier customerShippingAddressIdList + __customerShippingAddressIdList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressIdList'), 'customerShippingAddressIdList', '__AnetApixmlv1schemaAnetApiSchema_xsd_createProfileResponse_AnetApixmlv1schemaAnetApiSchema_xsdcustomerShippingAddressIdList', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2170, 12), ) + + + customerShippingAddressIdList = property(__customerShippingAddressIdList.value, __customerShippingAddressIdList.set, None, None) + + _ElementMap.update({ + __messages.name() : __messages, + __customerProfileId.name() : __customerProfileId, + __customerPaymentProfileIdList.name() : __customerPaymentProfileIdList, + __customerShippingAddressIdList.name() : __customerShippingAddressIdList + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'createProfileResponse', createProfileResponse) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}payPalType with content type ELEMENT_ONLY +class payPalType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}payPalType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'payPalType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3124, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}successUrl uses Python identifier successUrl + __successUrl = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'successUrl'), 'successUrl', '__AnetApixmlv1schemaAnetApiSchema_xsd_payPalType_AnetApixmlv1schemaAnetApiSchema_xsdsuccessUrl', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3126, 3), ) + + + successUrl = property(__successUrl.value, __successUrl.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cancelUrl uses Python identifier cancelUrl + __cancelUrl = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cancelUrl'), 'cancelUrl', '__AnetApixmlv1schemaAnetApiSchema_xsd_payPalType_AnetApixmlv1schemaAnetApiSchema_xsdcancelUrl', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3133, 3), ) + + + cancelUrl = property(__cancelUrl.value, __cancelUrl.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paypalLc uses Python identifier paypalLc + __paypalLc = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paypalLc'), 'paypalLc', '__AnetApixmlv1schemaAnetApiSchema_xsd_payPalType_AnetApixmlv1schemaAnetApiSchema_xsdpaypalLc', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3140, 3), ) + + + paypalLc = property(__paypalLc.value, __paypalLc.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paypalHdrImg uses Python identifier paypalHdrImg + __paypalHdrImg = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paypalHdrImg'), 'paypalHdrImg', '__AnetApixmlv1schemaAnetApiSchema_xsd_payPalType_AnetApixmlv1schemaAnetApiSchema_xsdpaypalHdrImg', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3147, 3), ) + + + paypalHdrImg = property(__paypalHdrImg.value, __paypalHdrImg.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paypalPayflowcolor uses Python identifier paypalPayflowcolor + __paypalPayflowcolor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paypalPayflowcolor'), 'paypalPayflowcolor', '__AnetApixmlv1schemaAnetApiSchema_xsd_payPalType_AnetApixmlv1schemaAnetApiSchema_xsdpaypalPayflowcolor', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3154, 3), ) + + + paypalPayflowcolor = property(__paypalPayflowcolor.value, __paypalPayflowcolor.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}payerID uses Python identifier payerID + __payerID = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'payerID'), 'payerID', '__AnetApixmlv1schemaAnetApiSchema_xsd_payPalType_AnetApixmlv1schemaAnetApiSchema_xsdpayerID', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3161, 3), ) + + + payerID = property(__payerID.value, __payerID.set, None, None) + + _ElementMap.update({ + __successUrl.name() : __successUrl, + __cancelUrl.name() : __cancelUrl, + __paypalLc.name() : __paypalLc, + __paypalHdrImg.name() : __paypalHdrImg, + __paypalPayflowcolor.name() : __paypalPayflowcolor, + __payerID.name() : __payerID + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'payPalType', payPalType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}Paging with content type ELEMENT_ONLY +class Paging (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}Paging with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Paging') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3183, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}limit uses Python identifier limit + __limit = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'limit'), 'limit', '__AnetApixmlv1schemaAnetApiSchema_xsd_Paging_AnetApixmlv1schemaAnetApiSchema_xsdlimit', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3185, 12), ) + + + limit = property(__limit.value, __limit.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}offset uses Python identifier offset + __offset = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'offset'), 'offset', '__AnetApixmlv1schemaAnetApiSchema_xsd_Paging_AnetApixmlv1schemaAnetApiSchema_xsdoffset', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3193, 12), ) + + + offset = property(__offset.value, __offset.set, None, None) + + _ElementMap.update({ + __limit.name() : __limit, + __offset.name() : __offset + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'Paging', Paging) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ARBGetSubscriptionListSorting with content type ELEMENT_ONLY +class ARBGetSubscriptionListSorting (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ARBGetSubscriptionListSorting with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ARBGetSubscriptionListSorting') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3203, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}orderBy uses Python identifier orderBy + __orderBy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'orderBy'), 'orderBy', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBGetSubscriptionListSorting_AnetApixmlv1schemaAnetApiSchema_xsdorderBy', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3205, 12), ) + + + orderBy = property(__orderBy.value, __orderBy.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}orderDescending uses Python identifier orderDescending + __orderDescending = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'orderDescending'), 'orderDescending', '__AnetApixmlv1schemaAnetApiSchema_xsd_ARBGetSubscriptionListSorting_AnetApixmlv1schemaAnetApiSchema_xsdorderDescending', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3206, 12), ) + + + orderDescending = property(__orderDescending.value, __orderDescending.set, None, None) + + _ElementMap.update({ + __orderBy.name() : __orderBy, + __orderDescending.name() : __orderDescending + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ARBGetSubscriptionListSorting', ARBGetSubscriptionListSorting) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfSubscription with content type ELEMENT_ONLY +class ArrayOfSubscription (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfSubscription with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ArrayOfSubscription') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3242, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscriptionDetail uses Python identifier subscriptionDetail + __subscriptionDetail = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subscriptionDetail'), 'subscriptionDetail', '__AnetApixmlv1schemaAnetApiSchema_xsd_ArrayOfSubscription_AnetApixmlv1schemaAnetApiSchema_xsdsubscriptionDetail', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3244, 3), ) + + + subscriptionDetail = property(__subscriptionDetail.value, __subscriptionDetail.set, None, None) + + _ElementMap.update({ + __subscriptionDetail.name() : __subscriptionDetail + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'ArrayOfSubscription', ArrayOfSubscription) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}SubscriptionDetail with content type ELEMENT_ONLY +class SubscriptionDetail (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}SubscriptionDetail with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'SubscriptionDetail') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3247, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}id uses Python identifier id + __id = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'id'), 'id', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdid', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3249, 3), ) + + + id = property(__id.value, __id.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}name uses Python identifier name + __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'name'), 'name', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdname', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3250, 3), ) + + + name = property(__name.value, __name.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}status uses Python identifier status + __status = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'status'), 'status', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdstatus', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3251, 12), ) + + + status = property(__status.value, __status.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}createTimeStampUTC uses Python identifier createTimeStampUTC + __createTimeStampUTC = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'createTimeStampUTC'), 'createTimeStampUTC', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdcreateTimeStampUTC', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3252, 3), ) + + + createTimeStampUTC = property(__createTimeStampUTC.value, __createTimeStampUTC.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}firstName uses Python identifier firstName + __firstName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'firstName'), 'firstName', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdfirstName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3253, 3), ) + + + firstName = property(__firstName.value, __firstName.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}lastName uses Python identifier lastName + __lastName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'lastName'), 'lastName', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdlastName', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3254, 3), ) + + + lastName = property(__lastName.value, __lastName.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}totalOccurrences uses Python identifier totalOccurrences + __totalOccurrences = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'totalOccurrences'), 'totalOccurrences', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdtotalOccurrences', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3255, 3), ) + + + totalOccurrences = property(__totalOccurrences.value, __totalOccurrences.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}pastOccurrences uses Python identifier pastOccurrences + __pastOccurrences = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'pastOccurrences'), 'pastOccurrences', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdpastOccurrences', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3256, 3), ) + + + pastOccurrences = property(__pastOccurrences.value, __pastOccurrences.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentMethod uses Python identifier paymentMethod + __paymentMethod = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentMethod'), 'paymentMethod', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdpaymentMethod', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3257, 12), ) + + + paymentMethod = property(__paymentMethod.value, __paymentMethod.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountNumber uses Python identifier accountNumber + __accountNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), 'accountNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdaccountNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3258, 12), ) + + + accountNumber = property(__accountNumber.value, __accountNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}invoice uses Python identifier invoice + __invoice = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'invoice'), 'invoice', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdinvoice', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3259, 3), ) + + + invoice = property(__invoice.value, __invoice.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount uses Python identifier amount + __amount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'amount'), 'amount', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdamount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3260, 3), ) + + + amount = property(__amount.value, __amount.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}currencyCode uses Python identifier currencyCode + __currencyCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'currencyCode'), 'currencyCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_SubscriptionDetail_AnetApixmlv1schemaAnetApiSchema_xsdcurrencyCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3268, 3), ) + + + currencyCode = property(__currencyCode.value, __currencyCode.set, None, None) + + _ElementMap.update({ + __id.name() : __id, + __name.name() : __name, + __status.name() : __status, + __createTimeStampUTC.name() : __createTimeStampUTC, + __firstName.name() : __firstName, + __lastName.name() : __lastName, + __totalOccurrences.name() : __totalOccurrences, + __pastOccurrences.name() : __pastOccurrences, + __paymentMethod.name() : __paymentMethod, + __accountNumber.name() : __accountNumber, + __invoice.name() : __invoice, + __amount.name() : __amount, + __currencyCode.name() : __currencyCode + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'SubscriptionDetail', SubscriptionDetail) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}searchCriteriaCustomerProfileType with content type ELEMENT_ONLY +class searchCriteriaCustomerProfileType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}searchCriteriaCustomerProfileType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'searchCriteriaCustomerProfileType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3277, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantCustomerId uses Python identifier merchantCustomerId + __merchantCustomerId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantCustomerId'), 'merchantCustomerId', '__AnetApixmlv1schemaAnetApiSchema_xsd_searchCriteriaCustomerProfileType_AnetApixmlv1schemaAnetApiSchema_xsdmerchantCustomerId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3279, 12), ) + + + merchantCustomerId = property(__merchantCustomerId.value, __merchantCustomerId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}email uses Python identifier email + __email = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'email'), 'email', '__AnetApixmlv1schemaAnetApiSchema_xsd_searchCriteriaCustomerProfileType_AnetApixmlv1schemaAnetApiSchema_xsdemail', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3280, 12), ) + + + email = property(__email.value, __email.set, None, None) + + _ElementMap.update({ + __merchantCustomerId.name() : __merchantCustomerId, + __email.name() : __email + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'searchCriteriaCustomerProfileType', searchCriteriaCustomerProfileType) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_17 (pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3297, 8) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileSummaryType uses Python identifier customerProfileSummaryType + __customerProfileSummaryType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileSummaryType'), 'customerProfileSummaryType', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_17_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileSummaryType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3300, 16), ) + + + customerProfileSummaryType = property(__customerProfileSummaryType.value, __customerProfileSummaryType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentSimpleType uses Python identifier paymentSimpleType + __paymentSimpleType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentSimpleType'), 'paymentSimpleType', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_17_AnetApixmlv1schemaAnetApiSchema_xsdpaymentSimpleType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3301, 16), ) + + + paymentSimpleType = property(__paymentSimpleType.value, __paymentSimpleType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}accountTypeEnum uses Python identifier accountTypeEnum + __accountTypeEnum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'accountTypeEnum'), 'accountTypeEnum', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_17_AnetApixmlv1schemaAnetApiSchema_xsdaccountTypeEnum', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3303, 16), ) + + + accountTypeEnum = property(__accountTypeEnum.value, __accountTypeEnum.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardTypeEnum uses Python identifier cardTypeEnum + __cardTypeEnum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardTypeEnum'), 'cardTypeEnum', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_17_AnetApixmlv1schemaAnetApiSchema_xsdcardTypeEnum', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3304, 16), ) + + + cardTypeEnum = property(__cardTypeEnum.value, __cardTypeEnum.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}FDSFilterActionEnum uses Python identifier FDSFilterActionEnum + __FDSFilterActionEnum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FDSFilterActionEnum'), 'FDSFilterActionEnum', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_17_AnetApixmlv1schemaAnetApiSchema_xsdFDSFilterActionEnum', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3305, 16), ) + + + FDSFilterActionEnum = property(__FDSFilterActionEnum.value, __FDSFilterActionEnum.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}permissionsEnum uses Python identifier permissionsEnum + __permissionsEnum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'permissionsEnum'), 'permissionsEnum', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_17_AnetApixmlv1schemaAnetApiSchema_xsdpermissionsEnum', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3306, 16), ) + + + permissionsEnum = property(__permissionsEnum.value, __permissionsEnum.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settingNameEnum uses Python identifier settingNameEnum + __settingNameEnum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'settingNameEnum'), 'settingNameEnum', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_17_AnetApixmlv1schemaAnetApiSchema_xsdsettingNameEnum', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3307, 16), ) + + + settingNameEnum = property(__settingNameEnum.value, __settingNameEnum.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}settlementStateEnum uses Python identifier settlementStateEnum + __settlementStateEnum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'settlementStateEnum'), 'settlementStateEnum', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_17_AnetApixmlv1schemaAnetApiSchema_xsdsettlementStateEnum', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3308, 16), ) + + + settlementStateEnum = property(__settlementStateEnum.value, __settlementStateEnum.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionStatusEnum uses Python identifier transactionStatusEnum + __transactionStatusEnum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionStatusEnum'), 'transactionStatusEnum', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_17_AnetApixmlv1schemaAnetApiSchema_xsdtransactionStatusEnum', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3309, 16), ) + + + transactionStatusEnum = property(__transactionStatusEnum.value, __transactionStatusEnum.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionTypeEnum uses Python identifier transactionTypeEnum + __transactionTypeEnum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionTypeEnum'), 'transactionTypeEnum', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_17_AnetApixmlv1schemaAnetApiSchema_xsdtransactionTypeEnum', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3310, 16), ) + + + transactionTypeEnum = property(__transactionTypeEnum.value, __transactionTypeEnum.set, None, None) + + _ElementMap.update({ + __customerProfileSummaryType.name() : __customerProfileSummaryType, + __paymentSimpleType.name() : __paymentSimpleType, + __accountTypeEnum.name() : __accountTypeEnum, + __cardTypeEnum.name() : __cardTypeEnum, + __FDSFilterActionEnum.name() : __FDSFilterActionEnum, + __permissionsEnum.name() : __permissionsEnum, + __settingNameEnum.name() : __settingNameEnum, + __settlementStateEnum.name() : __settlementStateEnum, + __transactionStatusEnum.name() : __transactionStatusEnum, + __transactionTypeEnum.name() : __transactionTypeEnum + }) + _AttributeMap.update({ + + }) + + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfilePaymentType with content type ELEMENT_ONLY +class customerProfilePaymentType (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfilePaymentType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerProfilePaymentType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3319, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}createProfile uses Python identifier createProfile + __createProfile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'createProfile'), 'createProfile', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfilePaymentType_AnetApixmlv1schemaAnetApiSchema_xsdcreateProfile', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3321, 8), ) + + + createProfile = property(__createProfile.value, __createProfile.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfilePaymentType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3322, 8), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentProfile uses Python identifier paymentProfile + __paymentProfile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile'), 'paymentProfile', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfilePaymentType_AnetApixmlv1schemaAnetApiSchema_xsdpaymentProfile', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3323, 8), ) + + + paymentProfile = property(__paymentProfile.value, __paymentProfile.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shippingProfileId uses Python identifier shippingProfileId + __shippingProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shippingProfileId'), 'shippingProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfilePaymentType_AnetApixmlv1schemaAnetApiSchema_xsdshippingProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3324, 8), ) + + + shippingProfileId = property(__shippingProfileId.value, __shippingProfileId.set, None, None) + + _ElementMap.update({ + __createProfile.name() : __createProfile, + __customerProfileId.name() : __customerProfileId, + __paymentProfile.name() : __paymentProfile, + __shippingProfileId.name() : __shippingProfileId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerProfilePaymentType', customerProfilePaymentType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentProfile with content type ELEMENT_ONLY +class paymentProfile (pyxb.binding.basis.complexTypeDefinition): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentProfile with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'paymentProfile') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3333, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentProfileId uses Python identifier paymentProfileId + __paymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentProfileId'), 'paymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentProfile_AnetApixmlv1schemaAnetApiSchema_xsdpaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3335, 6), ) + + + paymentProfileId = property(__paymentProfileId.value, __paymentProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardCode uses Python identifier cardCode + __cardCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardCode'), 'cardCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_paymentProfile_AnetApixmlv1schemaAnetApiSchema_xsdcardCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3336, 6), ) + + + cardCode = property(__cardCode.value, __cardCode.set, None, None) + + _ElementMap.update({ + __paymentProfileId.name() : __paymentProfileId, + __cardCode.name() : __cardCode + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'paymentProfile', paymentProfile) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardType with content type ELEMENT_ONLY +class creditCardType (creditCardSimpleType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'creditCardType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 420, 1) + _ElementMap = creditCardSimpleType._ElementMap.copy() + _AttributeMap = creditCardSimpleType._AttributeMap.copy() + # Base type is creditCardSimpleType + + # Element cardNumber ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardNumber) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardSimpleType + + # Element expirationDate ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}expirationDate) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardSimpleType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardCode uses Python identifier cardCode + __cardCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardCode'), 'cardCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardType_AnetApixmlv1schemaAnetApiSchema_xsdcardCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 425, 5), ) + + + cardCode = property(__cardCode.value, __cardCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}isPaymentToken uses Python identifier isPaymentToken + __isPaymentToken = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'isPaymentToken'), 'isPaymentToken', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardType_AnetApixmlv1schemaAnetApiSchema_xsdisPaymentToken', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 427, 10), ) + + + isPaymentToken = property(__isPaymentToken.value, __isPaymentToken.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cryptogram uses Python identifier cryptogram + __cryptogram = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cryptogram'), 'cryptogram', '__AnetApixmlv1schemaAnetApiSchema_xsd_creditCardType_AnetApixmlv1schemaAnetApiSchema_xsdcryptogram', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 429, 10), ) + + + cryptogram = property(__cryptogram.value, __cryptogram.set, None, None) + + _ElementMap.update({ + __cardCode.name() : __cardCode, + __isPaymentToken.name() : __isPaymentToken, + __cryptogram.name() : __cryptogram + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'creditCardType', creditCardType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}orderExType with content type ELEMENT_ONLY +class orderExType (orderType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}orderExType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'orderExType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 617, 1) + _ElementMap = orderType._ElementMap.copy() + _AttributeMap = orderType._AttributeMap.copy() + # Base type is orderType + + # Element invoiceNumber ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}invoiceNumber) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}orderType + + # Element description ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}description) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}orderType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}purchaseOrderNumber uses Python identifier purchaseOrderNumber + __purchaseOrderNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'purchaseOrderNumber'), 'purchaseOrderNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_orderExType_AnetApixmlv1schemaAnetApiSchema_xsdpurchaseOrderNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 621, 5), ) + + + purchaseOrderNumber = property(__purchaseOrderNumber.value, __purchaseOrderNumber.set, None, None) + + _ElementMap.update({ + __purchaseOrderNumber.name() : __purchaseOrderNumber + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'orderExType', orderExType) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_18 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 781, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}opaqueData uses Python identifier opaqueData + __opaqueData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'opaqueData'), 'opaqueData', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_18_AnetApixmlv1schemaAnetApiSchema_xsdopaqueData', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 785, 12), ) + + + opaqueData = property(__opaqueData.value, __opaqueData.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}callId uses Python identifier callId + __callId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'callId'), 'callId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_18_AnetApixmlv1schemaAnetApiSchema_xsdcallId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 786, 12), ) + + + callId = property(__callId.value, __callId.set, None, None) + + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + _ElementMap.update({ + __opaqueData.name() : __opaqueData, + __callId.name() : __callId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_19 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 794, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shippingInfo uses Python identifier shippingInfo + __shippingInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shippingInfo'), 'shippingInfo', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_19_AnetApixmlv1schemaAnetApiSchema_xsdshippingInfo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 798, 12), ) + + + shippingInfo = property(__shippingInfo.value, __shippingInfo.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}billingInfo uses Python identifier billingInfo + __billingInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'billingInfo'), 'billingInfo', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_19_AnetApixmlv1schemaAnetApiSchema_xsdbillingInfo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 799, 12), ) + + + billingInfo = property(__billingInfo.value, __billingInfo.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardInfo uses Python identifier cardInfo + __cardInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardInfo'), 'cardInfo', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_19_AnetApixmlv1schemaAnetApiSchema_xsdcardInfo', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 800, 12), ) + + + cardInfo = property(__cardInfo.value, __cardInfo.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentDetails uses Python identifier paymentDetails + __paymentDetails = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentDetails'), 'paymentDetails', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_19_AnetApixmlv1schemaAnetApiSchema_xsdpaymentDetails', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 801, 12), ) + + + paymentDetails = property(__paymentDetails.value, __paymentDetails.set, None, None) + + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + __shippingInfo.name() : __shippingInfo, + __billingInfo.name() : __billingInfo, + __cardInfo.name() : __cardInfo, + __paymentDetails.name() : __paymentDetails + }) + _AttributeMap.update({ + + }) + + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileType with content type ELEMENT_ONLY +class customerPaymentProfileType (customerPaymentProfileBaseType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1196, 1) + _ElementMap = customerPaymentProfileBaseType._ElementMap.copy() + _AttributeMap = customerPaymentProfileBaseType._AttributeMap.copy() + # Base type is customerPaymentProfileBaseType + + # Element customerType ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerType) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileBaseType + + # Element billTo ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}billTo) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileBaseType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}payment uses Python identifier payment + __payment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'payment'), 'payment', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerPaymentProfileType_AnetApixmlv1schemaAnetApiSchema_xsdpayment', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1200, 5), ) + + + payment = property(__payment.value, __payment.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}driversLicense uses Python identifier driversLicense + __driversLicense = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'driversLicense'), 'driversLicense', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerPaymentProfileType_AnetApixmlv1schemaAnetApiSchema_xsddriversLicense', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1201, 5), ) + + + driversLicense = property(__driversLicense.value, __driversLicense.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxId uses Python identifier taxId + __taxId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'taxId'), 'taxId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerPaymentProfileType_AnetApixmlv1schemaAnetApiSchema_xsdtaxId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1203, 5), ) + + + taxId = property(__taxId.value, __taxId.set, None, None) + + _ElementMap.update({ + __payment.name() : __payment, + __driversLicense.name() : __driversLicense, + __taxId.name() : __taxId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerPaymentProfileType', customerPaymentProfileType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileMaskedType with content type ELEMENT_ONLY +class customerPaymentProfileMaskedType (customerPaymentProfileBaseType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileMaskedType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileMaskedType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1226, 1) + _ElementMap = customerPaymentProfileBaseType._ElementMap.copy() + _AttributeMap = customerPaymentProfileBaseType._AttributeMap.copy() + # Base type is customerPaymentProfileBaseType + + # Element customerType ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerType) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileBaseType + + # Element billTo ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}billTo) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileBaseType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId uses Python identifier customerPaymentProfileId + __customerPaymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), 'customerPaymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerPaymentProfileMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1230, 5), ) + + + customerPaymentProfileId = property(__customerPaymentProfileId.value, __customerPaymentProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}payment uses Python identifier payment + __payment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'payment'), 'payment', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerPaymentProfileMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdpayment', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1231, 5), ) + + + payment = property(__payment.value, __payment.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}driversLicense uses Python identifier driversLicense + __driversLicense = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'driversLicense'), 'driversLicense', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerPaymentProfileMaskedType_AnetApixmlv1schemaAnetApiSchema_xsddriversLicense', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1232, 5), ) + + + driversLicense = property(__driversLicense.value, __driversLicense.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxId uses Python identifier taxId + __taxId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'taxId'), 'taxId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerPaymentProfileMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdtaxId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1233, 5), ) + + + taxId = property(__taxId.value, __taxId.set, None, None) + + _ElementMap.update({ + __customerPaymentProfileId.name() : __customerPaymentProfileId, + __payment.name() : __payment, + __driversLicense.name() : __driversLicense, + __taxId.name() : __taxId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerPaymentProfileMaskedType', customerPaymentProfileMaskedType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileType with content type ELEMENT_ONLY +class customerProfileType (customerProfileBaseType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerProfileType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1271, 1) + _ElementMap = customerProfileBaseType._ElementMap.copy() + _AttributeMap = customerProfileBaseType._AttributeMap.copy() + # Base type is customerProfileBaseType + + # Element merchantCustomerId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantCustomerId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType + + # Element description ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}description) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType + + # Element email ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}email) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentProfiles uses Python identifier paymentProfiles + __paymentProfiles = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentProfiles'), 'paymentProfiles', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfileType_AnetApixmlv1schemaAnetApiSchema_xsdpaymentProfiles', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1275, 5), ) + + + paymentProfiles = property(__paymentProfiles.value, __paymentProfiles.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipToList uses Python identifier shipToList + __shipToList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shipToList'), 'shipToList', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfileType_AnetApixmlv1schemaAnetApiSchema_xsdshipToList', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1276, 5), ) + + + shipToList = property(__shipToList.value, __shipToList.set, None, None) + + _ElementMap.update({ + __paymentProfiles.name() : __paymentProfiles, + __shipToList.name() : __shipToList + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerProfileType', customerProfileType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileExType with content type ELEMENT_ONLY +class customerProfileExType (customerProfileBaseType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileExType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerProfileExType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1282, 1) + _ElementMap = customerProfileBaseType._ElementMap.copy() + _AttributeMap = customerProfileBaseType._AttributeMap.copy() + # Base type is customerProfileBaseType + + # Element merchantCustomerId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantCustomerId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType + + # Element description ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}description) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType + + # Element email ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}email) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfileExType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1286, 5), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerProfileExType', customerProfileExType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressType with content type ELEMENT_ONLY +class customerAddressType (nameAndAddressType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerAddressType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1303, 1) + _ElementMap = nameAndAddressType._ElementMap.copy() + _AttributeMap = nameAndAddressType._AttributeMap.copy() + # Base type is nameAndAddressType + + # Element firstName ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}firstName) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element lastName ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}lastName) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element company ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}company) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element address ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}address) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element city ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}city) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element state ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}state) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element zip ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}zip) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element country ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}country) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}phoneNumber uses Python identifier phoneNumber + __phoneNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'phoneNumber'), 'phoneNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerAddressType_AnetApixmlv1schemaAnetApiSchema_xsdphoneNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1307, 5), ) + + + phoneNumber = property(__phoneNumber.value, __phoneNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}faxNumber uses Python identifier faxNumber + __faxNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'faxNumber'), 'faxNumber', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerAddressType_AnetApixmlv1schemaAnetApiSchema_xsdfaxNumber', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1314, 5), ) + + + faxNumber = property(__faxNumber.value, __faxNumber.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}email uses Python identifier email + __email = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'email'), 'email', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerAddressType_AnetApixmlv1schemaAnetApiSchema_xsdemail', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1321, 14), ) + + + email = property(__email.value, __email.set, None, None) + + _ElementMap.update({ + __phoneNumber.name() : __phoneNumber, + __faxNumber.name() : __faxNumber, + __email.name() : __email + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerAddressType', customerAddressType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType with content type ELEMENT_ONLY +class profileTransOrderType (profileTransAmountType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'profileTransOrderType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1426, 1) + _ElementMap = profileTransAmountType._ElementMap.copy() + _AttributeMap = profileTransAmountType._AttributeMap.copy() + # Base type is profileTransAmountType + + # Element amount ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element tax ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}tax) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element shipping ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipping) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element duty ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}duty) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element lineItems ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItems) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransOrderType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1430, 5), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId uses Python identifier customerPaymentProfileId + __customerPaymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), 'customerPaymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransOrderType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1431, 5), ) + + + customerPaymentProfileId = property(__customerPaymentProfileId.value, __customerPaymentProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerShippingAddressId uses Python identifier customerShippingAddressId + __customerShippingAddressId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId'), 'customerShippingAddressId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransOrderType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerShippingAddressId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1432, 5), ) + + + customerShippingAddressId = property(__customerShippingAddressId.value, __customerShippingAddressId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}order uses Python identifier order + __order = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'order'), 'order', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransOrderType_AnetApixmlv1schemaAnetApiSchema_xsdorder', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1433, 5), ) + + + order = property(__order.value, __order.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxExempt uses Python identifier taxExempt + __taxExempt = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'taxExempt'), 'taxExempt', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransOrderType_AnetApixmlv1schemaAnetApiSchema_xsdtaxExempt', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1434, 5), ) + + + taxExempt = property(__taxExempt.value, __taxExempt.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}recurringBilling uses Python identifier recurringBilling + __recurringBilling = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'recurringBilling'), 'recurringBilling', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransOrderType_AnetApixmlv1schemaAnetApiSchema_xsdrecurringBilling', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1435, 5), ) + + + recurringBilling = property(__recurringBilling.value, __recurringBilling.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardCode uses Python identifier cardCode + __cardCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardCode'), 'cardCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransOrderType_AnetApixmlv1schemaAnetApiSchema_xsdcardCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1436, 5), ) + + + cardCode = property(__cardCode.value, __cardCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderId uses Python identifier splitTenderId + __splitTenderId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId'), 'splitTenderId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransOrderType_AnetApixmlv1schemaAnetApiSchema_xsdsplitTenderId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1437, 5), ) + + + splitTenderId = property(__splitTenderId.value, __splitTenderId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __customerPaymentProfileId.name() : __customerPaymentProfileId, + __customerShippingAddressId.name() : __customerShippingAddressId, + __order.name() : __order, + __taxExempt.name() : __taxExempt, + __recurringBilling.name() : __recurringBilling, + __cardCode.name() : __cardCode, + __splitTenderId.name() : __splitTenderId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'profileTransOrderType', profileTransOrderType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransPriorAuthCaptureType with content type ELEMENT_ONLY +class profileTransPriorAuthCaptureType (profileTransAmountType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransPriorAuthCaptureType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'profileTransPriorAuthCaptureType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1457, 1) + _ElementMap = profileTransAmountType._ElementMap.copy() + _AttributeMap = profileTransAmountType._AttributeMap.copy() + # Base type is profileTransAmountType + + # Element amount ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element tax ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}tax) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element shipping ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipping) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element duty ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}duty) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element lineItems ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItems) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransPriorAuthCaptureType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1461, 5), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId uses Python identifier customerPaymentProfileId + __customerPaymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), 'customerPaymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransPriorAuthCaptureType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1462, 5), ) + + + customerPaymentProfileId = property(__customerPaymentProfileId.value, __customerPaymentProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerShippingAddressId uses Python identifier customerShippingAddressId + __customerShippingAddressId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId'), 'customerShippingAddressId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransPriorAuthCaptureType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerShippingAddressId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1463, 5), ) + + + customerShippingAddressId = property(__customerShippingAddressId.value, __customerShippingAddressId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transId uses Python identifier transId + __transId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transId'), 'transId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransPriorAuthCaptureType_AnetApixmlv1schemaAnetApiSchema_xsdtransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1464, 5), ) + + + transId = property(__transId.value, __transId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __customerPaymentProfileId.name() : __customerPaymentProfileId, + __customerShippingAddressId.name() : __customerShippingAddressId, + __transId.name() : __transId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'profileTransPriorAuthCaptureType', profileTransPriorAuthCaptureType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransRefundType with content type ELEMENT_ONLY +class profileTransRefundType (profileTransAmountType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransRefundType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'profileTransRefundType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1486, 1) + _ElementMap = profileTransAmountType._ElementMap.copy() + _AttributeMap = profileTransAmountType._AttributeMap.copy() + # Base type is profileTransAmountType + + # Element amount ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element tax ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}tax) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element shipping ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipping) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element duty ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}duty) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element lineItems ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItems) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransRefundType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1490, 5), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId uses Python identifier customerPaymentProfileId + __customerPaymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), 'customerPaymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransRefundType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1491, 5), ) + + + customerPaymentProfileId = property(__customerPaymentProfileId.value, __customerPaymentProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerShippingAddressId uses Python identifier customerShippingAddressId + __customerShippingAddressId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId'), 'customerShippingAddressId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransRefundType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerShippingAddressId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1492, 5), ) + + + customerShippingAddressId = property(__customerShippingAddressId.value, __customerShippingAddressId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}creditCardNumberMasked uses Python identifier creditCardNumberMasked + __creditCardNumberMasked = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'creditCardNumberMasked'), 'creditCardNumberMasked', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransRefundType_AnetApixmlv1schemaAnetApiSchema_xsdcreditCardNumberMasked', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1494, 5), ) + + + creditCardNumberMasked = property(__creditCardNumberMasked.value, __creditCardNumberMasked.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankRoutingNumberMasked uses Python identifier bankRoutingNumberMasked + __bankRoutingNumberMasked = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'bankRoutingNumberMasked'), 'bankRoutingNumberMasked', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransRefundType_AnetApixmlv1schemaAnetApiSchema_xsdbankRoutingNumberMasked', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1503, 5), ) + + + bankRoutingNumberMasked = property(__bankRoutingNumberMasked.value, __bankRoutingNumberMasked.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}bankAccountNumberMasked uses Python identifier bankAccountNumberMasked + __bankAccountNumberMasked = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'bankAccountNumberMasked'), 'bankAccountNumberMasked', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransRefundType_AnetApixmlv1schemaAnetApiSchema_xsdbankAccountNumberMasked', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1512, 5), ) + + + bankAccountNumberMasked = property(__bankAccountNumberMasked.value, __bankAccountNumberMasked.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}order uses Python identifier order + __order = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'order'), 'order', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransRefundType_AnetApixmlv1schemaAnetApiSchema_xsdorder', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1520, 5), ) + + + order = property(__order.value, __order.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transId uses Python identifier transId + __transId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transId'), 'transId', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransRefundType_AnetApixmlv1schemaAnetApiSchema_xsdtransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1521, 5), ) + + + transId = property(__transId.value, __transId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __customerPaymentProfileId.name() : __customerPaymentProfileId, + __customerShippingAddressId.name() : __customerShippingAddressId, + __creditCardNumberMasked.name() : __creditCardNumberMasked, + __bankRoutingNumberMasked.name() : __bankRoutingNumberMasked, + __bankAccountNumberMasked.name() : __bankAccountNumberMasked, + __order.name() : __order, + __transId.name() : __transId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'profileTransRefundType', profileTransRefundType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}emailSettingsType with content type ELEMENT_ONLY +class emailSettingsType (ArrayOfSetting): + """Allowed values for settingName are: headerEmailReceipt and footerEmailReceipt""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'emailSettingsType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1841, 2) + _ElementMap = ArrayOfSetting._ElementMap.copy() + _AttributeMap = ArrayOfSetting._AttributeMap.copy() + # Base type is ArrayOfSetting + + # Element setting ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}setting) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ArrayOfSetting + + # Attribute version uses Python identifier version + __version = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'version'), 'version', '__AnetApixmlv1schemaAnetApiSchema_xsd_emailSettingsType_version', STD_ANON_86) + __version._DeclarationLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1847, 8) + __version._UseLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1847, 8) + + version = property(__version.value, __version.set, None, None) + + _ElementMap.update({ + + }) + _AttributeMap.update({ + __version.name() : __version + }) +Namespace.addCategoryObject('typeBinding', 'emailSettingsType', emailSettingsType) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_20 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1945, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_21 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1959, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_22 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1973, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_23 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1988, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscription uses Python identifier subscription + __subscription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subscription'), 'subscription', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_23_AnetApixmlv1schemaAnetApiSchema_xsdsubscription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1992, 6), ) + + + subscription = property(__subscription.value, __subscription.set, None, None) + + _ElementMap.update({ + __subscription.name() : __subscription + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_24 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2005, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscriptionId uses Python identifier subscriptionId + __subscriptionId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId'), 'subscriptionId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_24_AnetApixmlv1schemaAnetApiSchema_xsdsubscriptionId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2010, 6), ) + + + subscriptionId = property(__subscriptionId.value, __subscriptionId.set, None, None) + + _ElementMap.update({ + __subscriptionId.name() : __subscriptionId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_25 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2024, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscriptionId uses Python identifier subscriptionId + __subscriptionId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId'), 'subscriptionId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_25_AnetApixmlv1schemaAnetApiSchema_xsdsubscriptionId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2028, 6), ) + + + subscriptionId = property(__subscriptionId.value, __subscriptionId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscription uses Python identifier subscription + __subscription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subscription'), 'subscription', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_25_AnetApixmlv1schemaAnetApiSchema_xsdsubscription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2029, 6), ) + + + subscription = property(__subscription.value, __subscription.set, None, None) + + _ElementMap.update({ + __subscriptionId.name() : __subscriptionId, + __subscription.name() : __subscription + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_26 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2042, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_27 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2057, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscriptionId uses Python identifier subscriptionId + __subscriptionId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId'), 'subscriptionId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_27_AnetApixmlv1schemaAnetApiSchema_xsdsubscriptionId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2061, 6), ) + + + subscriptionId = property(__subscriptionId.value, __subscriptionId.set, None, None) + + _ElementMap.update({ + __subscriptionId.name() : __subscriptionId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_28 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2074, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_29 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2089, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscriptionId uses Python identifier subscriptionId + __subscriptionId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId'), 'subscriptionId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_29_AnetApixmlv1schemaAnetApiSchema_xsdsubscriptionId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2093, 6), ) + + + subscriptionId = property(__subscriptionId.value, __subscriptionId.set, None, None) + + _ElementMap.update({ + __subscriptionId.name() : __subscriptionId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_30 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2106, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}status uses Python identifier status + __status = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'status'), 'status', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_30_AnetApixmlv1schemaAnetApiSchema_xsdstatus', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2110, 6), ) + + + status = property(__status.value, __status.set, None, None) + + _ElementMap.update({ + __status.name() : __status + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_31 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2125, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profile uses Python identifier profile + __profile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profile'), 'profile', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_31_AnetApixmlv1schemaAnetApiSchema_xsdprofile', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2129, 6), ) + + + profile = property(__profile.value, __profile.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}validationMode uses Python identifier validationMode + __validationMode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'validationMode'), 'validationMode', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_31_AnetApixmlv1schemaAnetApiSchema_xsdvalidationMode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2130, 6), ) + + + validationMode = property(__validationMode.value, __validationMode.set, None, None) + + _ElementMap.update({ + __profile.name() : __profile, + __validationMode.name() : __validationMode + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_32 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2143, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_32_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2148, 6), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileIdList uses Python identifier customerPaymentProfileIdList + __customerPaymentProfileIdList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileIdList'), 'customerPaymentProfileIdList', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_32_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileIdList', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2149, 6), ) + + + customerPaymentProfileIdList = property(__customerPaymentProfileIdList.value, __customerPaymentProfileIdList.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerShippingAddressIdList uses Python identifier customerShippingAddressIdList + __customerShippingAddressIdList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressIdList'), 'customerShippingAddressIdList', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_32_AnetApixmlv1schemaAnetApiSchema_xsdcustomerShippingAddressIdList', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2150, 6), ) + + + customerShippingAddressIdList = property(__customerShippingAddressIdList.value, __customerShippingAddressIdList.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}validationDirectResponseList uses Python identifier validationDirectResponseList + __validationDirectResponseList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'validationDirectResponseList'), 'validationDirectResponseList', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_32_AnetApixmlv1schemaAnetApiSchema_xsdvalidationDirectResponseList', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2151, 6), ) + + + validationDirectResponseList = property(__validationDirectResponseList.value, __validationDirectResponseList.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __customerPaymentProfileIdList.name() : __customerPaymentProfileIdList, + __customerShippingAddressIdList.name() : __customerShippingAddressIdList, + __validationDirectResponseList.name() : __validationDirectResponseList + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_33 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2182, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_33_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2186, 6), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentProfile uses Python identifier paymentProfile + __paymentProfile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile'), 'paymentProfile', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_33_AnetApixmlv1schemaAnetApiSchema_xsdpaymentProfile', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2187, 6), ) + + + paymentProfile = property(__paymentProfile.value, __paymentProfile.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}validationMode uses Python identifier validationMode + __validationMode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'validationMode'), 'validationMode', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_33_AnetApixmlv1schemaAnetApiSchema_xsdvalidationMode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2188, 6), ) + + + validationMode = property(__validationMode.value, __validationMode.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __paymentProfile.name() : __paymentProfile, + __validationMode.name() : __validationMode + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_34 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2201, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId uses Python identifier customerPaymentProfileId + __customerPaymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), 'customerPaymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_34_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2206, 6), ) + + + customerPaymentProfileId = property(__customerPaymentProfileId.value, __customerPaymentProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}validationDirectResponse uses Python identifier validationDirectResponse + __validationDirectResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'validationDirectResponse'), 'validationDirectResponse', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_34_AnetApixmlv1schemaAnetApiSchema_xsdvalidationDirectResponse', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2208, 6), ) + + + validationDirectResponse = property(__validationDirectResponse.value, __validationDirectResponse.set, None, None) + + _ElementMap.update({ + __customerPaymentProfileId.name() : __customerPaymentProfileId, + __validationDirectResponse.name() : __validationDirectResponse + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_35 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2228, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_35_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2232, 6), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}address uses Python identifier address + __address = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'address'), 'address', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_35_AnetApixmlv1schemaAnetApiSchema_xsdaddress', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2233, 6), ) + + + address = property(__address.value, __address.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __address.name() : __address + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_36 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2246, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressId uses Python identifier customerAddressId + __customerAddressId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId'), 'customerAddressId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_36_AnetApixmlv1schemaAnetApiSchema_xsdcustomerAddressId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2251, 6), ) + + + customerAddressId = property(__customerAddressId.value, __customerAddressId.set, None, None) + + _ElementMap.update({ + __customerAddressId.name() : __customerAddressId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_37 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2264, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transId uses Python identifier transId + __transId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transId'), 'transId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_37_AnetApixmlv1schemaAnetApiSchema_xsdtransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2268, 12), ) + + + transId = property(__transId.value, __transId.set, None, None) + + _ElementMap.update({ + __transId.name() : __transId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_38 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2284, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_38_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2288, 12), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_39 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2301, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profile uses Python identifier profile + __profile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profile'), 'profile', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_39_AnetApixmlv1schemaAnetApiSchema_xsdprofile', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2306, 12), ) + + + profile = property(__profile.value, __profile.set, None, None) + + _ElementMap.update({ + __profile.name() : __profile + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_40 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2320, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_40_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2324, 12), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId uses Python identifier customerPaymentProfileId + __customerPaymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), 'customerPaymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_40_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2325, 12), ) + + + customerPaymentProfileId = property(__customerPaymentProfileId.value, __customerPaymentProfileId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __customerPaymentProfileId.name() : __customerPaymentProfileId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_41 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2338, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentProfile uses Python identifier paymentProfile + __paymentProfile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile'), 'paymentProfile', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_41_AnetApixmlv1schemaAnetApiSchema_xsdpaymentProfile', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2343, 12), ) + + + paymentProfile = property(__paymentProfile.value, __paymentProfile.set, None, None) + + _ElementMap.update({ + __paymentProfile.name() : __paymentProfile + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_42 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2357, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_42_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2361, 12), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressId uses Python identifier customerAddressId + __customerAddressId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId'), 'customerAddressId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_42_AnetApixmlv1schemaAnetApiSchema_xsdcustomerAddressId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2362, 12), ) + + + customerAddressId = property(__customerAddressId.value, __customerAddressId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __customerAddressId.name() : __customerAddressId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_43 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2375, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}address uses Python identifier address + __address = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'address'), 'address', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_43_AnetApixmlv1schemaAnetApiSchema_xsdaddress', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2380, 12), ) + + + address = property(__address.value, __address.set, None, None) + + _ElementMap.update({ + __address.name() : __address + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_44 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2394, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profile uses Python identifier profile + __profile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profile'), 'profile', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_44_AnetApixmlv1schemaAnetApiSchema_xsdprofile', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2398, 12), ) + + + profile = property(__profile.value, __profile.set, None, None) + + _ElementMap.update({ + __profile.name() : __profile + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_45 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2411, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_46 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2426, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_46_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2430, 12), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentProfile uses Python identifier paymentProfile + __paymentProfile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile'), 'paymentProfile', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_46_AnetApixmlv1schemaAnetApiSchema_xsdpaymentProfile', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2431, 12), ) + + + paymentProfile = property(__paymentProfile.value, __paymentProfile.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}validationMode uses Python identifier validationMode + __validationMode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'validationMode'), 'validationMode', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_46_AnetApixmlv1schemaAnetApiSchema_xsdvalidationMode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2432, 12), ) + + + validationMode = property(__validationMode.value, __validationMode.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __paymentProfile.name() : __paymentProfile, + __validationMode.name() : __validationMode + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_47 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2445, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}validationDirectResponse uses Python identifier validationDirectResponse + __validationDirectResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'validationDirectResponse'), 'validationDirectResponse', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_47_AnetApixmlv1schemaAnetApiSchema_xsdvalidationDirectResponse', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2450, 12), ) + + + validationDirectResponse = property(__validationDirectResponse.value, __validationDirectResponse.set, None, None) + + _ElementMap.update({ + __validationDirectResponse.name() : __validationDirectResponse + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_48 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2470, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_48_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2474, 12), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}address uses Python identifier address + __address = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'address'), 'address', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_48_AnetApixmlv1schemaAnetApiSchema_xsdaddress', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2475, 12), ) + + + address = property(__address.value, __address.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __address.name() : __address + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_49 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2488, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_50 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2504, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_50_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2508, 12), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_51 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2521, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_52 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2536, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_52_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2540, 12), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId uses Python identifier customerPaymentProfileId + __customerPaymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), 'customerPaymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_52_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2541, 12), ) + + + customerPaymentProfileId = property(__customerPaymentProfileId.value, __customerPaymentProfileId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __customerPaymentProfileId.name() : __customerPaymentProfileId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_53 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2554, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_54 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2569, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_54_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2573, 12), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressId uses Python identifier customerAddressId + __customerAddressId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId'), 'customerAddressId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_54_AnetApixmlv1schemaAnetApiSchema_xsdcustomerAddressId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2574, 12), ) + + + customerAddressId = property(__customerAddressId.value, __customerAddressId.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __customerAddressId.name() : __customerAddressId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_55 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2587, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_56 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2602, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transaction uses Python identifier transaction + __transaction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transaction'), 'transaction', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_56_AnetApixmlv1schemaAnetApiSchema_xsdtransaction', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2606, 12), ) + + + transaction = property(__transaction.value, __transaction.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}extraOptions uses Python identifier extraOptions + __extraOptions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'extraOptions'), 'extraOptions', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_56_AnetApixmlv1schemaAnetApiSchema_xsdextraOptions', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2607, 12), ) + + + extraOptions = property(__extraOptions.value, __extraOptions.set, None, None) + + _ElementMap.update({ + __transaction.name() : __transaction, + __extraOptions.name() : __extraOptions + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_57 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2626, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionResponse uses Python identifier transactionResponse + __transactionResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionResponse'), 'transactionResponse', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_57_AnetApixmlv1schemaAnetApiSchema_xsdtransactionResponse', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2630, 48), ) + + + transactionResponse = property(__transactionResponse.value, __transactionResponse.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}directResponse uses Python identifier directResponse + __directResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'directResponse'), 'directResponse', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_57_AnetApixmlv1schemaAnetApiSchema_xsddirectResponse', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2631, 12), ) + + + directResponse = property(__directResponse.value, __directResponse.set, None, None) + + _ElementMap.update({ + __transactionResponse.name() : __transactionResponse, + __directResponse.name() : __directResponse + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_58 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2651, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_58_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2655, 12), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId uses Python identifier customerPaymentProfileId + __customerPaymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), 'customerPaymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_58_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2656, 12), ) + + + customerPaymentProfileId = property(__customerPaymentProfileId.value, __customerPaymentProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerShippingAddressId uses Python identifier customerShippingAddressId + __customerShippingAddressId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId'), 'customerShippingAddressId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_58_AnetApixmlv1schemaAnetApiSchema_xsdcustomerShippingAddressId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2657, 12), ) + + + customerShippingAddressId = property(__customerShippingAddressId.value, __customerShippingAddressId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardCode uses Python identifier cardCode + __cardCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cardCode'), 'cardCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_58_AnetApixmlv1schemaAnetApiSchema_xsdcardCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2658, 12), ) + + + cardCode = property(__cardCode.value, __cardCode.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}validationMode uses Python identifier validationMode + __validationMode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'validationMode'), 'validationMode', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_58_AnetApixmlv1schemaAnetApiSchema_xsdvalidationMode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2659, 12), ) + + + validationMode = property(__validationMode.value, __validationMode.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __customerPaymentProfileId.name() : __customerPaymentProfileId, + __customerShippingAddressId.name() : __customerShippingAddressId, + __cardCode.name() : __cardCode, + __validationMode.name() : __validationMode + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_59 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2672, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}directResponse uses Python identifier directResponse + __directResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'directResponse'), 'directResponse', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_59_AnetApixmlv1schemaAnetApiSchema_xsddirectResponse', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2676, 12), ) + + + directResponse = property(__directResponse.value, __directResponse.set, None, None) + + _ElementMap.update({ + __directResponse.name() : __directResponse + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_60 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2696, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_61 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2710, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ids uses Python identifier ids + __ids = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ids'), 'ids', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_61_AnetApixmlv1schemaAnetApiSchema_xsdids', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2714, 12), ) + + + ids = property(__ids.value, __ids.set, None, None) + + _ElementMap.update({ + __ids.name() : __ids + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_62 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2727, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderId uses Python identifier splitTenderId + __splitTenderId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId'), 'splitTenderId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_62_AnetApixmlv1schemaAnetApiSchema_xsdsplitTenderId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2731, 12), ) + + + splitTenderId = property(__splitTenderId.value, __splitTenderId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderStatus uses Python identifier splitTenderStatus + __splitTenderStatus = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'splitTenderStatus'), 'splitTenderStatus', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_62_AnetApixmlv1schemaAnetApiSchema_xsdsplitTenderStatus', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2732, 12), ) + + + splitTenderStatus = property(__splitTenderStatus.value, __splitTenderStatus.set, None, None) + + _ElementMap.update({ + __splitTenderId.name() : __splitTenderId, + __splitTenderStatus.name() : __splitTenderStatus + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_63 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2745, 4) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_64 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2759, 4) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transId uses Python identifier transId + __transId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transId'), 'transId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_64_AnetApixmlv1schemaAnetApiSchema_xsdtransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2763, 12), ) + + + transId = property(__transId.value, __transId.set, None, None) + + _ElementMap.update({ + __transId.name() : __transId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_65 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2776, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transaction uses Python identifier transaction + __transaction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transaction'), 'transaction', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_65_AnetApixmlv1schemaAnetApiSchema_xsdtransaction', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2780, 6), ) + + + transaction = property(__transaction.value, __transaction.set, None, None) + + _ElementMap.update({ + __transaction.name() : __transaction + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_66 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2794, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionRequest uses Python identifier transactionRequest + __transactionRequest = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionRequest'), 'transactionRequest', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_66_AnetApixmlv1schemaAnetApiSchema_xsdtransactionRequest', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2798, 6), ) + + + transactionRequest = property(__transactionRequest.value, __transactionRequest.set, None, None) + + _ElementMap.update({ + __transactionRequest.name() : __transactionRequest + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_67 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2812, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactionResponse uses Python identifier transactionResponse + __transactionResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactionResponse'), 'transactionResponse', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_67_AnetApixmlv1schemaAnetApiSchema_xsdtransactionResponse', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2816, 6), ) + + + transactionResponse = property(__transactionResponse.value, __transactionResponse.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileResponse uses Python identifier profileResponse + __profileResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'profileResponse'), 'profileResponse', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_67_AnetApixmlv1schemaAnetApiSchema_xsdprofileResponse', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2817, 12), ) + + + profileResponse = property(__profileResponse.value, __profileResponse.set, None, None) + + _ElementMap.update({ + __transactionResponse.name() : __transactionResponse, + __profileResponse.name() : __profileResponse + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_68 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2830, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batchId uses Python identifier batchId + __batchId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'batchId'), 'batchId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_68_AnetApixmlv1schemaAnetApiSchema_xsdbatchId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2834, 6), ) + + + batchId = property(__batchId.value, __batchId.set, None, None) + + _ElementMap.update({ + __batchId.name() : __batchId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_69 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2847, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batch uses Python identifier batch + __batch = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'batch'), 'batch', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_69_AnetApixmlv1schemaAnetApiSchema_xsdbatch', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2851, 6), ) + + + batch = property(__batch.value, __batch.set, None, None) + + _ElementMap.update({ + __batch.name() : __batch + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_70 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2864, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}includeStatistics uses Python identifier includeStatistics + __includeStatistics = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'includeStatistics'), 'includeStatistics', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_70_AnetApixmlv1schemaAnetApiSchema_xsdincludeStatistics', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2868, 6), ) + + + includeStatistics = property(__includeStatistics.value, __includeStatistics.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}firstSettlementDate uses Python identifier firstSettlementDate + __firstSettlementDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'firstSettlementDate'), 'firstSettlementDate', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_70_AnetApixmlv1schemaAnetApiSchema_xsdfirstSettlementDate', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2869, 6), ) + + + firstSettlementDate = property(__firstSettlementDate.value, __firstSettlementDate.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}lastSettlementDate uses Python identifier lastSettlementDate + __lastSettlementDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'lastSettlementDate'), 'lastSettlementDate', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_70_AnetApixmlv1schemaAnetApiSchema_xsdlastSettlementDate', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2870, 6), ) + + + lastSettlementDate = property(__lastSettlementDate.value, __lastSettlementDate.set, None, None) + + _ElementMap.update({ + __includeStatistics.name() : __includeStatistics, + __firstSettlementDate.name() : __firstSettlementDate, + __lastSettlementDate.name() : __lastSettlementDate + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_71 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2883, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batchList uses Python identifier batchList + __batchList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'batchList'), 'batchList', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_71_AnetApixmlv1schemaAnetApiSchema_xsdbatchList', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2887, 6), ) + + + batchList = property(__batchList.value, __batchList.set, None, None) + + _ElementMap.update({ + __batchList.name() : __batchList + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_72 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2900, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}batchId uses Python identifier batchId + __batchId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'batchId'), 'batchId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_72_AnetApixmlv1schemaAnetApiSchema_xsdbatchId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2904, 6), ) + + + batchId = property(__batchId.value, __batchId.set, None, None) + + _ElementMap.update({ + __batchId.name() : __batchId + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_73 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2917, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactions uses Python identifier transactions + __transactions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactions'), 'transactions', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_73_AnetApixmlv1schemaAnetApiSchema_xsdtransactions', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2921, 6), ) + + + transactions = property(__transactions.value, __transactions.set, None, None) + + _ElementMap.update({ + __transactions.name() : __transactions + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_74 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2935, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_74_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2939, 6), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}hostedProfileSettings uses Python identifier hostedProfileSettings + __hostedProfileSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'hostedProfileSettings'), 'hostedProfileSettings', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_74_AnetApixmlv1schemaAnetApiSchema_xsdhostedProfileSettings', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2940, 6), ) + + + hostedProfileSettings = property(__hostedProfileSettings.value, __hostedProfileSettings.set, None, 'Allowed values for settingName are: hostedProfileReturnUrl, hostedProfileReturnUrlText, hostedProfilePageBorderVisible, hostedProfileIFrameCommunicatorUrl, hostedProfileHeadingBgColor, hostedProfileBillingAddressRequired, hostedProfileCardCodeRequired.') + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __hostedProfileSettings.name() : __hostedProfileSettings + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_75 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2957, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}token uses Python identifier token + __token = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'token'), 'token', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_75_AnetApixmlv1schemaAnetApiSchema_xsdtoken', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2961, 6), ) + + + token = property(__token.value, __token.set, None, None) + + _ElementMap.update({ + __token.name() : __token + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_76 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2974, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_77 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2988, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transactions uses Python identifier transactions + __transactions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transactions'), 'transactions', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_77_AnetApixmlv1schemaAnetApiSchema_xsdtransactions', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2992, 6), ) + + + transactions = property(__transactions.value, __transactions.set, None, None) + + _ElementMap.update({ + __transactions.name() : __transactions + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_78 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3006, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}mobileDevice uses Python identifier mobileDevice + __mobileDevice = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'mobileDevice'), 'mobileDevice', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_78_AnetApixmlv1schemaAnetApiSchema_xsdmobileDevice', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3010, 6), ) + + + mobileDevice = property(__mobileDevice.value, __mobileDevice.set, None, None) + + _ElementMap.update({ + __mobileDevice.name() : __mobileDevice + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_79 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3023, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_80 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3036, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_81 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3049, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantContact uses Python identifier merchantContact + __merchantContact = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantContact'), 'merchantContact', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_81_AnetApixmlv1schemaAnetApiSchema_xsdmerchantContact', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3053, 6), ) + + + merchantContact = property(__merchantContact.value, __merchantContact.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}userPermissions uses Python identifier userPermissions + __userPermissions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'userPermissions'), 'userPermissions', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_81_AnetApixmlv1schemaAnetApiSchema_xsduserPermissions', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3054, 6), ) + + + userPermissions = property(__userPermissions.value, __userPermissions.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAccount uses Python identifier merchantAccount + __merchantAccount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'merchantAccount'), 'merchantAccount', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_81_AnetApixmlv1schemaAnetApiSchema_xsdmerchantAccount', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3055, 24), ) + + + merchantAccount = property(__merchantAccount.value, __merchantAccount.set, None, None) + + _ElementMap.update({ + __merchantContact.name() : __merchantContact, + __userPermissions.name() : __userPermissions, + __merchantAccount.name() : __merchantAccount + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_82 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3068, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_83 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3081, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_84 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3094, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}transId uses Python identifier transId + __transId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'transId'), 'transId', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_84_AnetApixmlv1schemaAnetApiSchema_xsdtransId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3098, 6), ) + + + transId = property(__transId.value, __transId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerEmail uses Python identifier customerEmail + __customerEmail = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerEmail'), 'customerEmail', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_84_AnetApixmlv1schemaAnetApiSchema_xsdcustomerEmail', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3099, 6), ) + + + customerEmail = property(__customerEmail.value, __customerEmail.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}emailSettings uses Python identifier emailSettings + __emailSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'emailSettings'), 'emailSettings', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_84_AnetApixmlv1schemaAnetApiSchema_xsdemailSettings', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3100, 6), ) + + + emailSettings = property(__emailSettings.value, __emailSettings.set, None, None) + + _ElementMap.update({ + __transId.name() : __transId, + __customerEmail.name() : __customerEmail, + __emailSettings.name() : __emailSettings + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_85 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3113, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_86 (ANetApiRequest): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3171, 2) + _ElementMap = ANetApiRequest._ElementMap.copy() + _AttributeMap = ANetApiRequest._AttributeMap.copy() + # Base type is ANetApiRequest + + # Element merchantAuthentication ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantAuthentication) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiRequest + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}searchType uses Python identifier searchType + __searchType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'searchType'), 'searchType', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_86_AnetApixmlv1schemaAnetApiSchema_xsdsearchType', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3175, 6), ) + + + searchType = property(__searchType.value, __searchType.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}sorting uses Python identifier sorting + __sorting = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'sorting'), 'sorting', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_86_AnetApixmlv1schemaAnetApiSchema_xsdsorting', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3176, 6), ) + + + sorting = property(__sorting.value, __sorting.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paging uses Python identifier paging + __paging = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paging'), 'paging', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_86_AnetApixmlv1schemaAnetApiSchema_xsdpaging', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3177, 6), ) + + + paging = property(__paging.value, __paging.set, None, None) + + _ElementMap.update({ + __searchType.name() : __searchType, + __sorting.name() : __sorting, + __paging.name() : __paging + }) + _AttributeMap.update({ + + }) + + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_87 (ANetApiResponse): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3231, 2) + _ElementMap = ANetApiResponse._ElementMap.copy() + _AttributeMap = ANetApiResponse._AttributeMap.copy() + # Base type is ANetApiResponse + + # Element refId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}refId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element messages ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}messages) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element sessionToken ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}sessionToken) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}ANetApiResponse + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}totalNumInResultSet uses Python identifier totalNumInResultSet + __totalNumInResultSet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'totalNumInResultSet'), 'totalNumInResultSet', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_87_AnetApixmlv1schemaAnetApiSchema_xsdtotalNumInResultSet', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3235, 6), ) + + + totalNumInResultSet = property(__totalNumInResultSet.value, __totalNumInResultSet.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}subscriptionDetails uses Python identifier subscriptionDetails + __subscriptionDetails = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'subscriptionDetails'), 'subscriptionDetails', '__AnetApixmlv1schemaAnetApiSchema_xsd_CTD_ANON_87_AnetApixmlv1schemaAnetApiSchema_xsdsubscriptionDetails', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3236, 6), ) + + + subscriptionDetails = property(__subscriptionDetails.value, __subscriptionDetails.set, None, None) + + _ElementMap.update({ + __totalNumInResultSet.name() : __totalNumInResultSet, + __subscriptionDetails.name() : __subscriptionDetails + }) + _AttributeMap.update({ + + }) + + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileSummaryType with content type ELEMENT_ONLY +class customerProfileSummaryType (searchCriteriaCustomerProfileType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileSummaryType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerProfileSummaryType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3284, 4) + _ElementMap = searchCriteriaCustomerProfileType._ElementMap.copy() + _AttributeMap = searchCriteriaCustomerProfileType._AttributeMap.copy() + # Base type is searchCriteriaCustomerProfileType + + # Element merchantCustomerId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantCustomerId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}searchCriteriaCustomerProfileType + + # Element email ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}email) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}searchCriteriaCustomerProfileType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId uses Python identifier customerProfileId + __customerProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), 'customerProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfileSummaryType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3288, 20), ) + + + customerProfileId = property(__customerProfileId.value, __customerProfileId.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}description uses Python identifier description + __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'description'), 'description', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfileSummaryType_AnetApixmlv1schemaAnetApiSchema_xsddescription', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3289, 20), ) + + + description = property(__description.value, __description.set, None, None) + + _ElementMap.update({ + __customerProfileId.name() : __customerProfileId, + __description.name() : __description + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerProfileSummaryType', customerProfileSummaryType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileExType with content type ELEMENT_ONLY +class customerPaymentProfileExType (customerPaymentProfileType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileExType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileExType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1216, 1) + _ElementMap = customerPaymentProfileType._ElementMap.copy() + _AttributeMap = customerPaymentProfileType._AttributeMap.copy() + # Base type is customerPaymentProfileType + + # Element customerType ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerType) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileBaseType + + # Element billTo ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}billTo) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileBaseType + + # Element payment ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}payment) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileType + + # Element driversLicense ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}driversLicense) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileType + + # Element taxId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId uses Python identifier customerPaymentProfileId + __customerPaymentProfileId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), 'customerPaymentProfileId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerPaymentProfileExType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerPaymentProfileId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1220, 5), ) + + + customerPaymentProfileId = property(__customerPaymentProfileId.value, __customerPaymentProfileId.set, None, None) + + _ElementMap.update({ + __customerPaymentProfileId.name() : __customerPaymentProfileId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerPaymentProfileExType', customerPaymentProfileExType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileMaskedType with content type ELEMENT_ONLY +class customerProfileMaskedType (customerProfileExType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileMaskedType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerProfileMaskedType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1292, 1) + _ElementMap = customerProfileExType._ElementMap.copy() + _AttributeMap = customerProfileExType._AttributeMap.copy() + # Base type is customerProfileExType + + # Element merchantCustomerId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}merchantCustomerId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType + + # Element description ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}description) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType + + # Element email ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}email) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileBaseType + + # Element customerProfileId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileExType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}paymentProfiles uses Python identifier paymentProfiles + __paymentProfiles = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'paymentProfiles'), 'paymentProfiles', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfileMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdpaymentProfiles', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1296, 5), ) + + + paymentProfiles = property(__paymentProfiles.value, __paymentProfiles.set, None, None) + + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipToList uses Python identifier shipToList + __shipToList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'shipToList'), 'shipToList', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerProfileMaskedType_AnetApixmlv1schemaAnetApiSchema_xsdshipToList', True, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1297, 5), ) + + + shipToList = property(__shipToList.value, __shipToList.set, None, None) + + _ElementMap.update({ + __paymentProfiles.name() : __paymentProfiles, + __shipToList.name() : __shipToList + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerProfileMaskedType', customerProfileMaskedType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressExType with content type ELEMENT_ONLY +class customerAddressExType (customerAddressType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressExType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'customerAddressExType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1327, 1) + _ElementMap = customerAddressType._ElementMap.copy() + _AttributeMap = customerAddressType._AttributeMap.copy() + # Base type is customerAddressType + + # Element firstName ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}firstName) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element lastName ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}lastName) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element company ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}company) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element address ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}address) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element city ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}city) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element state ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}state) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element zip ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}zip) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element country ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}country) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}nameAndAddressType + + # Element phoneNumber ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}phoneNumber) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressType + + # Element faxNumber ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}faxNumber) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressType + + # Element email ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}email) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerAddressId uses Python identifier customerAddressId + __customerAddressId = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId'), 'customerAddressId', '__AnetApixmlv1schemaAnetApiSchema_xsd_customerAddressExType_AnetApixmlv1schemaAnetApiSchema_xsdcustomerAddressId', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1331, 5), ) + + + customerAddressId = property(__customerAddressId.value, __customerAddressId.set, None, None) + + _ElementMap.update({ + __customerAddressId.name() : __customerAddressId + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'customerAddressExType', customerAddressExType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAuthCaptureType with content type ELEMENT_ONLY +class profileTransAuthCaptureType (profileTransOrderType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAuthCaptureType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'profileTransAuthCaptureType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1443, 1) + _ElementMap = profileTransOrderType._ElementMap.copy() + _AttributeMap = profileTransOrderType._AttributeMap.copy() + # Base type is profileTransOrderType + + # Element amount ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element tax ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}tax) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element shipping ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipping) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element duty ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}duty) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element lineItems ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItems) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element customerProfileId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element customerPaymentProfileId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element customerShippingAddressId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerShippingAddressId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element order ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}order) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element taxExempt ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxExempt) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element recurringBilling ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}recurringBilling) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element cardCode ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardCode) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element splitTenderId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'profileTransAuthCaptureType', profileTransAuthCaptureType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAuthOnlyType with content type ELEMENT_ONLY +class profileTransAuthOnlyType (profileTransOrderType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAuthOnlyType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'profileTransAuthOnlyType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1450, 1) + _ElementMap = profileTransOrderType._ElementMap.copy() + _AttributeMap = profileTransOrderType._AttributeMap.copy() + # Base type is profileTransOrderType + + # Element amount ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element tax ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}tax) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element shipping ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipping) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element duty ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}duty) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element lineItems ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItems) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element customerProfileId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element customerPaymentProfileId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element customerShippingAddressId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerShippingAddressId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element order ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}order) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element taxExempt ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxExempt) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element recurringBilling ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}recurringBilling) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element cardCode ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardCode) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element splitTenderId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'profileTransAuthOnlyType', profileTransAuthOnlyType) + + +# Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransCaptureOnlyType with content type ELEMENT_ONLY +class profileTransCaptureOnlyType (profileTransOrderType): + """Complex type {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransCaptureOnlyType with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'profileTransCaptureOnlyType') + _XSDLocation = pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1470, 1) + _ElementMap = profileTransOrderType._ElementMap.copy() + _AttributeMap = profileTransOrderType._AttributeMap.copy() + # Base type is profileTransOrderType + + # Element amount ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}amount) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element tax ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}tax) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element shipping ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}shipping) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element duty ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}duty) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element lineItems ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}lineItems) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransAmountType + + # Element customerProfileId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerProfileId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element customerPaymentProfileId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerPaymentProfileId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element customerShippingAddressId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}customerShippingAddressId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element order ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}order) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element taxExempt ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}taxExempt) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element recurringBilling ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}recurringBilling) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element cardCode ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}cardCode) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element splitTenderId ({AnetApi/xml/v1/schema/AnetApiSchema.xsd}splitTenderId) inherited from {AnetApi/xml/v1/schema/AnetApiSchema.xsd}profileTransOrderType + + # Element {AnetApi/xml/v1/schema/AnetApiSchema.xsd}approvalCode uses Python identifier approvalCode + __approvalCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'approvalCode'), 'approvalCode', '__AnetApixmlv1schemaAnetApiSchema_xsd_profileTransCaptureOnlyType_AnetApixmlv1schemaAnetApiSchema_xsdapprovalCode', False, pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1474, 5), ) + + + approvalCode = property(__approvalCode.value, __approvalCode.set, None, None) + + _ElementMap.update({ + __approvalCode.name() : __approvalCode + }) + _AttributeMap.update({ + + }) +Namespace.addCategoryObject('typeBinding', 'profileTransCaptureOnlyType', profileTransCaptureOnlyType) + + +ErrorResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ErrorResponse'), ANetApiResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1918, 1)) +Namespace.addCategoryObject('elementBinding', ErrorResponse.name().localName(), ErrorResponse) + +isAliveRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'isAliveRequest'), CTD_ANON_16, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1925, 1)) +Namespace.addCategoryObject('elementBinding', isAliveRequest.name().localName(), isAliveRequest) + +EnumCollection = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'EnumCollection'), CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3296, 4)) +Namespace.addCategoryObject('elementBinding', EnumCollection.name().localName(), EnumCollection) + +decryptPaymentDataRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'decryptPaymentDataRequest'), CTD_ANON_18, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 780, 2)) +Namespace.addCategoryObject('elementBinding', decryptPaymentDataRequest.name().localName(), decryptPaymentDataRequest) + +decryptPaymentDataResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'decryptPaymentDataResponse'), CTD_ANON_19, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 793, 2)) +Namespace.addCategoryObject('elementBinding', decryptPaymentDataResponse.name().localName(), decryptPaymentDataResponse) + +isAliveResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'isAliveResponse'), CTD_ANON_20, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1944, 1)) +Namespace.addCategoryObject('elementBinding', isAliveResponse.name().localName(), isAliveResponse) + +authenticateTestRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'authenticateTestRequest'), CTD_ANON_21, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1958, 1)) +Namespace.addCategoryObject('elementBinding', authenticateTestRequest.name().localName(), authenticateTestRequest) + +authenticateTestResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'authenticateTestResponse'), CTD_ANON_22, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1972, 1)) +Namespace.addCategoryObject('elementBinding', authenticateTestResponse.name().localName(), authenticateTestResponse) + +ARBCreateSubscriptionRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ARBCreateSubscriptionRequest'), CTD_ANON_23, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1987, 1)) +Namespace.addCategoryObject('elementBinding', ARBCreateSubscriptionRequest.name().localName(), ARBCreateSubscriptionRequest) + +ARBCreateSubscriptionResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ARBCreateSubscriptionResponse'), CTD_ANON_24, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2004, 1)) +Namespace.addCategoryObject('elementBinding', ARBCreateSubscriptionResponse.name().localName(), ARBCreateSubscriptionResponse) + +ARBUpdateSubscriptionRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ARBUpdateSubscriptionRequest'), CTD_ANON_25, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2023, 1)) +Namespace.addCategoryObject('elementBinding', ARBUpdateSubscriptionRequest.name().localName(), ARBUpdateSubscriptionRequest) + +ARBUpdateSubscriptionResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ARBUpdateSubscriptionResponse'), CTD_ANON_26, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2041, 1)) +Namespace.addCategoryObject('elementBinding', ARBUpdateSubscriptionResponse.name().localName(), ARBUpdateSubscriptionResponse) + +ARBCancelSubscriptionRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ARBCancelSubscriptionRequest'), CTD_ANON_27, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2056, 1)) +Namespace.addCategoryObject('elementBinding', ARBCancelSubscriptionRequest.name().localName(), ARBCancelSubscriptionRequest) + +ARBCancelSubscriptionResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ARBCancelSubscriptionResponse'), CTD_ANON_28, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2073, 1)) +Namespace.addCategoryObject('elementBinding', ARBCancelSubscriptionResponse.name().localName(), ARBCancelSubscriptionResponse) + +ARBGetSubscriptionStatusRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ARBGetSubscriptionStatusRequest'), CTD_ANON_29, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2088, 1)) +Namespace.addCategoryObject('elementBinding', ARBGetSubscriptionStatusRequest.name().localName(), ARBGetSubscriptionStatusRequest) + +ARBGetSubscriptionStatusResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ARBGetSubscriptionStatusResponse'), CTD_ANON_30, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2105, 1)) +Namespace.addCategoryObject('elementBinding', ARBGetSubscriptionStatusResponse.name().localName(), ARBGetSubscriptionStatusResponse) + +createCustomerProfileRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createCustomerProfileRequest'), CTD_ANON_31, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2124, 1)) +Namespace.addCategoryObject('elementBinding', createCustomerProfileRequest.name().localName(), createCustomerProfileRequest) + +createCustomerProfileResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createCustomerProfileResponse'), CTD_ANON_32, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2142, 1)) +Namespace.addCategoryObject('elementBinding', createCustomerProfileResponse.name().localName(), createCustomerProfileResponse) + +createCustomerPaymentProfileRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createCustomerPaymentProfileRequest'), CTD_ANON_33, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2181, 1)) +Namespace.addCategoryObject('elementBinding', createCustomerPaymentProfileRequest.name().localName(), createCustomerPaymentProfileRequest) + +createCustomerPaymentProfileResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createCustomerPaymentProfileResponse'), CTD_ANON_34, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2200, 1)) +Namespace.addCategoryObject('elementBinding', createCustomerPaymentProfileResponse.name().localName(), createCustomerPaymentProfileResponse) + +createCustomerShippingAddressRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createCustomerShippingAddressRequest'), CTD_ANON_35, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2227, 1)) +Namespace.addCategoryObject('elementBinding', createCustomerShippingAddressRequest.name().localName(), createCustomerShippingAddressRequest) + +createCustomerShippingAddressResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createCustomerShippingAddressResponse'), CTD_ANON_36, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2245, 1)) +Namespace.addCategoryObject('elementBinding', createCustomerShippingAddressResponse.name().localName(), createCustomerShippingAddressResponse) + +createCustomerProfileFromTransactionRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createCustomerProfileFromTransactionRequest'), CTD_ANON_37, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2263, 2)) +Namespace.addCategoryObject('elementBinding', createCustomerProfileFromTransactionRequest.name().localName(), createCustomerProfileFromTransactionRequest) + +getCustomerProfileRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getCustomerProfileRequest'), CTD_ANON_38, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2283, 1)) +Namespace.addCategoryObject('elementBinding', getCustomerProfileRequest.name().localName(), getCustomerProfileRequest) + +getCustomerProfileResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getCustomerProfileResponse'), CTD_ANON_39, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2300, 2)) +Namespace.addCategoryObject('elementBinding', getCustomerProfileResponse.name().localName(), getCustomerProfileResponse) + +getCustomerPaymentProfileRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getCustomerPaymentProfileRequest'), CTD_ANON_40, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2319, 2)) +Namespace.addCategoryObject('elementBinding', getCustomerPaymentProfileRequest.name().localName(), getCustomerPaymentProfileRequest) + +getCustomerPaymentProfileResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getCustomerPaymentProfileResponse'), CTD_ANON_41, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2337, 2)) +Namespace.addCategoryObject('elementBinding', getCustomerPaymentProfileResponse.name().localName(), getCustomerPaymentProfileResponse) + +getCustomerShippingAddressRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getCustomerShippingAddressRequest'), CTD_ANON_42, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2356, 2)) +Namespace.addCategoryObject('elementBinding', getCustomerShippingAddressRequest.name().localName(), getCustomerShippingAddressRequest) + +getCustomerShippingAddressResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getCustomerShippingAddressResponse'), CTD_ANON_43, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2374, 2)) +Namespace.addCategoryObject('elementBinding', getCustomerShippingAddressResponse.name().localName(), getCustomerShippingAddressResponse) + +updateCustomerProfileRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'updateCustomerProfileRequest'), CTD_ANON_44, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2393, 2)) +Namespace.addCategoryObject('elementBinding', updateCustomerProfileRequest.name().localName(), updateCustomerProfileRequest) + +updateCustomerProfileResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'updateCustomerProfileResponse'), CTD_ANON_45, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2410, 2)) +Namespace.addCategoryObject('elementBinding', updateCustomerProfileResponse.name().localName(), updateCustomerProfileResponse) + +updateCustomerPaymentProfileRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'updateCustomerPaymentProfileRequest'), CTD_ANON_46, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2425, 2)) +Namespace.addCategoryObject('elementBinding', updateCustomerPaymentProfileRequest.name().localName(), updateCustomerPaymentProfileRequest) + +updateCustomerPaymentProfileResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'updateCustomerPaymentProfileResponse'), CTD_ANON_47, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2444, 2)) +Namespace.addCategoryObject('elementBinding', updateCustomerPaymentProfileResponse.name().localName(), updateCustomerPaymentProfileResponse) + +updateCustomerShippingAddressRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'updateCustomerShippingAddressRequest'), CTD_ANON_48, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2469, 2)) +Namespace.addCategoryObject('elementBinding', updateCustomerShippingAddressRequest.name().localName(), updateCustomerShippingAddressRequest) + +updateCustomerShippingAddressResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'updateCustomerShippingAddressResponse'), CTD_ANON_49, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2487, 2)) +Namespace.addCategoryObject('elementBinding', updateCustomerShippingAddressResponse.name().localName(), updateCustomerShippingAddressResponse) + +deleteCustomerProfileRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'deleteCustomerProfileRequest'), CTD_ANON_50, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2503, 2)) +Namespace.addCategoryObject('elementBinding', deleteCustomerProfileRequest.name().localName(), deleteCustomerProfileRequest) + +deleteCustomerProfileResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'deleteCustomerProfileResponse'), CTD_ANON_51, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2520, 2)) +Namespace.addCategoryObject('elementBinding', deleteCustomerProfileResponse.name().localName(), deleteCustomerProfileResponse) + +deleteCustomerPaymentProfileRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'deleteCustomerPaymentProfileRequest'), CTD_ANON_52, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2535, 2)) +Namespace.addCategoryObject('elementBinding', deleteCustomerPaymentProfileRequest.name().localName(), deleteCustomerPaymentProfileRequest) + +deleteCustomerPaymentProfileResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'deleteCustomerPaymentProfileResponse'), CTD_ANON_53, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2553, 2)) +Namespace.addCategoryObject('elementBinding', deleteCustomerPaymentProfileResponse.name().localName(), deleteCustomerPaymentProfileResponse) + +deleteCustomerShippingAddressRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'deleteCustomerShippingAddressRequest'), CTD_ANON_54, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2568, 2)) +Namespace.addCategoryObject('elementBinding', deleteCustomerShippingAddressRequest.name().localName(), deleteCustomerShippingAddressRequest) + +deleteCustomerShippingAddressResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'deleteCustomerShippingAddressResponse'), CTD_ANON_55, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2586, 2)) +Namespace.addCategoryObject('elementBinding', deleteCustomerShippingAddressResponse.name().localName(), deleteCustomerShippingAddressResponse) + +createCustomerProfileTransactionRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createCustomerProfileTransactionRequest'), CTD_ANON_56, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2601, 2)) +Namespace.addCategoryObject('elementBinding', createCustomerProfileTransactionRequest.name().localName(), createCustomerProfileTransactionRequest) + +createCustomerProfileTransactionResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createCustomerProfileTransactionResponse'), CTD_ANON_57, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2625, 2)) +Namespace.addCategoryObject('elementBinding', createCustomerProfileTransactionResponse.name().localName(), createCustomerProfileTransactionResponse) + +validateCustomerPaymentProfileRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'validateCustomerPaymentProfileRequest'), CTD_ANON_58, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2650, 2)) +Namespace.addCategoryObject('elementBinding', validateCustomerPaymentProfileRequest.name().localName(), validateCustomerPaymentProfileRequest) + +validateCustomerPaymentProfileResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'validateCustomerPaymentProfileResponse'), CTD_ANON_59, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2671, 2)) +Namespace.addCategoryObject('elementBinding', validateCustomerPaymentProfileResponse.name().localName(), validateCustomerPaymentProfileResponse) + +getCustomerProfileIdsRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getCustomerProfileIdsRequest'), CTD_ANON_60, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2695, 2)) +Namespace.addCategoryObject('elementBinding', getCustomerProfileIdsRequest.name().localName(), getCustomerProfileIdsRequest) + +getCustomerProfileIdsResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getCustomerProfileIdsResponse'), CTD_ANON_61, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2709, 2)) +Namespace.addCategoryObject('elementBinding', getCustomerProfileIdsResponse.name().localName(), getCustomerProfileIdsResponse) + +updateSplitTenderGroupRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'updateSplitTenderGroupRequest'), CTD_ANON_62, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2726, 2)) +Namespace.addCategoryObject('elementBinding', updateSplitTenderGroupRequest.name().localName(), updateSplitTenderGroupRequest) + +updateSplitTenderGroupResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'updateSplitTenderGroupResponse'), CTD_ANON_63, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2744, 2)) +Namespace.addCategoryObject('elementBinding', updateSplitTenderGroupResponse.name().localName(), updateSplitTenderGroupResponse) + +getTransactionDetailsRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getTransactionDetailsRequest'), CTD_ANON_64, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2758, 2)) +Namespace.addCategoryObject('elementBinding', getTransactionDetailsRequest.name().localName(), getTransactionDetailsRequest) + +getTransactionDetailsResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getTransactionDetailsResponse'), CTD_ANON_65, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2775, 1)) +Namespace.addCategoryObject('elementBinding', getTransactionDetailsResponse.name().localName(), getTransactionDetailsResponse) + +createTransactionRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createTransactionRequest'), CTD_ANON_66, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2793, 1)) +Namespace.addCategoryObject('elementBinding', createTransactionRequest.name().localName(), createTransactionRequest) + +createTransactionResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createTransactionResponse'), CTD_ANON_67, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2811, 1)) +Namespace.addCategoryObject('elementBinding', createTransactionResponse.name().localName(), createTransactionResponse) + +getBatchStatisticsRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getBatchStatisticsRequest'), CTD_ANON_68, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2829, 1)) +Namespace.addCategoryObject('elementBinding', getBatchStatisticsRequest.name().localName(), getBatchStatisticsRequest) + +getBatchStatisticsResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getBatchStatisticsResponse'), CTD_ANON_69, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2846, 1)) +Namespace.addCategoryObject('elementBinding', getBatchStatisticsResponse.name().localName(), getBatchStatisticsResponse) + +getSettledBatchListRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getSettledBatchListRequest'), CTD_ANON_70, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2863, 1)) +Namespace.addCategoryObject('elementBinding', getSettledBatchListRequest.name().localName(), getSettledBatchListRequest) + +getSettledBatchListResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getSettledBatchListResponse'), CTD_ANON_71, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2882, 1)) +Namespace.addCategoryObject('elementBinding', getSettledBatchListResponse.name().localName(), getSettledBatchListResponse) + +getTransactionListRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getTransactionListRequest'), CTD_ANON_72, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2899, 1)) +Namespace.addCategoryObject('elementBinding', getTransactionListRequest.name().localName(), getTransactionListRequest) + +getTransactionListResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getTransactionListResponse'), CTD_ANON_73, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2916, 1)) +Namespace.addCategoryObject('elementBinding', getTransactionListResponse.name().localName(), getTransactionListResponse) + +getHostedProfilePageRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getHostedProfilePageRequest'), CTD_ANON_74, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2934, 1)) +Namespace.addCategoryObject('elementBinding', getHostedProfilePageRequest.name().localName(), getHostedProfilePageRequest) + +getHostedProfilePageResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getHostedProfilePageResponse'), CTD_ANON_75, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2956, 1)) +Namespace.addCategoryObject('elementBinding', getHostedProfilePageResponse.name().localName(), getHostedProfilePageResponse) + +getUnsettledTransactionListRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getUnsettledTransactionListRequest'), CTD_ANON_76, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2973, 1)) +Namespace.addCategoryObject('elementBinding', getUnsettledTransactionListRequest.name().localName(), getUnsettledTransactionListRequest) + +getUnsettledTransactionListResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'getUnsettledTransactionListResponse'), CTD_ANON_77, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2987, 1)) +Namespace.addCategoryObject('elementBinding', getUnsettledTransactionListResponse.name().localName(), getUnsettledTransactionListResponse) + +mobileDeviceRegistrationRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceRegistrationRequest'), CTD_ANON_78, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3005, 1)) +Namespace.addCategoryObject('elementBinding', mobileDeviceRegistrationRequest.name().localName(), mobileDeviceRegistrationRequest) + +mobileDeviceRegistrationResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceRegistrationResponse'), CTD_ANON_79, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3022, 1)) +Namespace.addCategoryObject('elementBinding', mobileDeviceRegistrationResponse.name().localName(), mobileDeviceRegistrationResponse) + +mobileDeviceLoginRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceLoginRequest'), CTD_ANON_80, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3035, 1)) +Namespace.addCategoryObject('elementBinding', mobileDeviceLoginRequest.name().localName(), mobileDeviceLoginRequest) + +mobileDeviceLoginResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceLoginResponse'), CTD_ANON_81, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3048, 1)) +Namespace.addCategoryObject('elementBinding', mobileDeviceLoginResponse.name().localName(), mobileDeviceLoginResponse) + +logoutRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'logoutRequest'), CTD_ANON_82, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3067, 1)) +Namespace.addCategoryObject('elementBinding', logoutRequest.name().localName(), logoutRequest) + +logoutResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'logoutResponse'), CTD_ANON_83, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3080, 1)) +Namespace.addCategoryObject('elementBinding', logoutResponse.name().localName(), logoutResponse) + +sendCustomerTransactionReceiptRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'sendCustomerTransactionReceiptRequest'), CTD_ANON_84, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3093, 1)) +Namespace.addCategoryObject('elementBinding', sendCustomerTransactionReceiptRequest.name().localName(), sendCustomerTransactionReceiptRequest) + +sendCustomerTransactionReceiptResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'sendCustomerTransactionReceiptResponse'), CTD_ANON_85, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3112, 1)) +Namespace.addCategoryObject('elementBinding', sendCustomerTransactionReceiptResponse.name().localName(), sendCustomerTransactionReceiptResponse) + +ARBGetSubscriptionListRequest = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ARBGetSubscriptionListRequest'), CTD_ANON_86, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3170, 1)) +Namespace.addCategoryObject('elementBinding', ARBGetSubscriptionListRequest.name().localName(), ARBGetSubscriptionListRequest) + +ARBGetSubscriptionListResponse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ARBGetSubscriptionListResponse'), CTD_ANON_87, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3230, 1)) +Namespace.addCategoryObject('elementBinding', ARBGetSubscriptionListResponse.name().localName(), ARBGetSubscriptionListResponse) + + + +ArrayOfLong._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'long'), pyxb.binding.datatypes.long, scope=ArrayOfLong, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 17, 3))) + +def _BuildAutomaton (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton + del _BuildAutomaton + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 17, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfLong._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'long')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 17, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfLong._Automaton = _BuildAutomaton() + + + + +ArrayOfNumericString._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'numericString'), numericString, scope=ArrayOfNumericString, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 23, 3))) + +def _BuildAutomaton_ (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_ + del _BuildAutomaton_ + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 23, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfNumericString._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'numericString')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 23, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfNumericString._Automaton = _BuildAutomaton_() + + + + +ArrayOfString._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'string'), pyxb.binding.datatypes.string, scope=ArrayOfString, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 29, 3))) + +def _BuildAutomaton_2 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_2 + del _BuildAutomaton_2 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 29, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfString._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'string')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 29, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfString._Automaton = _BuildAutomaton_2() + + + + +ArrayOfLineItem._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'lineItem'), lineItemType, scope=ArrayOfLineItem, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 35, 3))) + +def _BuildAutomaton_3 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_3 + del _BuildAutomaton_3 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 35, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfLineItem._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lineItem')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 35, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfLineItem._Automaton = _BuildAutomaton_3() + + + + +ArrayOfBatchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'statistic'), batchStatisticType, scope=ArrayOfBatchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 41, 3))) + +def _BuildAutomaton_4 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_4 + del _BuildAutomaton_4 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 41, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfBatchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'statistic')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 41, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfBatchStatisticType._Automaton = _BuildAutomaton_4() + + + + +ArrayOfBatchDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'batch'), batchDetailsType, scope=ArrayOfBatchDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 47, 3))) + +def _BuildAutomaton_5 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_5 + del _BuildAutomaton_5 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 47, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfBatchDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'batch')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 47, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfBatchDetailsType._Automaton = _BuildAutomaton_5() + + + + +ArrayOfTransactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transaction'), transactionSummaryType, scope=ArrayOfTransactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 53, 3))) + +def _BuildAutomaton_6 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_6 + del _BuildAutomaton_6 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 53, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfTransactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transaction')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 53, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfTransactionSummaryType._Automaton = _BuildAutomaton_6() + + + + +ArrayOfSetting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'setting'), settingType, scope=ArrayOfSetting, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 59, 3))) + +def _BuildAutomaton_7 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_7 + del _BuildAutomaton_7 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 59, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfSetting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'setting')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 59, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfSetting._Automaton = _BuildAutomaton_7() + + + + +ArrayOfFDSFilter._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FDSFilter'), FDSFilterType, scope=ArrayOfFDSFilter, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 65, 3))) + +def _BuildAutomaton_8 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_8 + del _BuildAutomaton_8 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 65, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfFDSFilter._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FDSFilter')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 65, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfFDSFilter._Automaton = _BuildAutomaton_8() + + + + +ArrayOfPermissionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'permission'), permissionType, scope=ArrayOfPermissionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 71, 3))) + +def _BuildAutomaton_9 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_9 + del _BuildAutomaton_9 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 71, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfPermissionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'permission')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 71, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfPermissionType._Automaton = _BuildAutomaton_9() + + + + +driversLicenseType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'number'), STD_ANON, scope=driversLicenseType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 247, 3))) + +driversLicenseType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'state'), STD_ANON_, scope=driversLicenseType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 255, 3))) + +driversLicenseType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'dateOfBirth'), STD_ANON_2, scope=driversLicenseType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 264, 3))) + +def _BuildAutomaton_10 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_10 + del _BuildAutomaton_10 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(driversLicenseType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'number')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 247, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(driversLicenseType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'state')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 255, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(driversLicenseType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'dateOfBirth')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 264, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +driversLicenseType._Automaton = _BuildAutomaton_10() + + + + +driversLicenseMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'number'), STD_ANON_3, scope=driversLicenseMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 277, 3))) + +driversLicenseMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'state'), STD_ANON_4, scope=driversLicenseMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 284, 3))) + +driversLicenseMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'dateOfBirth'), STD_ANON_5, scope=driversLicenseMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 292, 3))) + +def _BuildAutomaton_11 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_11 + del _BuildAutomaton_11 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(driversLicenseMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'number')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 277, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(driversLicenseMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'state')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 284, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(driversLicenseMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'dateOfBirth')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 292, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +driversLicenseMaskedType._Automaton = _BuildAutomaton_11() + + + + +nameAndAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'firstName'), STD_ANON_6, scope=nameAndAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 305, 3))) + +nameAndAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'lastName'), STD_ANON_7, scope=nameAndAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 312, 3))) + +nameAndAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'company'), STD_ANON_8, scope=nameAndAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 319, 3))) + +nameAndAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'address'), STD_ANON_9, scope=nameAndAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 326, 3))) + +nameAndAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'city'), STD_ANON_10, scope=nameAndAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 333, 3))) + +nameAndAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'state'), STD_ANON_11, scope=nameAndAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 340, 3))) + +nameAndAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'zip'), STD_ANON_12, scope=nameAndAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 347, 3))) + +nameAndAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'country'), STD_ANON_13, scope=nameAndAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 354, 3))) + +def _BuildAutomaton_12 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_12 + del _BuildAutomaton_12 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 305, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 312, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 319, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 326, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 333, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 340, 3)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 347, 3)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 354, 3)) + counters.add(cc_7) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(nameAndAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'firstName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 305, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(nameAndAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lastName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 312, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(nameAndAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'company')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 319, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(nameAndAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'address')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 326, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(nameAndAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'city')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 333, 3)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(nameAndAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'state')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 340, 3)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(nameAndAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'zip')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 347, 3)) + st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(nameAndAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'country')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 354, 3)) + st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_6, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_7, True) ])) + st_7._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +nameAndAddressType._Automaton = _BuildAutomaton_12() + + + + +merchantContactType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantName'), pyxb.binding.datatypes.string, scope=merchantContactType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 366, 3))) + +merchantContactType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantAddress'), pyxb.binding.datatypes.string, scope=merchantContactType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 367, 3))) + +merchantContactType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantCity'), pyxb.binding.datatypes.string, scope=merchantContactType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 368, 3))) + +merchantContactType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantState'), pyxb.binding.datatypes.string, scope=merchantContactType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 369, 3))) + +merchantContactType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantZip'), pyxb.binding.datatypes.string, scope=merchantContactType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 370, 3))) + +merchantContactType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantPhone'), pyxb.binding.datatypes.string, scope=merchantContactType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 371, 3))) + +def _BuildAutomaton_13 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_13 + del _BuildAutomaton_13 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 366, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 367, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 368, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 369, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 370, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 371, 3)) + counters.add(cc_5) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(merchantContactType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 366, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(merchantContactType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAddress')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 367, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(merchantContactType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantCity')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 368, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(merchantContactType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantState')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 369, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(merchantContactType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantZip')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 370, 3)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(merchantContactType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantPhone')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 371, 3)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +merchantContactType._Automaton = _BuildAutomaton_13() + + + + +transRetailInfoType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'marketType'), pyxb.binding.datatypes.string, scope=transRetailInfoType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 377, 3), unicode_default='2')) + +transRetailInfoType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'deviceType'), pyxb.binding.datatypes.string, scope=transRetailInfoType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 378, 3))) + +def _BuildAutomaton_14 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_14 + del _BuildAutomaton_14 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 377, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 378, 3)) + counters.add(cc_1) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(transRetailInfoType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'marketType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 377, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(transRetailInfoType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'deviceType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 378, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +transRetailInfoType._Automaton = _BuildAutomaton_14() + + + + +creditCardSimpleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardNumber'), STD_ANON_14, scope=creditCardSimpleType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 385, 3))) + +creditCardSimpleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'expirationDate'), STD_ANON_15, scope=creditCardSimpleType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 394, 3))) + +def _BuildAutomaton_15 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_15 + del _BuildAutomaton_15 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(creditCardSimpleType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 385, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(creditCardSimpleType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'expirationDate')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 394, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +creditCardSimpleType._Automaton = _BuildAutomaton_15() + + + + +creditCardTrackType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'track1'), pyxb.binding.datatypes.string, scope=creditCardTrackType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 407, 3))) + +creditCardTrackType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'track2'), pyxb.binding.datatypes.string, scope=creditCardTrackType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 408, 3))) + +def _BuildAutomaton_16 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_16 + del _BuildAutomaton_16 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(creditCardTrackType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'track1')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 407, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(creditCardTrackType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'track2')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 408, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +creditCardTrackType._Automaton = _BuildAutomaton_16() + + + + +creditCardMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardNumber'), STD_ANON_16, scope=creditCardMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 437, 3))) + +creditCardMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'expirationDate'), STD_ANON_17, scope=creditCardMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 444, 3))) + +creditCardMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardType'), pyxb.binding.datatypes.string, scope=creditCardMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 452, 3))) + +creditCardMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardArt'), cardArt, scope=creditCardMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 453, 3))) + +def _BuildAutomaton_17 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_17 + del _BuildAutomaton_17 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 452, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 453, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(creditCardMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 437, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(creditCardMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'expirationDate')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 444, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(creditCardMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 452, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(creditCardMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardArt')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 453, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +creditCardMaskedType._Automaton = _BuildAutomaton_17() + + + + +ccAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'authenticationIndicator'), pyxb.binding.datatypes.string, scope=ccAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 459, 3))) + +ccAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardholderAuthenticationValue'), pyxb.binding.datatypes.string, scope=ccAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 460, 3))) + +def _BuildAutomaton_18 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_18 + del _BuildAutomaton_18 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(ccAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'authenticationIndicator')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 459, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(ccAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardholderAuthenticationValue')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 460, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +ccAuthenticationType._Automaton = _BuildAutomaton_18() + + + + +bankAccountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountType'), bankAccountTypeEnum, scope=bankAccountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 466, 3))) + +bankAccountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'routingNumber'), STD_ANON_18, scope=bankAccountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 468, 3))) + +bankAccountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), STD_ANON_19, scope=bankAccountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 476, 3))) + +bankAccountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'nameOnAccount'), STD_ANON_20, scope=bankAccountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 483, 3))) + +bankAccountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'echeckType'), echeckTypeEnum, scope=bankAccountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 490, 3))) + +bankAccountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'bankName'), STD_ANON_21, scope=bankAccountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 491, 3))) + +bankAccountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'checkNumber'), STD_ANON_22, scope=bankAccountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 498, 3))) + +def _BuildAutomaton_19 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_19 + del _BuildAutomaton_19 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 466, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 490, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 491, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 498, 3)) + counters.add(cc_3) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(bankAccountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 466, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(bankAccountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'routingNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 468, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(bankAccountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 476, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(bankAccountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'nameOnAccount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 483, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(bankAccountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'echeckType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 490, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(bankAccountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'bankName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 491, 3)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(bankAccountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'checkNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 498, 3)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, True) ])) + st_6._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +bankAccountType._Automaton = _BuildAutomaton_19() + + + + +bankAccountMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountType'), bankAccountTypeEnum, scope=bankAccountMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 510, 3))) + +bankAccountMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'routingNumber'), STD_ANON_23, scope=bankAccountMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 511, 3))) + +bankAccountMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), STD_ANON_24, scope=bankAccountMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 518, 3))) + +bankAccountMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'nameOnAccount'), STD_ANON_25, scope=bankAccountMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 525, 3))) + +bankAccountMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'echeckType'), echeckTypeEnum, scope=bankAccountMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 532, 3))) + +bankAccountMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'bankName'), STD_ANON_26, scope=bankAccountMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 533, 3))) + +def _BuildAutomaton_20 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_20 + del _BuildAutomaton_20 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 510, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 532, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 533, 3)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(bankAccountMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 510, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(bankAccountMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'routingNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 511, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(bankAccountMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 518, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(bankAccountMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'nameOnAccount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 525, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(bankAccountMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'echeckType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 532, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(bankAccountMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'bankName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 533, 3)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, True) ])) + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +bankAccountMaskedType._Automaton = _BuildAutomaton_20() + + + + +opaqueDataType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'dataDescriptor'), pyxb.binding.datatypes.string, scope=opaqueDataType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 545, 6))) + +opaqueDataType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'dataValue'), pyxb.binding.datatypes.string, scope=opaqueDataType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 546, 6))) + +opaqueDataType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'dataKey'), pyxb.binding.datatypes.string, scope=opaqueDataType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 547, 6))) + +def _BuildAutomaton_21 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_21 + del _BuildAutomaton_21 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 547, 6)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(opaqueDataType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'dataDescriptor')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 545, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(opaqueDataType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'dataValue')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 546, 6)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(opaqueDataType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'dataKey')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 547, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +opaqueDataType._Automaton = _BuildAutomaton_21() + + + + +paymentSimpleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'creditCard'), creditCardSimpleType, scope=paymentSimpleType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 554, 4))) + +paymentSimpleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'bankAccount'), bankAccountType, scope=paymentSimpleType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 555, 4))) + +def _BuildAutomaton_22 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_22 + del _BuildAutomaton_22 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentSimpleType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'creditCard')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 554, 4)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentSimpleType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'bankAccount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 555, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +paymentSimpleType._Automaton = _BuildAutomaton_22() + + + + +paymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'creditCard'), creditCardType, scope=paymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 563, 4))) + +paymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'bankAccount'), bankAccountType, scope=paymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 564, 4))) + +paymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'trackData'), creditCardTrackType, scope=paymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 565, 4))) + +paymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'encryptedTrackData'), encryptedTrackDataType, scope=paymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 566, 4))) + +paymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'payPal'), payPalType, scope=paymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 567, 4))) + +paymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'opaqueData'), opaqueDataType, scope=paymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 568, 8))) + +def _BuildAutomaton_23 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_23 + del _BuildAutomaton_23 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'creditCard')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 563, 4)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'bankAccount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 564, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'trackData')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 565, 4)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'encryptedTrackData')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 566, 4)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'payPal')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 567, 4)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'opaqueData')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 568, 8)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + transitions = [] + st_4._set_transitionSet(transitions) + transitions = [] + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +paymentType._Automaton = _BuildAutomaton_23() + + + + +paymentMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'creditCard'), creditCardMaskedType, scope=paymentMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 576, 4))) + +paymentMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'bankAccount'), bankAccountMaskedType, scope=paymentMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 577, 4))) + +paymentMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'tokenInformation'), tokenMaskedType, scope=paymentMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 578, 8))) + +def _BuildAutomaton_24 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_24 + del _BuildAutomaton_24 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'creditCard')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 576, 4)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'bankAccount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 577, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tokenInformation')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 578, 8)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +paymentMaskedType._Automaton = _BuildAutomaton_24() + + + + +tokenMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'tokenSource'), pyxb.binding.datatypes.string, scope=tokenMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 585, 6))) + +tokenMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'tokenNumber'), pyxb.binding.datatypes.string, scope=tokenMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 586, 6))) + +tokenMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'expirationDate'), STD_ANON_27, scope=tokenMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 587, 6))) + +def _BuildAutomaton_25 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_25 + del _BuildAutomaton_25 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 585, 6)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(tokenMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tokenSource')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 585, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(tokenMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tokenNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 586, 6)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(tokenMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'expirationDate')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 587, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +tokenMaskedType._Automaton = _BuildAutomaton_25() + + + + +orderType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'invoiceNumber'), STD_ANON_28, scope=orderType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 600, 3))) + +orderType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'description'), STD_ANON_29, scope=orderType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 607, 3))) + +def _BuildAutomaton_26 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_26 + del _BuildAutomaton_26 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 600, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 607, 3)) + counters.add(cc_1) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(orderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'invoiceNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 600, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(orderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 607, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +orderType._Automaton = _BuildAutomaton_26() + + + + +customerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'type'), customerTypeEnum, scope=customerType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 635, 3))) + +customerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'id'), STD_ANON_31, scope=customerType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 636, 3))) + +customerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'email'), STD_ANON_32, scope=customerType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 643, 3))) + +customerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'phoneNumber'), STD_ANON_33, scope=customerType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 650, 3))) + +customerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'faxNumber'), STD_ANON_34, scope=customerType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 657, 3))) + +customerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'driversLicense'), driversLicenseType, scope=customerType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 664, 3))) + +customerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'taxId'), STD_ANON_102, scope=customerType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 665, 3))) + +def _BuildAutomaton_27 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_27 + del _BuildAutomaton_27 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 635, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 636, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 643, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 650, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 657, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 664, 3)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 665, 3)) + counters.add(cc_6) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'type')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 635, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'id')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 636, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'email')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 643, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'phoneNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 650, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(customerType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'faxNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 657, 3)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(customerType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'driversLicense')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 664, 3)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(customerType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 665, 3)) + st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_6, True) ])) + st_6._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerType._Automaton = _BuildAutomaton_27() + + + + +customerDataType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'type'), customerTypeEnum, scope=customerDataType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 678, 3))) + +customerDataType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'id'), STD_ANON_35, scope=customerDataType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 679, 3))) + +customerDataType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'email'), STD_ANON_36, scope=customerDataType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 686, 3))) + +customerDataType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'driversLicense'), driversLicenseType, scope=customerDataType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 693, 3))) + +customerDataType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'taxId'), STD_ANON_37, scope=customerDataType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 694, 3))) + +def _BuildAutomaton_28 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_28 + del _BuildAutomaton_28 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 678, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 679, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 686, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 693, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 694, 3)) + counters.add(cc_4) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerDataType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'type')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 678, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerDataType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'id')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 679, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerDataType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'email')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 686, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerDataType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'driversLicense')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 693, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(customerDataType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 694, 3)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerDataType._Automaton = _BuildAutomaton_28() + + + + +merchantAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'name'), STD_ANON_38, scope=merchantAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 707, 3))) + +merchantAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionKey'), STD_ANON_39, scope=merchantAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 716, 4))) + +merchantAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'sessionToken'), pyxb.binding.datatypes.string, scope=merchantAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 723, 16))) + +merchantAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'password'), STD_ANON_40, scope=merchantAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 724, 4))) + +merchantAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'impersonationAuthentication'), impersonationAuthenticationType, scope=merchantAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 731, 8))) + +merchantAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'fingerPrint'), fingerPrintType, scope=merchantAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 732, 8))) + +merchantAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId'), STD_ANON_41, scope=merchantAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 734, 3))) + +def _BuildAutomaton_29 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_29 + del _BuildAutomaton_29 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 707, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 723, 16)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 731, 8)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 732, 8)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 734, 3)) + counters.add(cc_4) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(merchantAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'name')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 707, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(merchantAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionKey')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 716, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(merchantAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 723, 16)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(merchantAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'password')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 724, 4)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(merchantAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'impersonationAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 731, 8)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(merchantAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'fingerPrint')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 732, 8)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(merchantAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 734, 3)) + st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, True) ])) + st_6._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +merchantAuthenticationType._Automaton = _BuildAutomaton_29() + + + + +fingerPrintType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'hashValue'), pyxb.binding.datatypes.string, scope=fingerPrintType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 746, 6))) + +fingerPrintType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'sequence'), pyxb.binding.datatypes.string, scope=fingerPrintType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 747, 6))) + +fingerPrintType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'timestamp'), pyxb.binding.datatypes.string, scope=fingerPrintType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 748, 6))) + +fingerPrintType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'currencyCode'), pyxb.binding.datatypes.string, scope=fingerPrintType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 749, 6))) + +fingerPrintType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'amount'), pyxb.binding.datatypes.string, scope=fingerPrintType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 750, 6))) + +def _BuildAutomaton_30 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_30 + del _BuildAutomaton_30 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 747, 6)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 749, 6)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 750, 6)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(fingerPrintType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'hashValue')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 746, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(fingerPrintType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sequence')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 747, 6)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(fingerPrintType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'timestamp')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 748, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(fingerPrintType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'currencyCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 749, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(fingerPrintType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 750, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +fingerPrintType._Automaton = _BuildAutomaton_30() + + + + +cardArt._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardBrand'), pyxb.binding.datatypes.string, scope=cardArt, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 757, 6))) + +cardArt._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardImageHeight'), pyxb.binding.datatypes.string, scope=cardArt, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 758, 6))) + +cardArt._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardImageUrl'), pyxb.binding.datatypes.string, scope=cardArt, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 759, 6))) + +cardArt._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardImageWidth'), pyxb.binding.datatypes.string, scope=cardArt, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 760, 6))) + +cardArt._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardType'), pyxb.binding.datatypes.string, scope=cardArt, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 761, 6))) + +def _BuildAutomaton_31 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_31 + del _BuildAutomaton_31 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 757, 6)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 758, 6)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 759, 6)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 760, 6)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 761, 6)) + counters.add(cc_4) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(cardArt._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardBrand')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 757, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(cardArt._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardImageHeight')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 758, 6)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(cardArt._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardImageUrl')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 759, 6)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(cardArt._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardImageWidth')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 760, 6)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(cardArt._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 761, 6)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +cardArt._Automaton = _BuildAutomaton_31() + + + + +paymentDetails._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'currency'), pyxb.binding.datatypes.string, scope=paymentDetails, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 767, 6))) + +paymentDetails._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'promoCode'), pyxb.binding.datatypes.string, scope=paymentDetails, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 768, 6))) + +paymentDetails._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'misc'), pyxb.binding.datatypes.string, scope=paymentDetails, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 769, 6))) + +paymentDetails._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'giftWrap'), pyxb.binding.datatypes.string, scope=paymentDetails, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 770, 6))) + +paymentDetails._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'discount'), pyxb.binding.datatypes.string, scope=paymentDetails, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 771, 6))) + +paymentDetails._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'tax'), pyxb.binding.datatypes.string, scope=paymentDetails, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 772, 6))) + +paymentDetails._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shippingHandling'), pyxb.binding.datatypes.string, scope=paymentDetails, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 773, 6))) + +paymentDetails._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subTotal'), pyxb.binding.datatypes.string, scope=paymentDetails, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 774, 6))) + +paymentDetails._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'orderID'), pyxb.binding.datatypes.string, scope=paymentDetails, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 775, 6))) + +paymentDetails._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'amount'), pyxb.binding.datatypes.string, scope=paymentDetails, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 776, 6))) + +def _BuildAutomaton_32 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_32 + del _BuildAutomaton_32 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 767, 6)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 768, 6)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 769, 6)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 770, 6)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 771, 6)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 772, 6)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 773, 6)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 774, 6)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 775, 6)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 776, 6)) + counters.add(cc_9) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(paymentDetails._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'currency')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 767, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(paymentDetails._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'promoCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 768, 6)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(paymentDetails._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'misc')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 769, 6)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(paymentDetails._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'giftWrap')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 770, 6)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(paymentDetails._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'discount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 771, 6)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(paymentDetails._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tax')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 772, 6)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(paymentDetails._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shippingHandling')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 773, 6)) + st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(paymentDetails._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subTotal')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 774, 6)) + st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(paymentDetails._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'orderID')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 775, 6)) + st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_9, False)) + symbol = pyxb.binding.content.ElementUse(paymentDetails._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 776, 6)) + st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_7, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_8, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_9, True) ])) + st_9._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +paymentDetails._Automaton = _BuildAutomaton_32() + + + + +impersonationAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'partnerLoginId'), STD_ANON_42, scope=impersonationAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 813, 6))) + +impersonationAuthenticationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'partnerTransactionKey'), STD_ANON_43, scope=impersonationAuthenticationType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 820, 6))) + +def _BuildAutomaton_33 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_33 + del _BuildAutomaton_33 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(impersonationAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'partnerLoginId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 813, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(impersonationAuthenticationType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'partnerTransactionKey')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 820, 6)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +impersonationAuthenticationType._Automaton = _BuildAutomaton_33() + + + + +paymentScheduleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'interval'), CTD_ANON, scope=paymentScheduleType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 833, 3))) + +paymentScheduleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'startDate'), pyxb.binding.datatypes.date, scope=paymentScheduleType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 849, 3))) + +paymentScheduleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'totalOccurrences'), STD_ANON_45, scope=paymentScheduleType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 851, 3))) + +paymentScheduleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'trialOccurrences'), STD_ANON_46, scope=paymentScheduleType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 860, 3))) + +def _BuildAutomaton_34 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_34 + del _BuildAutomaton_34 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 833, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 849, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 851, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 860, 3)) + counters.add(cc_3) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(paymentScheduleType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'interval')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 833, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(paymentScheduleType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'startDate')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 849, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(paymentScheduleType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'totalOccurrences')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 851, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(paymentScheduleType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'trialOccurrences')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 860, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +paymentScheduleType._Automaton = _BuildAutomaton_34() + + + + +CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'length'), STD_ANON_44, scope=CTD_ANON, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 836, 6))) + +CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'unit'), ARBSubscriptionUnitEnum, scope=CTD_ANON, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 844, 6))) + +def _BuildAutomaton_35 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_35 + del _BuildAutomaton_35 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'length')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 836, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'unit')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 844, 6)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON._Automaton = _BuildAutomaton_35() + + + + +ARBSubscriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'name'), STD_ANON_47, scope=ARBSubscriptionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 873, 3))) + +ARBSubscriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentSchedule'), paymentScheduleType, scope=ARBSubscriptionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 881, 3))) + +ARBSubscriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'amount'), STD_ANON_48, scope=ARBSubscriptionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 882, 3))) + +ARBSubscriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'trialAmount'), STD_ANON_49, scope=ARBSubscriptionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 890, 3))) + +ARBSubscriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'payment'), paymentType, scope=ARBSubscriptionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 899, 3))) + +ARBSubscriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'order'), orderType, scope=ARBSubscriptionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 900, 3))) + +ARBSubscriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customer'), customerType, scope=ARBSubscriptionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 901, 3))) + +ARBSubscriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'billTo'), nameAndAddressType, scope=ARBSubscriptionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 902, 3))) + +ARBSubscriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shipTo'), nameAndAddressType, scope=ARBSubscriptionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 903, 3))) + +def _BuildAutomaton_36 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_36 + del _BuildAutomaton_36 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 873, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 881, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 882, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 890, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 899, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 900, 3)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 901, 3)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 902, 3)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 903, 3)) + counters.add(cc_8) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ARBSubscriptionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'name')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 873, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(ARBSubscriptionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentSchedule')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 881, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(ARBSubscriptionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 882, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(ARBSubscriptionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'trialAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 890, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(ARBSubscriptionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'payment')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 899, 3)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(ARBSubscriptionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'order')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 900, 3)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(ARBSubscriptionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customer')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 901, 3)) + st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(ARBSubscriptionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'billTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 902, 3)) + st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(ARBSubscriptionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 903, 3)) + st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_6, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_7, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_8, True) ])) + st_8._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ARBSubscriptionType._Automaton = _BuildAutomaton_36() + + + + +subscriptionPaymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'id'), STD_ANON_50, scope=subscriptionPaymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 909, 6))) + +subscriptionPaymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'payNum'), STD_ANON_51, scope=subscriptionPaymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 916, 6))) + +def _BuildAutomaton_37 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_37 + del _BuildAutomaton_37 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(subscriptionPaymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'id')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 909, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(subscriptionPaymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'payNum')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 916, 6)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +subscriptionPaymentType._Automaton = _BuildAutomaton_37() + + + + +mobileDeviceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId'), STD_ANON_52, scope=mobileDeviceType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 928, 3))) + +mobileDeviceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'description'), STD_ANON_53, scope=mobileDeviceType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 935, 3))) + +mobileDeviceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'phoneNumber'), STD_ANON_54, scope=mobileDeviceType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 942, 3))) + +mobileDeviceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'devicePlatform'), STD_ANON_55, scope=mobileDeviceType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 949, 6))) + +mobileDeviceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'deviceActivation'), deviceActivationEnum, scope=mobileDeviceType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 956, 6))) + +def _BuildAutomaton_38 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_38 + del _BuildAutomaton_38 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 935, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 942, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 949, 6)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 956, 6)) + counters.add(cc_3) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(mobileDeviceType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 928, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(mobileDeviceType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 935, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(mobileDeviceType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'phoneNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 942, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(mobileDeviceType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'devicePlatform')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 949, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(mobileDeviceType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'deviceActivation')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 956, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +mobileDeviceType._Automaton = _BuildAutomaton_38() + + + + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionType'), pyxb.binding.datatypes.string, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 967, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'amount'), pyxb.binding.datatypes.decimal, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 968, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'currencyCode'), pyxb.binding.datatypes.string, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 969, 6))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'payment'), paymentType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 970, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profile'), customerProfilePaymentType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 971, 6))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'solution'), solutionType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 972, 6))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'callId'), pyxb.binding.datatypes.string, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 973, 6))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'authCode'), pyxb.binding.datatypes.string, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 974, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refTransId'), pyxb.binding.datatypes.string, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 975, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId'), pyxb.binding.datatypes.string, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 976, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'order'), orderType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 977, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'lineItems'), ArrayOfLineItem, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 978, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'tax'), extendedAmountType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 979, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'duty'), extendedAmountType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 980, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shipping'), extendedAmountType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 981, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'taxExempt'), STD_ANON_56, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 982, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'poNumber'), pyxb.binding.datatypes.string, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 987, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customer'), customerDataType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 988, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'billTo'), customerAddressType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 989, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shipTo'), nameAndAddressType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 990, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerIP'), pyxb.binding.datatypes.string, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 991, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardholderAuthentication'), ccAuthenticationType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 992, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'retail'), transRetailInfoType, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 993, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'employeeId'), pyxb.binding.datatypes.string, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 994, 6))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionSettings'), ArrayOfSetting, scope=transactionRequestType, documentation='Allowed values for settingName are: emailCustomer, merchantEmail, allowPartialAuth, headerEmailReceipt, footerEmailReceipt, recurringBilling, duplicateWindow, testRequest.', location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 995, 3))) + +transactionRequestType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'userFields'), CTD_ANON_, scope=transactionRequestType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1000, 3))) + +def _BuildAutomaton_39 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_39 + del _BuildAutomaton_39 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 968, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 969, 6)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 970, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 971, 6)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 972, 6)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 973, 6)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 974, 3)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 975, 3)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 976, 3)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 977, 3)) + counters.add(cc_9) + cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 978, 3)) + counters.add(cc_10) + cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 979, 3)) + counters.add(cc_11) + cc_12 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 980, 3)) + counters.add(cc_12) + cc_13 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 981, 3)) + counters.add(cc_13) + cc_14 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 982, 3)) + counters.add(cc_14) + cc_15 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 987, 3)) + counters.add(cc_15) + cc_16 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 988, 3)) + counters.add(cc_16) + cc_17 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 989, 3)) + counters.add(cc_17) + cc_18 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 990, 3)) + counters.add(cc_18) + cc_19 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 991, 3)) + counters.add(cc_19) + cc_20 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 992, 3)) + counters.add(cc_20) + cc_21 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 993, 3)) + counters.add(cc_21) + cc_22 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 994, 6)) + counters.add(cc_22) + cc_23 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 995, 3)) + counters.add(cc_23) + cc_24 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1000, 3)) + counters.add(cc_24) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 967, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 968, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'currencyCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 969, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'payment')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 970, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profile')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 971, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'solution')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 972, 6)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'callId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 973, 6)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'authCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 974, 3)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refTransId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 975, 3)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 976, 3)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_9, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'order')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 977, 3)) + st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_10, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lineItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 978, 3)) + st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_11, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tax')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 979, 3)) + st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_12, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'duty')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 980, 3)) + st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_13) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_13, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipping')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 981, 3)) + st_14 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_14) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_14, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxExempt')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 982, 3)) + st_15 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_15) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_15, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'poNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 987, 3)) + st_16 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_16) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_16, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customer')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 988, 3)) + st_17 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_17) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_17, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'billTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 989, 3)) + st_18 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_18) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_18, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 990, 3)) + st_19 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_19) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_19, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerIP')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 991, 3)) + st_20 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_20) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_20, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardholderAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 992, 3)) + st_21 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_21) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_21, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'retail')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 993, 3)) + st_22 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_22) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_22, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'employeeId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 994, 6)) + st_23 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_23) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_23, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionSettings')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 995, 3)) + st_24 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_24) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_24, False)) + symbol = pyxb.binding.content.ElementUse(transactionRequestType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'userFields')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1000, 3)) + st_25 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_25) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + transitions.append(fac.Transition(st_9, [ + ])) + transitions.append(fac.Transition(st_10, [ + ])) + transitions.append(fac.Transition(st_11, [ + ])) + transitions.append(fac.Transition(st_12, [ + ])) + transitions.append(fac.Transition(st_13, [ + ])) + transitions.append(fac.Transition(st_14, [ + ])) + transitions.append(fac.Transition(st_15, [ + ])) + transitions.append(fac.Transition(st_16, [ + ])) + transitions.append(fac.Transition(st_17, [ + ])) + transitions.append(fac.Transition(st_18, [ + ])) + transitions.append(fac.Transition(st_19, [ + ])) + transitions.append(fac.Transition(st_20, [ + ])) + transitions.append(fac.Transition(st_21, [ + ])) + transitions.append(fac.Transition(st_22, [ + ])) + transitions.append(fac.Transition(st_23, [ + ])) + transitions.append(fac.Transition(st_24, [ + ])) + transitions.append(fac.Transition(st_25, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_3, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_4, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_5, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_6, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_7, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_8, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_9, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_9, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_10, True) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_10, False) ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_11, True) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_11, False) ])) + st_12._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_12, True) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_12, False) ])) + st_13._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_13, True) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_13, False) ])) + st_14._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_14, True) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_14, False) ])) + st_15._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_15, True) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_15, False) ])) + st_16._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_16, True) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_16, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_16, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_16, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_16, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_16, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_16, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_16, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_16, False) ])) + st_17._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_17, True) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_17, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_17, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_17, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_17, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_17, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_17, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_17, False) ])) + st_18._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_18, True) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_18, False) ])) + st_19._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_19, True) ])) + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_19, False) ])) + st_20._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_21, [ + fac.UpdateInstruction(cc_20, True) ])) + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_20, False) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_20, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_20, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_20, False) ])) + st_21._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_21, True) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_21, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_21, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_21, False) ])) + st_22._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_22, True) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_22, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_22, False) ])) + st_23._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_23, True) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_23, False) ])) + st_24._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_24, True) ])) + st_25._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +transactionRequestType._Automaton = _BuildAutomaton_39() + + + + +CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'userField'), userField, scope=CTD_ANON_, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1003, 6))) + +def _BuildAutomaton_40 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_40 + del _BuildAutomaton_40 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=20, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1003, 6)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'userField')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1003, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_._Automaton = _BuildAutomaton_40() + + + + +KeyManagementScheme._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DUKPT'), CTD_ANON_2, scope=KeyManagementScheme, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1012, 7))) + +def _BuildAutomaton_41 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_41 + del _BuildAutomaton_41 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(KeyManagementScheme._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DUKPT')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1012, 7)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +KeyManagementScheme._Automaton = _BuildAutomaton_41() + + + + +CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Operation'), OperationType, scope=CTD_ANON_2, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1015, 13))) + +CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Mode'), CTD_ANON_3, scope=CTD_ANON_2, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1016, 13))) + +CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DeviceInfo'), CTD_ANON_4, scope=CTD_ANON_2, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1024, 13))) + +CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'EncryptedData'), CTD_ANON_5, scope=CTD_ANON_2, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1031, 13))) + +def _BuildAutomaton_42 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_42 + del _BuildAutomaton_42 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Operation')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1015, 13)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Mode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1016, 13)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DeviceInfo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1024, 13)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'EncryptedData')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1031, 13)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_2._Automaton = _BuildAutomaton_42() + + + + +CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'PIN'), pyxb.binding.datatypes.string, scope=CTD_ANON_3, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1019, 19))) + +CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Data'), pyxb.binding.datatypes.string, scope=CTD_ANON_3, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1020, 19))) + +def _BuildAutomaton_43 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_43 + del _BuildAutomaton_43 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1019, 19)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1020, 19)) + counters.add(cc_1) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'PIN')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1019, 19)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Data')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1020, 19)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_3._Automaton = _BuildAutomaton_43() + + + + +CTD_ANON_4._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), pyxb.binding.datatypes.string, scope=CTD_ANON_4, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1027, 19))) + +def _BuildAutomaton_44 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_44 + del _BuildAutomaton_44 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_4._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1027, 19)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_4._Automaton = _BuildAutomaton_44() + + + + +CTD_ANON_5._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.string, scope=CTD_ANON_5, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1034, 19))) + +def _BuildAutomaton_45 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_45 + del _BuildAutomaton_45 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_5._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1034, 19)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_5._Automaton = _BuildAutomaton_45() + + + + +KeyValue._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Encoding'), EncodingType, scope=KeyValue, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1063, 7))) + +KeyValue._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'EncryptionAlgorithm'), EncryptionAlgorithmType, scope=KeyValue, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1064, 7))) + +KeyValue._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Scheme'), KeyManagementScheme, scope=KeyValue, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1065, 7))) + +def _BuildAutomaton_46 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_46 + del _BuildAutomaton_46 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(KeyValue._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Encoding')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1063, 7)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(KeyValue._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'EncryptionAlgorithm')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1064, 7)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(KeyValue._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Scheme')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1065, 7)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +KeyValue._Automaton = _BuildAutomaton_46() + + + + +KeyBlock._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), KeyValue, scope=KeyBlock, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1070, 12))) + +def _BuildAutomaton_47 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_47 + del _BuildAutomaton_47 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(KeyBlock._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1070, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +KeyBlock._Automaton = _BuildAutomaton_47() + + + + +encryptedTrackDataType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FormOfPayment'), KeyBlock, scope=encryptedTrackDataType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1075, 7))) + +def _BuildAutomaton_48 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_48 + del _BuildAutomaton_48 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(encryptedTrackDataType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FormOfPayment')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1075, 7)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +encryptedTrackDataType._Automaton = _BuildAutomaton_48() + + + + +settingType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'settingName'), pyxb.binding.datatypes.string, scope=settingType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1081, 3))) + +settingType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'settingValue'), pyxb.binding.datatypes.string, scope=settingType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1082, 3))) + +def _BuildAutomaton_49 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_49 + del _BuildAutomaton_49 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1081, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1082, 3)) + counters.add(cc_1) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(settingType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'settingName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1081, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(settingType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'settingValue')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1082, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +settingType._Automaton = _BuildAutomaton_49() + + + + +permissionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'permissionName'), pyxb.binding.datatypes.string, scope=permissionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1088, 3))) + +def _BuildAutomaton_50 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_50 + del _BuildAutomaton_50 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1088, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(permissionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'permissionName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1088, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +permissionType._Automaton = _BuildAutomaton_50() + + + + +userField._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'name'), pyxb.binding.datatypes.string, scope=userField, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1184, 3))) + +userField._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'value'), pyxb.binding.datatypes.string, scope=userField, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1185, 3))) + +def _BuildAutomaton_51 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_51 + del _BuildAutomaton_51 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1184, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1185, 3)) + counters.add(cc_1) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(userField._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'name')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1184, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(userField._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'value')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1185, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +userField._Automaton = _BuildAutomaton_51() + + + + +customerPaymentProfileBaseType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerType'), customerTypeEnum, scope=customerPaymentProfileBaseType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1191, 3))) + +customerPaymentProfileBaseType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'billTo'), customerAddressType, scope=customerPaymentProfileBaseType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1192, 3))) + +def _BuildAutomaton_52 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_52 + del _BuildAutomaton_52 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1191, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1192, 3)) + counters.add(cc_1) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileBaseType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1191, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileBaseType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'billTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1192, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerPaymentProfileBaseType._Automaton = _BuildAutomaton_52() + + + + +customerProfileBaseType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantCustomerId'), STD_ANON_59, scope=customerProfileBaseType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1247, 3))) + +customerProfileBaseType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'description'), STD_ANON_60, scope=customerProfileBaseType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1254, 3))) + +customerProfileBaseType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'email'), STD_ANON_61, scope=customerProfileBaseType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1261, 3))) + +def _BuildAutomaton_53 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_53 + del _BuildAutomaton_53 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1247, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1254, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1261, 3)) + counters.add(cc_2) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileBaseType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantCustomerId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1247, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileBaseType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1254, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileBaseType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'email')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1261, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerProfileBaseType._Automaton = _BuildAutomaton_53() + + + + +extendedAmountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'amount'), STD_ANON_64, scope=extendedAmountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1339, 3))) + +extendedAmountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'name'), STD_ANON_65, scope=extendedAmountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1347, 3))) + +extendedAmountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'description'), STD_ANON_66, scope=extendedAmountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1354, 3))) + +def _BuildAutomaton_54 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_54 + del _BuildAutomaton_54 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1347, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1354, 3)) + counters.add(cc_1) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(extendedAmountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1339, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(extendedAmountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'name')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1347, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(extendedAmountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1354, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +extendedAmountType._Automaton = _BuildAutomaton_54() + + + + +lineItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'itemId'), STD_ANON_67, scope=lineItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1366, 3))) + +lineItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'name'), STD_ANON_68, scope=lineItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1374, 3))) + +lineItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'description'), STD_ANON_69, scope=lineItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1382, 3))) + +lineItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'quantity'), STD_ANON_70, scope=lineItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1389, 3))) + +lineItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'unitPrice'), STD_ANON_71, scope=lineItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1397, 3))) + +lineItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'taxable'), pyxb.binding.datatypes.boolean, scope=lineItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1405, 3))) + +def _BuildAutomaton_55 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_55 + del _BuildAutomaton_55 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1382, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1405, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(lineItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'itemId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1366, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(lineItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'name')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1374, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(lineItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1382, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(lineItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'quantity')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1389, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + symbol = pyxb.binding.content.ElementUse(lineItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'unitPrice')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1397, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(lineItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxable')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1405, 3)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, True) ])) + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +lineItemType._Automaton = _BuildAutomaton_55() + + + + +profileTransAmountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'amount'), STD_ANON_72, scope=profileTransAmountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1411, 3))) + +profileTransAmountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'tax'), extendedAmountType, scope=profileTransAmountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3))) + +profileTransAmountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shipping'), extendedAmountType, scope=profileTransAmountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3))) + +profileTransAmountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'duty'), extendedAmountType, scope=profileTransAmountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3))) + +profileTransAmountType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'lineItems'), lineItemType, scope=profileTransAmountType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3))) + +def _BuildAutomaton_56 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_56 + del _BuildAutomaton_56 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=30, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + counters.add(cc_3) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransAmountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1411, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAmountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tax')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAmountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipping')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAmountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'duty')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAmountType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lineItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +profileTransAmountType._Automaton = _BuildAutomaton_56() + + + + +profileTransVoidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=profileTransVoidType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1529, 3))) + +profileTransVoidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), numericString, scope=profileTransVoidType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1530, 3))) + +profileTransVoidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId'), numericString, scope=profileTransVoidType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1531, 3))) + +profileTransVoidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transId'), numericString, scope=profileTransVoidType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1532, 3))) + +def _BuildAutomaton_57 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_57 + del _BuildAutomaton_57 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1529, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1530, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1531, 3)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransVoidType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1529, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransVoidType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1530, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransVoidType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1531, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransVoidType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1532, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +profileTransVoidType._Automaton = _BuildAutomaton_57() + + + + +profileTransactionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profileTransAuthCapture'), profileTransAuthCaptureType, scope=profileTransactionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1538, 3))) + +profileTransactionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profileTransAuthOnly'), profileTransAuthOnlyType, scope=profileTransactionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1539, 3))) + +profileTransactionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profileTransPriorAuthCapture'), profileTransPriorAuthCaptureType, scope=profileTransactionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1540, 3))) + +profileTransactionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profileTransCaptureOnly'), profileTransCaptureOnlyType, scope=profileTransactionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1541, 3))) + +profileTransactionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profileTransRefund'), profileTransRefundType, scope=profileTransactionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1542, 3))) + +profileTransactionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profileTransVoid'), profileTransVoidType, scope=profileTransactionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1543, 3))) + +def _BuildAutomaton_58 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_58 + del _BuildAutomaton_58 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransactionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profileTransAuthCapture')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1538, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransactionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profileTransAuthOnly')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1539, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransactionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profileTransPriorAuthCapture')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1540, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransactionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profileTransCaptureOnly')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1541, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransactionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profileTransRefund')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1542, 3)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransactionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profileTransVoid')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1543, 3)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + transitions = [] + st_4._set_transitionSet(transitions) + transitions = [] + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +profileTransactionType._Automaton = _BuildAutomaton_58() + + + + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transId'), numericString, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1549, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'submitTimeUTC'), pyxb.binding.datatypes.dateTime, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1550, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'submitTimeLocal'), pyxb.binding.datatypes.dateTime, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1551, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionStatus'), pyxb.binding.datatypes.string, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1552, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'invoiceNumber'), pyxb.binding.datatypes.string, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1553, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'firstName'), pyxb.binding.datatypes.string, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1554, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'lastName'), pyxb.binding.datatypes.string, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1555, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountType'), pyxb.binding.datatypes.string, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1556, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), pyxb.binding.datatypes.string, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1557, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'settleAmount'), pyxb.binding.datatypes.decimal, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1558, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'marketType'), pyxb.binding.datatypes.string, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1559, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'product'), pyxb.binding.datatypes.string, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1560, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId'), pyxb.binding.datatypes.string, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1561, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subscription'), subscriptionPaymentType, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1562, 3))) + +transactionSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'hasReturnedItems'), pyxb.binding.datatypes.boolean, scope=transactionSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1563, 9))) + +def _BuildAutomaton_59 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_59 + del _BuildAutomaton_59 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1553, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1554, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1555, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1559, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1560, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1561, 3)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1562, 3)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1563, 9)) + counters.add(cc_7) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1549, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'submitTimeUTC')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1550, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'submitTimeLocal')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1551, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionStatus')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1552, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'invoiceNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1553, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'firstName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1554, 3)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lastName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1555, 3)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1556, 3)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1557, 3)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'settleAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1558, 3)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'marketType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1559, 3)) + st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'product')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1560, 3)) + st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1561, 3)) + st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subscription')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1562, 3)) + st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_13) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(transactionSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'hasReturnedItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1563, 9)) + st_14 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_14) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + ])) + transitions.append(fac.Transition(st_11, [ + ])) + transitions.append(fac.Transition(st_12, [ + ])) + transitions.append(fac.Transition(st_13, [ + ])) + transitions.append(fac.Transition(st_14, [ + ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_3, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_4, False) ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_5, False) ])) + st_12._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_6, False) ])) + st_13._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_7, True) ])) + st_14._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +transactionSummaryType._Automaton = _BuildAutomaton_59() + + + + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transId'), numericString, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1569, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refTransId'), numericString, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1570, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId'), numericString, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1571, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'submitTimeUTC'), pyxb.binding.datatypes.dateTime, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1572, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'submitTimeLocal'), pyxb.binding.datatypes.dateTime, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1573, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionType'), pyxb.binding.datatypes.string, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1574, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionStatus'), pyxb.binding.datatypes.string, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1575, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'responseCode'), pyxb.binding.datatypes.int, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1576, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'responseReasonCode'), pyxb.binding.datatypes.int, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1577, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subscription'), subscriptionPaymentType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1578, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'responseReasonDescription'), pyxb.binding.datatypes.string, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1579, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'authCode'), STD_ANON_77, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1580, 6))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AVSResponse'), STD_ANON_78, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1587, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardCodeResponse'), STD_ANON_79, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1594, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'CAVVResponse'), STD_ANON_80, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1601, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FDSFilterAction'), pyxb.binding.datatypes.string, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1608, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FDSFilters'), ArrayOfFDSFilter, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1609, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'batch'), batchDetailsType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1610, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'order'), orderExType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1611, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'requestedAmount'), STD_ANON_81, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1612, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'authAmount'), STD_ANON_82, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1620, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'settleAmount'), STD_ANON_83, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1628, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'tax'), extendedAmountType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1636, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shipping'), extendedAmountType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1637, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'duty'), extendedAmountType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1638, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'lineItems'), ArrayOfLineItem, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1639, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'prepaidBalanceRemaining'), STD_ANON_84, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1640, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'taxExempt'), pyxb.binding.datatypes.boolean, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1647, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'payment'), paymentMaskedType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1648, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customer'), customerDataType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1649, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'billTo'), customerAddressType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1650, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shipTo'), nameAndAddressType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1651, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'recurringBilling'), pyxb.binding.datatypes.boolean, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1652, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerIP'), pyxb.binding.datatypes.string, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1653, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'product'), pyxb.binding.datatypes.string, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1654, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'marketType'), pyxb.binding.datatypes.string, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1655, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId'), pyxb.binding.datatypes.string, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1656, 3))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'returnedItems'), ArrayOfReturnedItem, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1657, 6))) + +transactionDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'solution'), solutionType, scope=transactionDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1658, 6))) + +def _BuildAutomaton_60 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_60 + del _BuildAutomaton_60 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1570, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1571, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1578, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1580, 6)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1587, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1594, 3)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1601, 3)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1608, 3)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1609, 3)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1610, 3)) + counters.add(cc_9) + cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1611, 3)) + counters.add(cc_10) + cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1612, 3)) + counters.add(cc_11) + cc_12 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1636, 3)) + counters.add(cc_12) + cc_13 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1637, 3)) + counters.add(cc_13) + cc_14 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1638, 3)) + counters.add(cc_14) + cc_15 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1639, 3)) + counters.add(cc_15) + cc_16 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1640, 3)) + counters.add(cc_16) + cc_17 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1647, 3)) + counters.add(cc_17) + cc_18 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1649, 3)) + counters.add(cc_18) + cc_19 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1650, 3)) + counters.add(cc_19) + cc_20 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1651, 3)) + counters.add(cc_20) + cc_21 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1652, 3)) + counters.add(cc_21) + cc_22 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1653, 3)) + counters.add(cc_22) + cc_23 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1654, 3)) + counters.add(cc_23) + cc_24 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1655, 3)) + counters.add(cc_24) + cc_25 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1656, 3)) + counters.add(cc_25) + cc_26 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1657, 6)) + counters.add(cc_26) + cc_27 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1658, 6)) + counters.add(cc_27) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1569, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refTransId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1570, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1571, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'submitTimeUTC')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1572, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'submitTimeLocal')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1573, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1574, 3)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionStatus')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1575, 3)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'responseCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1576, 3)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'responseReasonCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1577, 3)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subscription')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1578, 3)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'responseReasonDescription')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1579, 3)) + st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'authCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1580, 6)) + st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AVSResponse')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1587, 3)) + st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardCodeResponse')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1594, 3)) + st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_13) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'CAVVResponse')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1601, 3)) + st_14 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_14) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FDSFilterAction')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1608, 3)) + st_15 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_15) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FDSFilters')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1609, 3)) + st_16 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_16) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'batch')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1610, 3)) + st_17 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_17) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'order')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1611, 3)) + st_18 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_18) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'requestedAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1612, 3)) + st_19 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_19) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'authAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1620, 3)) + st_20 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_20) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'settleAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1628, 3)) + st_21 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_21) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tax')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1636, 3)) + st_22 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_22) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipping')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1637, 3)) + st_23 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_23) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'duty')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1638, 3)) + st_24 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_24) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lineItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1639, 3)) + st_25 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_25) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'prepaidBalanceRemaining')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1640, 3)) + st_26 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_26) + final_update = None + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxExempt')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1647, 3)) + st_27 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_27) + final_update = set() + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'payment')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1648, 3)) + st_28 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_28) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_18, False)) + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customer')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1649, 3)) + st_29 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_29) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_19, False)) + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'billTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1650, 3)) + st_30 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_30) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_20, False)) + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1651, 3)) + st_31 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_31) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_21, False)) + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'recurringBilling')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1652, 3)) + st_32 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_32) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_22, False)) + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerIP')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1653, 3)) + st_33 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_33) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_23, False)) + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'product')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1654, 3)) + st_34 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_34) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_24, False)) + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'marketType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1655, 3)) + st_35 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_35) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_25, False)) + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'mobileDeviceId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1656, 3)) + st_36 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_36) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_26, False)) + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'returnedItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1657, 6)) + st_37 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_37) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_27, False)) + symbol = pyxb.binding.content.ElementUse(transactionDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'solution')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1658, 6)) + st_38 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_38) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + ])) + transitions.append(fac.Transition(st_10, [ + ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_2, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + ])) + transitions.append(fac.Transition(st_12, [ + ])) + transitions.append(fac.Transition(st_13, [ + ])) + transitions.append(fac.Transition(st_14, [ + ])) + transitions.append(fac.Transition(st_15, [ + ])) + transitions.append(fac.Transition(st_16, [ + ])) + transitions.append(fac.Transition(st_17, [ + ])) + transitions.append(fac.Transition(st_18, [ + ])) + transitions.append(fac.Transition(st_19, [ + ])) + transitions.append(fac.Transition(st_20, [ + ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_3, False) ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_4, False) ])) + st_12._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_5, False) ])) + st_13._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_6, False) ])) + st_14._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_7, False) ])) + st_15._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_8, False) ])) + st_16._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_9, True) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_9, False) ])) + st_17._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_10, True) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_10, False) ])) + st_18._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_11, True) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_11, False) ])) + st_19._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_21, [ + ])) + st_20._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_22, [ + ])) + transitions.append(fac.Transition(st_23, [ + ])) + transitions.append(fac.Transition(st_24, [ + ])) + transitions.append(fac.Transition(st_25, [ + ])) + transitions.append(fac.Transition(st_26, [ + ])) + transitions.append(fac.Transition(st_27, [ + ])) + transitions.append(fac.Transition(st_28, [ + ])) + st_21._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_22, [ + fac.UpdateInstruction(cc_12, True) ])) + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_26, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_27, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_28, [ + fac.UpdateInstruction(cc_12, False) ])) + st_22._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_23, [ + fac.UpdateInstruction(cc_13, True) ])) + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_26, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_27, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_28, [ + fac.UpdateInstruction(cc_13, False) ])) + st_23._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_24, [ + fac.UpdateInstruction(cc_14, True) ])) + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_26, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_27, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_28, [ + fac.UpdateInstruction(cc_14, False) ])) + st_24._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_25, [ + fac.UpdateInstruction(cc_15, True) ])) + transitions.append(fac.Transition(st_26, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_27, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_28, [ + fac.UpdateInstruction(cc_15, False) ])) + st_25._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_26, [ + fac.UpdateInstruction(cc_16, True) ])) + transitions.append(fac.Transition(st_27, [ + fac.UpdateInstruction(cc_16, False) ])) + transitions.append(fac.Transition(st_28, [ + fac.UpdateInstruction(cc_16, False) ])) + st_26._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_27, [ + fac.UpdateInstruction(cc_17, True) ])) + transitions.append(fac.Transition(st_28, [ + fac.UpdateInstruction(cc_17, False) ])) + st_27._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_29, [ + ])) + transitions.append(fac.Transition(st_30, [ + ])) + transitions.append(fac.Transition(st_31, [ + ])) + transitions.append(fac.Transition(st_32, [ + ])) + transitions.append(fac.Transition(st_33, [ + ])) + transitions.append(fac.Transition(st_34, [ + ])) + transitions.append(fac.Transition(st_35, [ + ])) + transitions.append(fac.Transition(st_36, [ + ])) + transitions.append(fac.Transition(st_37, [ + ])) + transitions.append(fac.Transition(st_38, [ + ])) + st_28._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_29, [ + fac.UpdateInstruction(cc_18, True) ])) + transitions.append(fac.Transition(st_30, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_31, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_32, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_33, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_34, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_35, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_36, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_37, [ + fac.UpdateInstruction(cc_18, False) ])) + transitions.append(fac.Transition(st_38, [ + fac.UpdateInstruction(cc_18, False) ])) + st_29._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_30, [ + fac.UpdateInstruction(cc_19, True) ])) + transitions.append(fac.Transition(st_31, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_32, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_33, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_34, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_35, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_36, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_37, [ + fac.UpdateInstruction(cc_19, False) ])) + transitions.append(fac.Transition(st_38, [ + fac.UpdateInstruction(cc_19, False) ])) + st_30._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_31, [ + fac.UpdateInstruction(cc_20, True) ])) + transitions.append(fac.Transition(st_32, [ + fac.UpdateInstruction(cc_20, False) ])) + transitions.append(fac.Transition(st_33, [ + fac.UpdateInstruction(cc_20, False) ])) + transitions.append(fac.Transition(st_34, [ + fac.UpdateInstruction(cc_20, False) ])) + transitions.append(fac.Transition(st_35, [ + fac.UpdateInstruction(cc_20, False) ])) + transitions.append(fac.Transition(st_36, [ + fac.UpdateInstruction(cc_20, False) ])) + transitions.append(fac.Transition(st_37, [ + fac.UpdateInstruction(cc_20, False) ])) + transitions.append(fac.Transition(st_38, [ + fac.UpdateInstruction(cc_20, False) ])) + st_31._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_32, [ + fac.UpdateInstruction(cc_21, True) ])) + transitions.append(fac.Transition(st_33, [ + fac.UpdateInstruction(cc_21, False) ])) + transitions.append(fac.Transition(st_34, [ + fac.UpdateInstruction(cc_21, False) ])) + transitions.append(fac.Transition(st_35, [ + fac.UpdateInstruction(cc_21, False) ])) + transitions.append(fac.Transition(st_36, [ + fac.UpdateInstruction(cc_21, False) ])) + transitions.append(fac.Transition(st_37, [ + fac.UpdateInstruction(cc_21, False) ])) + transitions.append(fac.Transition(st_38, [ + fac.UpdateInstruction(cc_21, False) ])) + st_32._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_33, [ + fac.UpdateInstruction(cc_22, True) ])) + transitions.append(fac.Transition(st_34, [ + fac.UpdateInstruction(cc_22, False) ])) + transitions.append(fac.Transition(st_35, [ + fac.UpdateInstruction(cc_22, False) ])) + transitions.append(fac.Transition(st_36, [ + fac.UpdateInstruction(cc_22, False) ])) + transitions.append(fac.Transition(st_37, [ + fac.UpdateInstruction(cc_22, False) ])) + transitions.append(fac.Transition(st_38, [ + fac.UpdateInstruction(cc_22, False) ])) + st_33._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_34, [ + fac.UpdateInstruction(cc_23, True) ])) + transitions.append(fac.Transition(st_35, [ + fac.UpdateInstruction(cc_23, False) ])) + transitions.append(fac.Transition(st_36, [ + fac.UpdateInstruction(cc_23, False) ])) + transitions.append(fac.Transition(st_37, [ + fac.UpdateInstruction(cc_23, False) ])) + transitions.append(fac.Transition(st_38, [ + fac.UpdateInstruction(cc_23, False) ])) + st_34._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_35, [ + fac.UpdateInstruction(cc_24, True) ])) + transitions.append(fac.Transition(st_36, [ + fac.UpdateInstruction(cc_24, False) ])) + transitions.append(fac.Transition(st_37, [ + fac.UpdateInstruction(cc_24, False) ])) + transitions.append(fac.Transition(st_38, [ + fac.UpdateInstruction(cc_24, False) ])) + st_35._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_36, [ + fac.UpdateInstruction(cc_25, True) ])) + transitions.append(fac.Transition(st_37, [ + fac.UpdateInstruction(cc_25, False) ])) + transitions.append(fac.Transition(st_38, [ + fac.UpdateInstruction(cc_25, False) ])) + st_36._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_37, [ + fac.UpdateInstruction(cc_26, True) ])) + transitions.append(fac.Transition(st_38, [ + fac.UpdateInstruction(cc_26, False) ])) + st_37._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_38, [ + fac.UpdateInstruction(cc_27, True) ])) + st_38._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +transactionDetailsType._Automaton = _BuildAutomaton_60() + + + + +solutionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'id'), pyxb.binding.datatypes.string, scope=solutionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1664, 6))) + +solutionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'name'), pyxb.binding.datatypes.string, scope=solutionType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1665, 6))) + +def _BuildAutomaton_61 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_61 + del _BuildAutomaton_61 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1665, 6)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(solutionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'id')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1664, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(solutionType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'name')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1665, 6)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +solutionType._Automaton = _BuildAutomaton_61() + + + + +ArrayOfReturnedItem._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'returnedItem'), returnedItemType, scope=ArrayOfReturnedItem, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1671, 6))) + +def _BuildAutomaton_62 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_62 + del _BuildAutomaton_62 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1671, 6)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfReturnedItem._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'returnedItem')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1671, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfReturnedItem._Automaton = _BuildAutomaton_62() + + + + +returnedItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'id'), numericString, scope=returnedItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1677, 6))) + +returnedItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'dateUTC'), pyxb.binding.datatypes.dateTime, scope=returnedItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1678, 6))) + +returnedItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'dateLocal'), pyxb.binding.datatypes.dateTime, scope=returnedItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1679, 6))) + +returnedItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'code'), pyxb.binding.datatypes.string, scope=returnedItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1680, 6))) + +returnedItemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'description'), pyxb.binding.datatypes.string, scope=returnedItemType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1681, 6))) + +def _BuildAutomaton_63 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_63 + del _BuildAutomaton_63 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(returnedItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'id')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1677, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(returnedItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'dateUTC')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1678, 6)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(returnedItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'dateLocal')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1679, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(returnedItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'code')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1680, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + symbol = pyxb.binding.content.ElementUse(returnedItemType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1681, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +returnedItemType._Automaton = _BuildAutomaton_63() + + + + +FDSFilterType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'name'), pyxb.binding.datatypes.string, scope=FDSFilterType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1687, 3))) + +FDSFilterType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'action'), pyxb.binding.datatypes.string, scope=FDSFilterType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1688, 3))) + +def _BuildAutomaton_64 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_64 + del _BuildAutomaton_64 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(FDSFilterType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'name')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1687, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(FDSFilterType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'action')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1688, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +FDSFilterType._Automaton = _BuildAutomaton_64() + + + + +batchDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'batchId'), numericString, scope=batchDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1694, 3))) + +batchDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'settlementTimeUTC'), pyxb.binding.datatypes.dateTime, scope=batchDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1695, 3))) + +batchDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'settlementTimeLocal'), pyxb.binding.datatypes.dateTime, scope=batchDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1696, 3))) + +batchDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'settlementState'), pyxb.binding.datatypes.string, scope=batchDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1697, 3))) + +batchDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentMethod'), pyxb.binding.datatypes.string, scope=batchDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1698, 3))) + +batchDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'marketType'), pyxb.binding.datatypes.string, scope=batchDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1699, 3))) + +batchDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'product'), pyxb.binding.datatypes.string, scope=batchDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1700, 3))) + +batchDetailsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'statistics'), ArrayOfBatchStatisticType, scope=batchDetailsType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1701, 3))) + +def _BuildAutomaton_65 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_65 + del _BuildAutomaton_65 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1695, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1696, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1698, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1699, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1700, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1701, 3)) + counters.add(cc_5) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(batchDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'batchId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1694, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(batchDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'settlementTimeUTC')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1695, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(batchDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'settlementTimeLocal')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1696, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(batchDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'settlementState')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1697, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(batchDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentMethod')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1698, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(batchDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'marketType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1699, 3)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(batchDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'product')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1700, 3)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(batchDetailsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'statistics')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1701, 3)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, True) ])) + st_7._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +batchDetailsType._Automaton = _BuildAutomaton_65() + + + + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountType'), pyxb.binding.datatypes.string, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1707, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'chargeAmount'), pyxb.binding.datatypes.decimal, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1708, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'chargeCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1709, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refundAmount'), pyxb.binding.datatypes.decimal, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1710, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refundCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1711, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'voidCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1712, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'declineCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1713, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'errorCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1714, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'returnedItemAmount'), pyxb.binding.datatypes.decimal, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1715, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'returnedItemCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1716, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'chargebackAmount'), pyxb.binding.datatypes.decimal, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1717, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'chargebackCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1718, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'correctionNoticeCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1719, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'chargeChargeBackAmount'), pyxb.binding.datatypes.decimal, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1720, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'chargeChargeBackCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1721, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refundChargeBackAmount'), pyxb.binding.datatypes.decimal, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1722, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refundChargeBackCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1723, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'chargeReturnedItemsAmount'), pyxb.binding.datatypes.decimal, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1724, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'chargeReturnedItemsCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1725, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refundReturnedItemsAmount'), pyxb.binding.datatypes.decimal, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1726, 3))) + +batchStatisticType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refundReturnedItemsCount'), pyxb.binding.datatypes.int, scope=batchStatisticType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1727, 3))) + +def _BuildAutomaton_66 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_66 + del _BuildAutomaton_66 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1715, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1716, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1717, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1718, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1719, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1720, 3)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1721, 3)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1722, 3)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1723, 3)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1724, 3)) + counters.add(cc_9) + cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1725, 3)) + counters.add(cc_10) + cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1726, 3)) + counters.add(cc_11) + cc_12 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1727, 3)) + counters.add(cc_12) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1707, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'chargeAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1708, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'chargeCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1709, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refundAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1710, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refundCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1711, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'voidCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1712, 3)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = None + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'declineCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1713, 3)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'errorCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1714, 3)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'returnedItemAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1715, 3)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'returnedItemCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1716, 3)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'chargebackAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1717, 3)) + st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'chargebackCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1718, 3)) + st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'correctionNoticeCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1719, 3)) + st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'chargeChargeBackAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1720, 3)) + st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_13) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'chargeChargeBackCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1721, 3)) + st_14 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_14) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refundChargeBackAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1722, 3)) + st_15 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_15) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refundChargeBackCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1723, 3)) + st_16 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_16) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_9, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'chargeReturnedItemsAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1724, 3)) + st_17 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_17) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_10, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'chargeReturnedItemsCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1725, 3)) + st_18 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_18) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_11, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refundReturnedItemsAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1726, 3)) + st_19 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_19) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_12, False)) + symbol = pyxb.binding.content.ElementUse(batchStatisticType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refundReturnedItemsCount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1727, 3)) + st_20 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_20) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + ])) + transitions.append(fac.Transition(st_9, [ + ])) + transitions.append(fac.Transition(st_10, [ + ])) + transitions.append(fac.Transition(st_11, [ + ])) + transitions.append(fac.Transition(st_12, [ + ])) + transitions.append(fac.Transition(st_13, [ + ])) + transitions.append(fac.Transition(st_14, [ + ])) + transitions.append(fac.Transition(st_15, [ + ])) + transitions.append(fac.Transition(st_16, [ + ])) + transitions.append(fac.Transition(st_17, [ + ])) + transitions.append(fac.Transition(st_18, [ + ])) + transitions.append(fac.Transition(st_19, [ + ])) + transitions.append(fac.Transition(st_20, [ + ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_0, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_1, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_2, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_3, False) ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_4, False) ])) + st_12._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_5, False) ])) + st_13._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_6, False) ])) + st_14._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_7, False) ])) + st_15._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_8, False) ])) + st_16._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_9, True) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_9, False) ])) + st_17._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_10, True) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_10, False) ])) + st_18._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_11, True) ])) + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_11, False) ])) + st_19._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_20, [ + fac.UpdateInstruction(cc_12, True) ])) + st_20._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +batchStatisticType._Automaton = _BuildAutomaton_66() + + + + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'responseCode'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1733, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'rawResponseCode'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1734, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'authCode'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1735, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'avsResultCode'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1736, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cvvResultCode'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1737, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cavvResultCode'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1738, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transId'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1739, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refTransID'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1740, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transHash'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1741, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'testRequest'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1742, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1743, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountType'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1744, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId'), pyxb.binding.datatypes.string, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1745, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'prePaidCard'), CTD_ANON_6, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1746, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'messages'), CTD_ANON_7, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1755, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'errors'), CTD_ANON_9, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1769, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'splitTenderPayments'), CTD_ANON_11, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1783, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'userFields'), CTD_ANON_13, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1804, 3))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shipTo'), nameAndAddressType, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1811, 6))) + +transactionResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'secureAcceptance'), CTD_ANON_14, scope=transactionResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1812, 6))) + +def _BuildAutomaton_67 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_67 + del _BuildAutomaton_67 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1733, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1734, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1735, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1736, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1737, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1738, 3)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1739, 3)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1740, 3)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1741, 3)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1742, 3)) + counters.add(cc_9) + cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1743, 3)) + counters.add(cc_10) + cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1744, 3)) + counters.add(cc_11) + cc_12 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1745, 3)) + counters.add(cc_12) + cc_13 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1746, 3)) + counters.add(cc_13) + cc_14 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1755, 3)) + counters.add(cc_14) + cc_15 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1769, 3)) + counters.add(cc_15) + cc_16 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1783, 3)) + counters.add(cc_16) + cc_17 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1804, 3)) + counters.add(cc_17) + cc_18 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1811, 6)) + counters.add(cc_18) + cc_19 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1812, 6)) + counters.add(cc_19) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'responseCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1733, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'rawResponseCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1734, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'authCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1735, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'avsResultCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1736, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cvvResultCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1737, 3)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cavvResultCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1738, 3)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1739, 3)) + st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refTransID')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1740, 3)) + st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transHash')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1741, 3)) + st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_9, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'testRequest')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1742, 3)) + st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_10, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1743, 3)) + st_10 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_11, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1744, 3)) + st_11 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_12, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1745, 3)) + st_12 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_13, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'prePaidCard')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1746, 3)) + st_13 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_13) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_14, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1755, 3)) + st_14 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_14) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_15, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'errors')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1769, 3)) + st_15 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_15) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_16, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderPayments')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1783, 3)) + st_16 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_16) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_17, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'userFields')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1804, 3)) + st_17 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_17) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_18, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1811, 6)) + st_18 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_18) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_19, False)) + symbol = pyxb.binding.content.ElementUse(transactionResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'secureAcceptance')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1812, 6)) + st_19 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_19) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_5, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_6, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_7, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_8, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_9, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_9, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_10, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_10, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_10, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_11, True) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_11, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_11, False) ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_12, True) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_12, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_12, False) ])) + st_12._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_13, True) ])) + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_13, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_13, False) ])) + st_13._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_14, [ + fac.UpdateInstruction(cc_14, True) ])) + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_14, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_14, False) ])) + st_14._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_15, [ + fac.UpdateInstruction(cc_15, True) ])) + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_15, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_15, False) ])) + st_15._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_16, [ + fac.UpdateInstruction(cc_16, True) ])) + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_16, False) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_16, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_16, False) ])) + st_16._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_17, [ + fac.UpdateInstruction(cc_17, True) ])) + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_17, False) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_17, False) ])) + st_17._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_18, [ + fac.UpdateInstruction(cc_18, True) ])) + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_18, False) ])) + st_18._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_19, [ + fac.UpdateInstruction(cc_19, True) ])) + st_19._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +transactionResponse._Automaton = _BuildAutomaton_67() + + + + +CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'requestedAmount'), pyxb.binding.datatypes.string, scope=CTD_ANON_6, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1749, 6))) + +CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'approvedAmount'), pyxb.binding.datatypes.string, scope=CTD_ANON_6, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1750, 6))) + +CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'balanceOnCard'), pyxb.binding.datatypes.string, scope=CTD_ANON_6, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1751, 6))) + +def _BuildAutomaton_68 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_68 + del _BuildAutomaton_68 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1749, 6)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1750, 6)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1751, 6)) + counters.add(cc_2) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'requestedAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1749, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'approvedAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1750, 6)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'balanceOnCard')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1751, 6)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_6._Automaton = _BuildAutomaton_68() + + + + +CTD_ANON_7._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'message'), CTD_ANON_8, scope=CTD_ANON_7, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1758, 6))) + +def _BuildAutomaton_69 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_69 + del _BuildAutomaton_69 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1758, 6)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_7._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'message')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1758, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_7._Automaton = _BuildAutomaton_69() + + + + +CTD_ANON_8._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'code'), pyxb.binding.datatypes.string, scope=CTD_ANON_8, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1761, 9))) + +CTD_ANON_8._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'description'), pyxb.binding.datatypes.string, scope=CTD_ANON_8, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1762, 9))) + +def _BuildAutomaton_70 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_70 + del _BuildAutomaton_70 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1761, 9)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1762, 9)) + counters.add(cc_1) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_8._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'code')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1761, 9)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_8._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1762, 9)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_8._Automaton = _BuildAutomaton_70() + + + + +CTD_ANON_9._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'error'), CTD_ANON_10, scope=CTD_ANON_9, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1772, 6))) + +def _BuildAutomaton_71 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_71 + del _BuildAutomaton_71 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1772, 6)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_9._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'error')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1772, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_9._Automaton = _BuildAutomaton_71() + + + + +CTD_ANON_10._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'errorCode'), pyxb.binding.datatypes.string, scope=CTD_ANON_10, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1775, 9))) + +CTD_ANON_10._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'errorText'), pyxb.binding.datatypes.string, scope=CTD_ANON_10, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1776, 9))) + +def _BuildAutomaton_72 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_72 + del _BuildAutomaton_72 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1775, 9)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1776, 9)) + counters.add(cc_1) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_10._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'errorCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1775, 9)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_10._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'errorText')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1776, 9)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_10._Automaton = _BuildAutomaton_72() + + + + +CTD_ANON_11._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'splitTenderPayment'), CTD_ANON_12, scope=CTD_ANON_11, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1786, 6))) + +def _BuildAutomaton_73 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_73 + del _BuildAutomaton_73 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1786, 6)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_11._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderPayment')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1786, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_11._Automaton = _BuildAutomaton_73() + + + + +CTD_ANON_12._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transId'), pyxb.binding.datatypes.string, scope=CTD_ANON_12, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1789, 9))) + +CTD_ANON_12._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'responseCode'), pyxb.binding.datatypes.string, scope=CTD_ANON_12, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1790, 9))) + +CTD_ANON_12._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'responseToCustomer'), pyxb.binding.datatypes.string, scope=CTD_ANON_12, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1791, 9))) + +CTD_ANON_12._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'authCode'), pyxb.binding.datatypes.string, scope=CTD_ANON_12, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1792, 9))) + +CTD_ANON_12._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), pyxb.binding.datatypes.string, scope=CTD_ANON_12, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1793, 9))) + +CTD_ANON_12._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountType'), pyxb.binding.datatypes.string, scope=CTD_ANON_12, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1794, 9))) + +CTD_ANON_12._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'requestedAmount'), pyxb.binding.datatypes.string, scope=CTD_ANON_12, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1795, 9))) + +CTD_ANON_12._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'approvedAmount'), pyxb.binding.datatypes.string, scope=CTD_ANON_12, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1796, 9))) + +CTD_ANON_12._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'balanceOnCard'), pyxb.binding.datatypes.string, scope=CTD_ANON_12, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1797, 9))) + +def _BuildAutomaton_74 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_74 + del _BuildAutomaton_74 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1789, 9)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1790, 9)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1791, 9)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1792, 9)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1793, 9)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1794, 9)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1795, 9)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1796, 9)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1797, 9)) + counters.add(cc_8) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_12._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1789, 9)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_12._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'responseCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1790, 9)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_12._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'responseToCustomer')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1791, 9)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_12._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'authCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1792, 9)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_12._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1793, 9)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_12._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1794, 9)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_12._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'requestedAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1795, 9)) + st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_12._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'approvedAmount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1796, 9)) + st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_12._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'balanceOnCard')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1797, 9)) + st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_6, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_7, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_8, True) ])) + st_8._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_12._Automaton = _BuildAutomaton_74() + + + + +CTD_ANON_13._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'userField'), userField, scope=CTD_ANON_13, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1807, 6))) + +def _BuildAutomaton_75 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_75 + del _BuildAutomaton_75 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=20, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1807, 6)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_13._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'userField')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1807, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_13._Automaton = _BuildAutomaton_75() + + + + +CTD_ANON_14._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'SecureAcceptanceUrl'), pyxb.binding.datatypes.string, scope=CTD_ANON_14, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1815, 12))) + +CTD_ANON_14._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'PayerID'), pyxb.binding.datatypes.string, scope=CTD_ANON_14, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1816, 12))) + +def _BuildAutomaton_76 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_76 + del _BuildAutomaton_76 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1815, 12)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1816, 12)) + counters.add(cc_1) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_14._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'SecureAcceptanceUrl')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1815, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_14._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'PayerID')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1816, 12)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_14._Automaton = _BuildAutomaton_76() + + + + +ANetApiRequest._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication'), merchantAuthenticationType, scope=ANetApiRequest, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3))) + +ANetApiRequest._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refId'), STD_ANON_85, scope=ANetApiRequest, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3))) + +def _BuildAutomaton_77 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_77 + del _BuildAutomaton_77 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(ANetApiRequest._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ANetApiRequest._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +ANetApiRequest._Automaton = _BuildAutomaton_77() + + + + +messagesType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'resultCode'), messageTypeEnum, scope=messagesType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1880, 3))) + +messagesType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'message'), CTD_ANON_15, scope=messagesType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1881, 3))) + +def _BuildAutomaton_78 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_78 + del _BuildAutomaton_78 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(messagesType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'resultCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1880, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(messagesType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'message')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1881, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +messagesType._Automaton = _BuildAutomaton_78() + + + + +CTD_ANON_15._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'code'), pyxb.binding.datatypes.string, scope=CTD_ANON_15, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1884, 6))) + +CTD_ANON_15._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'text'), pyxb.binding.datatypes.string, scope=CTD_ANON_15, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1885, 6))) + +def _BuildAutomaton_79 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_79 + del _BuildAutomaton_79 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_15._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'code')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1884, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_15._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'text')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1885, 6)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_15._Automaton = _BuildAutomaton_79() + + + + +ANetApiResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refId'), pyxb.binding.datatypes.string, scope=ANetApiResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3))) + +ANetApiResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'messages'), messagesType, scope=ANetApiResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4))) + +ANetApiResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'sessionToken'), pyxb.binding.datatypes.string, scope=ANetApiResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3))) + +def _BuildAutomaton_80 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_80 + del _BuildAutomaton_80 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(ANetApiResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(ANetApiResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(ANetApiResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +ANetApiResponse._Automaton = _BuildAutomaton_80() + + + + +CTD_ANON_16._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'refId'), STD_ANON_87, scope=CTD_ANON_16, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1928, 4))) + +def _BuildAutomaton_81 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_81 + del _BuildAutomaton_81 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1928, 4)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_16._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1928, 4)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +CTD_ANON_16._Automaton = _BuildAutomaton_81() + + + + +createProfileResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'messages'), messagesType, scope=createProfileResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2166, 12))) + +createProfileResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=createProfileResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2168, 12))) + +createProfileResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileIdList'), ArrayOfNumericString, scope=createProfileResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2169, 12))) + +createProfileResponse._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressIdList'), ArrayOfNumericString, scope=createProfileResponse, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2170, 12))) + +def _BuildAutomaton_82 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_82 + del _BuildAutomaton_82 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2168, 12)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2169, 12)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2170, 12)) + counters.add(cc_2) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(createProfileResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2166, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(createProfileResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2168, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(createProfileResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileIdList')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2169, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(createProfileResponse._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressIdList')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2170, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +createProfileResponse._Automaton = _BuildAutomaton_82() + + + + +payPalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'successUrl'), STD_ANON_93, scope=payPalType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3126, 3))) + +payPalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cancelUrl'), STD_ANON_94, scope=payPalType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3133, 3))) + +payPalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paypalLc'), STD_ANON_95, scope=payPalType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3140, 3))) + +payPalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paypalHdrImg'), STD_ANON_96, scope=payPalType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3147, 3))) + +payPalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paypalPayflowcolor'), STD_ANON_97, scope=payPalType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3154, 3))) + +payPalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'payerID'), STD_ANON_98, scope=payPalType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3161, 3))) + +def _BuildAutomaton_83 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_83 + del _BuildAutomaton_83 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3126, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3133, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3140, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3147, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3154, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3161, 3)) + counters.add(cc_5) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(payPalType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'successUrl')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3126, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(payPalType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cancelUrl')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3133, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(payPalType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paypalLc')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3140, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(payPalType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paypalHdrImg')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3147, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(payPalType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paypalPayflowcolor')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3154, 3)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(payPalType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'payerID')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3161, 3)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +payPalType._Automaton = _BuildAutomaton_83() + + + + +Paging._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'limit'), STD_ANON_99, scope=Paging, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3185, 12))) + +Paging._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'offset'), STD_ANON_100, scope=Paging, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3193, 12))) + +def _BuildAutomaton_84 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_84 + del _BuildAutomaton_84 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(Paging._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'limit')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3185, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(Paging._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'offset')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3193, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +Paging._Automaton = _BuildAutomaton_84() + + + + +ARBGetSubscriptionListSorting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'orderBy'), ARBGetSubscriptionListOrderFieldEnum, scope=ARBGetSubscriptionListSorting, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3205, 12))) + +ARBGetSubscriptionListSorting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'orderDescending'), pyxb.binding.datatypes.boolean, scope=ARBGetSubscriptionListSorting, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3206, 12))) + +def _BuildAutomaton_85 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_85 + del _BuildAutomaton_85 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(ARBGetSubscriptionListSorting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'orderBy')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3205, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(ARBGetSubscriptionListSorting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'orderDescending')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3206, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +ARBGetSubscriptionListSorting._Automaton = _BuildAutomaton_85() + + + + +ArrayOfSubscription._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subscriptionDetail'), SubscriptionDetail, nillable=pyxb.binding.datatypes.boolean(1), scope=ArrayOfSubscription, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3244, 3))) + +def _BuildAutomaton_86 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_86 + del _BuildAutomaton_86 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3244, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(ArrayOfSubscription._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subscriptionDetail')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3244, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +ArrayOfSubscription._Automaton = _BuildAutomaton_86() + + + + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'id'), pyxb.binding.datatypes.int, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3249, 3))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'name'), pyxb.binding.datatypes.string, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3250, 3))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'status'), ARBSubscriptionStatusEnum, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3251, 12))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createTimeStampUTC'), pyxb.binding.datatypes.dateTime, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3252, 3))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'firstName'), pyxb.binding.datatypes.string, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3253, 3))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'lastName'), pyxb.binding.datatypes.string, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3254, 3))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'totalOccurrences'), pyxb.binding.datatypes.int, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3255, 3))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'pastOccurrences'), pyxb.binding.datatypes.int, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3256, 3))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentMethod'), paymentMethodEnum, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3257, 12))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountNumber'), pyxb.binding.datatypes.string, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3258, 12))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'invoice'), pyxb.binding.datatypes.string, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3259, 3))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'amount'), STD_ANON_101, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3260, 3))) + +SubscriptionDetail._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'currencyCode'), pyxb.binding.datatypes.string, scope=SubscriptionDetail, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3268, 3))) + +def _BuildAutomaton_87 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_87 + del _BuildAutomaton_87 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3250, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3253, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3254, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3258, 12)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3259, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3268, 3)) + counters.add(cc_5) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'id')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3249, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'name')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3250, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'status')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3251, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'createTimeStampUTC')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3252, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'firstName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3253, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lastName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3254, 3)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'totalOccurrences')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3255, 3)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'pastOccurrences')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3256, 3)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentMethod')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3257, 12)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3258, 12)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = None + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'invoice')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3259, 3)) + st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = set() + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3260, 3)) + st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(SubscriptionDetail._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'currencyCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3268, 3)) + st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + ])) + transitions.append(fac.Transition(st_10, [ + ])) + transitions.append(fac.Transition(st_11, [ + ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_3, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_4, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_5, True) ])) + st_12._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +SubscriptionDetail._Automaton = _BuildAutomaton_87() + + + + +searchCriteriaCustomerProfileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantCustomerId'), pyxb.binding.datatypes.string, scope=searchCriteriaCustomerProfileType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3279, 12))) + +searchCriteriaCustomerProfileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'email'), pyxb.binding.datatypes.string, scope=searchCriteriaCustomerProfileType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3280, 12))) + +def _BuildAutomaton_88 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_88 + del _BuildAutomaton_88 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3280, 12)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(searchCriteriaCustomerProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantCustomerId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3279, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(searchCriteriaCustomerProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'email')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3280, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +searchCriteriaCustomerProfileType._Automaton = _BuildAutomaton_88() + + + + +CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileSummaryType'), customerProfileSummaryType, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3300, 16))) + +CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentSimpleType'), paymentSimpleType, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3301, 16))) + +CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'accountTypeEnum'), accountTypeEnum, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3303, 16))) + +CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardTypeEnum'), cardTypeEnum, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3304, 16))) + +CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FDSFilterActionEnum'), FDSFilterActionEnum, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3305, 16))) + +CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'permissionsEnum'), permissionsEnum, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3306, 16))) + +CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'settingNameEnum'), settingNameEnum, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3307, 16))) + +CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'settlementStateEnum'), settlementStateEnum, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3308, 16))) + +CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionStatusEnum'), transactionStatusEnum, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3309, 16))) + +CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionTypeEnum'), transactionTypeEnum, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3310, 16))) + +def _BuildAutomaton_89 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_89 + del _BuildAutomaton_89 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileSummaryType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3300, 16)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentSimpleType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3301, 16)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'accountTypeEnum')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3303, 16)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardTypeEnum')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3304, 16)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FDSFilterActionEnum')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3305, 16)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'permissionsEnum')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3306, 16)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'settingNameEnum')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3307, 16)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'settlementStateEnum')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3308, 16)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionStatusEnum')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3309, 16)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionTypeEnum')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3310, 16)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + ])) + st_8._set_transitionSet(transitions) + transitions = [] + st_9._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_17._Automaton = _BuildAutomaton_89() + + + + +customerProfilePaymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'createProfile'), pyxb.binding.datatypes.boolean, scope=customerProfilePaymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3321, 8))) + +customerProfilePaymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=customerProfilePaymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3322, 8))) + +customerProfilePaymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile'), paymentProfile, scope=customerProfilePaymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3323, 8))) + +customerProfilePaymentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shippingProfileId'), numericString, scope=customerProfilePaymentType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3324, 8))) + +def _BuildAutomaton_90 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_90 + del _BuildAutomaton_90 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3321, 8)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3322, 8)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3323, 8)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3324, 8)) + counters.add(cc_3) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerProfilePaymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'createProfile')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3321, 8)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerProfilePaymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3322, 8)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerProfilePaymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3323, 8)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerProfilePaymentType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shippingProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3324, 8)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerProfilePaymentType._Automaton = _BuildAutomaton_90() + + + + +paymentProfile._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentProfileId'), numericString, scope=paymentProfile, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3335, 6))) + +paymentProfile._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardCode'), cardCode, scope=paymentProfile, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3336, 6))) + +def _BuildAutomaton_91 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_91 + del _BuildAutomaton_91 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3336, 6)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(paymentProfile._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3335, 6)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(paymentProfile._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3336, 6)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +paymentProfile._Automaton = _BuildAutomaton_91() + + + + +creditCardType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardCode'), cardCode, scope=creditCardType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 425, 5))) + +creditCardType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'isPaymentToken'), pyxb.binding.datatypes.boolean, scope=creditCardType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 427, 10))) + +creditCardType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cryptogram'), pyxb.binding.datatypes.string, scope=creditCardType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 429, 10))) + +def _BuildAutomaton_92 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_92 + del _BuildAutomaton_92 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 425, 5)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 427, 10)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 429, 10)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(creditCardType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 385, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(creditCardType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'expirationDate')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 394, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(creditCardType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 425, 5)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(creditCardType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'isPaymentToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 427, 10)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(creditCardType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cryptogram')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 429, 10)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +creditCardType._Automaton = _BuildAutomaton_92() + + + + +orderExType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'purchaseOrderNumber'), STD_ANON_30, scope=orderExType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 621, 5))) + +def _BuildAutomaton_93 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_93 + del _BuildAutomaton_93 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 600, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 607, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 621, 5)) + counters.add(cc_2) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(orderExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'invoiceNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 600, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(orderExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 607, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(orderExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'purchaseOrderNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 621, 5)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +orderExType._Automaton = _BuildAutomaton_93() + + + + +CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'opaqueData'), opaqueDataType, scope=CTD_ANON_18, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 785, 12))) + +CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'callId'), pyxb.binding.datatypes.string, scope=CTD_ANON_18, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 786, 12))) + +def _BuildAutomaton_94 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_94 + del _BuildAutomaton_94 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 786, 12)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'opaqueData')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 785, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'callId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 786, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_18._Automaton = _BuildAutomaton_94() + + + + +CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shippingInfo'), customerAddressType, scope=CTD_ANON_19, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 798, 12))) + +CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'billingInfo'), customerAddressType, scope=CTD_ANON_19, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 799, 12))) + +CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardInfo'), creditCardMaskedType, scope=CTD_ANON_19, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 800, 12))) + +CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentDetails'), paymentDetails, scope=CTD_ANON_19, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 801, 12))) + +def _BuildAutomaton_95 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_95 + del _BuildAutomaton_95 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 798, 12)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 799, 12)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 800, 12)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 801, 12)) + counters.add(cc_5) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shippingInfo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 798, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'billingInfo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 799, 12)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardInfo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 800, 12)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentDetails')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 801, 12)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, True) ])) + st_6._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_19._Automaton = _BuildAutomaton_95() + + + + +customerPaymentProfileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'payment'), paymentType, scope=customerPaymentProfileType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1200, 5))) + +customerPaymentProfileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'driversLicense'), driversLicenseType, scope=customerPaymentProfileType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1201, 5))) + +customerPaymentProfileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'taxId'), STD_ANON_57, scope=customerPaymentProfileType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1203, 5))) + +def _BuildAutomaton_96 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_96 + del _BuildAutomaton_96 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1191, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1192, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1200, 5)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1201, 5)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1203, 5)) + counters.add(cc_4) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1191, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'billTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1192, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'payment')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1200, 5)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'driversLicense')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1201, 5)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1203, 5)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerPaymentProfileType._Automaton = _BuildAutomaton_96() + + + + +customerPaymentProfileMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), numericString, scope=customerPaymentProfileMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1230, 5))) + +customerPaymentProfileMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'payment'), paymentMaskedType, scope=customerPaymentProfileMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1231, 5))) + +customerPaymentProfileMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'driversLicense'), driversLicenseMaskedType, scope=customerPaymentProfileMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1232, 5))) + +customerPaymentProfileMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'taxId'), STD_ANON_58, scope=customerPaymentProfileMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1233, 5))) + +def _BuildAutomaton_97 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_97 + del _BuildAutomaton_97 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1191, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1192, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1230, 5)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1231, 5)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1232, 5)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1233, 5)) + counters.add(cc_5) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1191, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'billTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1192, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1230, 5)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'payment')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1231, 5)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'driversLicense')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1232, 5)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1233, 5)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerPaymentProfileMaskedType._Automaton = _BuildAutomaton_97() + + + + +customerProfileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentProfiles'), customerPaymentProfileType, scope=customerProfileType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1275, 5))) + +customerProfileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shipToList'), customerAddressType, scope=customerProfileType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1276, 5))) + +def _BuildAutomaton_98 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_98 + del _BuildAutomaton_98 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1247, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1254, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1261, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1275, 5)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1276, 5)) + counters.add(cc_4) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantCustomerId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1247, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1254, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'email')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1261, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentProfiles')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1275, 5)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipToList')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1276, 5)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerProfileType._Automaton = _BuildAutomaton_98() + + + + +customerProfileExType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=customerProfileExType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1286, 5))) + +def _BuildAutomaton_99 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_99 + del _BuildAutomaton_99 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1247, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1254, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1261, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1286, 5)) + counters.add(cc_3) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantCustomerId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1247, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1254, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'email')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1261, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1286, 5)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerProfileExType._Automaton = _BuildAutomaton_99() + + + + +customerAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'phoneNumber'), STD_ANON_62, scope=customerAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1307, 5))) + +customerAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'faxNumber'), STD_ANON_63, scope=customerAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1314, 5))) + +customerAddressType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'email'), pyxb.binding.datatypes.string, scope=customerAddressType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1321, 14))) + +def _BuildAutomaton_100 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_100 + del _BuildAutomaton_100 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 305, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 312, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 319, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 326, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 333, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 340, 3)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 347, 3)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 354, 3)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1307, 5)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1314, 5)) + counters.add(cc_9) + cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1321, 14)) + counters.add(cc_10) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'firstName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 305, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lastName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 312, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'company')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 319, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'address')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 326, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'city')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 333, 3)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'state')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 340, 3)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'zip')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 347, 3)) + st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'country')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 354, 3)) + st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'phoneNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1307, 5)) + st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_9, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'faxNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1314, 5)) + st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_10, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'email')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1321, 14)) + st_10 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_5, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_6, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_7, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_8, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_9, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_9, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_10, True) ])) + st_10._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerAddressType._Automaton = _BuildAutomaton_100() + + + + +profileTransOrderType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=profileTransOrderType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1430, 5))) + +profileTransOrderType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), numericString, scope=profileTransOrderType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1431, 5))) + +profileTransOrderType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId'), numericString, scope=profileTransOrderType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1432, 5))) + +profileTransOrderType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'order'), orderExType, scope=profileTransOrderType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1433, 5))) + +profileTransOrderType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'taxExempt'), pyxb.binding.datatypes.boolean, scope=profileTransOrderType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1434, 5))) + +profileTransOrderType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'recurringBilling'), pyxb.binding.datatypes.boolean, scope=profileTransOrderType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1435, 5))) + +profileTransOrderType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardCode'), cardCode, scope=profileTransOrderType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1436, 5))) + +profileTransOrderType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId'), numericString, scope=profileTransOrderType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1437, 5))) + +def _BuildAutomaton_101 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_101 + del _BuildAutomaton_101 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=30, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1432, 5)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1433, 5)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1434, 5)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1435, 5)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1436, 5)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1437, 5)) + counters.add(cc_9) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1411, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tax')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipping')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'duty')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lineItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1430, 5)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1431, 5)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1432, 5)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'order')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1433, 5)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxExempt')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1434, 5)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'recurringBilling')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1435, 5)) + st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1436, 5)) + st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_9, False)) + symbol = pyxb.binding.content.ElementUse(profileTransOrderType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1437, 5)) + st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + transitions.append(fac.Transition(st_9, [ + ])) + transitions.append(fac.Transition(st_10, [ + ])) + transitions.append(fac.Transition(st_11, [ + ])) + transitions.append(fac.Transition(st_12, [ + ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_4, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_5, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_6, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_7, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_8, False) ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_9, True) ])) + st_12._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +profileTransOrderType._Automaton = _BuildAutomaton_101() + + + + +profileTransPriorAuthCaptureType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=profileTransPriorAuthCaptureType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1461, 5))) + +profileTransPriorAuthCaptureType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), numericString, scope=profileTransPriorAuthCaptureType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1462, 5))) + +profileTransPriorAuthCaptureType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId'), numericString, scope=profileTransPriorAuthCaptureType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1463, 5))) + +profileTransPriorAuthCaptureType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transId'), numericString, scope=profileTransPriorAuthCaptureType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1464, 5))) + +def _BuildAutomaton_102 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_102 + del _BuildAutomaton_102 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=30, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1461, 5)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1462, 5)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1463, 5)) + counters.add(cc_6) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransPriorAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1411, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransPriorAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tax')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransPriorAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipping')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransPriorAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'duty')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransPriorAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lineItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransPriorAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1461, 5)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransPriorAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1462, 5)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransPriorAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1463, 5)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransPriorAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1464, 5)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_3, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_6, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + st_8._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +profileTransPriorAuthCaptureType._Automaton = _BuildAutomaton_102() + + + + +profileTransRefundType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=profileTransRefundType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1490, 5))) + +profileTransRefundType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), numericString, scope=profileTransRefundType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1491, 5))) + +profileTransRefundType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId'), numericString, scope=profileTransRefundType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1492, 5))) + +profileTransRefundType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'creditCardNumberMasked'), STD_ANON_74, scope=profileTransRefundType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1494, 5))) + +profileTransRefundType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'bankRoutingNumberMasked'), STD_ANON_75, scope=profileTransRefundType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1503, 5))) + +profileTransRefundType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'bankAccountNumberMasked'), STD_ANON_76, scope=profileTransRefundType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1512, 5))) + +profileTransRefundType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'order'), orderExType, scope=profileTransRefundType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1520, 5))) + +profileTransRefundType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transId'), numericString, scope=profileTransRefundType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1521, 5))) + +def _BuildAutomaton_103 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_103 + del _BuildAutomaton_103 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=30, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1490, 5)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1491, 5)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1492, 5)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1494, 5)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1503, 5)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1512, 5)) + counters.add(cc_9) + cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1520, 5)) + counters.add(cc_10) + cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1521, 5)) + counters.add(cc_11) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1411, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tax')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipping')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'duty')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lineItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1490, 5)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1491, 5)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1492, 5)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'creditCardNumberMasked')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1494, 5)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'bankRoutingNumberMasked')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1503, 5)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_9, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'bankAccountNumberMasked')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1512, 5)) + st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_10, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'order')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1520, 5)) + st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_11, False)) + symbol = pyxb.binding.content.ElementUse(profileTransRefundType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1521, 5)) + st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + transitions.append(fac.Transition(st_9, [ + ])) + transitions.append(fac.Transition(st_10, [ + ])) + transitions.append(fac.Transition(st_11, [ + ])) + transitions.append(fac.Transition(st_12, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_3, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_4, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_5, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_6, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_7, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_8, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_9, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_9, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_10, True) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_10, False) ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_11, True) ])) + st_12._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +profileTransRefundType._Automaton = _BuildAutomaton_103() + + + + +def _BuildAutomaton_104 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_104 + del _BuildAutomaton_104 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 59, 3)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(emailSettingsType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'setting')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 59, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +emailSettingsType._Automaton = _BuildAutomaton_104() + + + + +def _BuildAutomaton_105 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_105 + del _BuildAutomaton_105 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_20._Automaton = _BuildAutomaton_105() + + + + +def _BuildAutomaton_106 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_106 + del _BuildAutomaton_106 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_21._Automaton = _BuildAutomaton_106() + + + + +def _BuildAutomaton_107 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_107 + del _BuildAutomaton_107 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_22._Automaton = _BuildAutomaton_107() + + + + +CTD_ANON_23._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subscription'), ARBSubscriptionType, scope=CTD_ANON_23, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1992, 6))) + +def _BuildAutomaton_108 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_108 + del _BuildAutomaton_108 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subscription')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1992, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_23._Automaton = _BuildAutomaton_108() + + + + +CTD_ANON_24._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId'), numericString, scope=CTD_ANON_24, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2010, 6))) + +def _BuildAutomaton_109 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_109 + del _BuildAutomaton_109 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2010, 6)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_24._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_24._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_24._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_24._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2010, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_24._Automaton = _BuildAutomaton_109() + + + + +CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId'), numericString, scope=CTD_ANON_25, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2028, 6))) + +CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subscription'), ARBSubscriptionType, scope=CTD_ANON_25, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2029, 6))) + +def _BuildAutomaton_110 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_110 + del _BuildAutomaton_110 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2028, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subscription')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2029, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_25._Automaton = _BuildAutomaton_110() + + + + +def _BuildAutomaton_111 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_111 + del _BuildAutomaton_111 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_26._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_26._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_26._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_26._Automaton = _BuildAutomaton_111() + + + + +CTD_ANON_27._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId'), numericString, scope=CTD_ANON_27, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2061, 6))) + +def _BuildAutomaton_112 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_112 + del _BuildAutomaton_112 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_27._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_27._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_27._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2061, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_27._Automaton = _BuildAutomaton_112() + + + + +def _BuildAutomaton_113 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_113 + del _BuildAutomaton_113 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_28._Automaton = _BuildAutomaton_113() + + + + +CTD_ANON_29._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId'), numericString, scope=CTD_ANON_29, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2093, 6))) + +def _BuildAutomaton_114 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_114 + del _BuildAutomaton_114 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_29._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_29._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_29._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subscriptionId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2093, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_29._Automaton = _BuildAutomaton_114() + + + + +CTD_ANON_30._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'status'), ARBSubscriptionStatusEnum, scope=CTD_ANON_30, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2110, 6))) + +def _BuildAutomaton_115 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_115 + del _BuildAutomaton_115 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2110, 6)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_30._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_30._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_30._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_30._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'status')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2110, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_30._Automaton = _BuildAutomaton_115() + + + + +CTD_ANON_31._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profile'), customerProfileType, scope=CTD_ANON_31, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2129, 6))) + +CTD_ANON_31._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'validationMode'), validationModeEnum, scope=CTD_ANON_31, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2130, 6))) + +def _BuildAutomaton_116 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_116 + del _BuildAutomaton_116 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2130, 6)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_31._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_31._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_31._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profile')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2129, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_31._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'validationMode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2130, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_31._Automaton = _BuildAutomaton_116() + + + + +CTD_ANON_32._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_32, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2148, 6))) + +CTD_ANON_32._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileIdList'), ArrayOfNumericString, scope=CTD_ANON_32, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2149, 6))) + +CTD_ANON_32._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressIdList'), ArrayOfNumericString, scope=CTD_ANON_32, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2150, 6))) + +CTD_ANON_32._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'validationDirectResponseList'), ArrayOfString, scope=CTD_ANON_32, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2151, 6))) + +def _BuildAutomaton_117 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_117 + del _BuildAutomaton_117 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2148, 6)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2148, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileIdList')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2149, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressIdList')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2150, 6)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'validationDirectResponseList')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2151, 6)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + st_5._set_transitionSet(transitions) + transitions = [] + st_6._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_32._Automaton = _BuildAutomaton_117() + + + + +CTD_ANON_33._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_33, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2186, 6))) + +CTD_ANON_33._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile'), customerPaymentProfileType, scope=CTD_ANON_33, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2187, 6))) + +CTD_ANON_33._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'validationMode'), validationModeEnum, scope=CTD_ANON_33, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2188, 6))) + +def _BuildAutomaton_118 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_118 + del _BuildAutomaton_118 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2188, 6)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_33._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_33._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_33._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2186, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_33._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2187, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_33._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'validationMode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2188, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_33._Automaton = _BuildAutomaton_118() + + + + +CTD_ANON_34._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), numericString, scope=CTD_ANON_34, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2206, 6))) + +CTD_ANON_34._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'validationDirectResponse'), STD_ANON_88, scope=CTD_ANON_34, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2208, 6))) + +def _BuildAutomaton_119 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_119 + del _BuildAutomaton_119 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2206, 6)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2208, 6)) + counters.add(cc_3) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_34._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_34._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_34._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_34._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2206, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_34._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'validationDirectResponse')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2208, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_34._Automaton = _BuildAutomaton_119() + + + + +CTD_ANON_35._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_35, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2232, 6))) + +CTD_ANON_35._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'address'), customerAddressType, scope=CTD_ANON_35, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2233, 6))) + +def _BuildAutomaton_120 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_120 + del _BuildAutomaton_120 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_35._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_35._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_35._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2232, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_35._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'address')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2233, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_35._Automaton = _BuildAutomaton_120() + + + + +CTD_ANON_36._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId'), numericString, scope=CTD_ANON_36, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2251, 6))) + +def _BuildAutomaton_121 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_121 + del _BuildAutomaton_121 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2251, 6)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_36._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_36._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_36._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_36._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2251, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_36._Automaton = _BuildAutomaton_121() + + + + +CTD_ANON_37._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transId'), numericString, scope=CTD_ANON_37, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2268, 12))) + +def _BuildAutomaton_122 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_122 + del _BuildAutomaton_122 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_37._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_37._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_37._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2268, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_37._Automaton = _BuildAutomaton_122() + + + + +CTD_ANON_38._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_38, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2288, 12))) + +def _BuildAutomaton_123 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_123 + del _BuildAutomaton_123 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_38._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_38._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_38._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2288, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_38._Automaton = _BuildAutomaton_123() + + + + +CTD_ANON_39._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profile'), customerProfileMaskedType, scope=CTD_ANON_39, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2306, 12))) + +def _BuildAutomaton_124 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_124 + del _BuildAutomaton_124 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2306, 12)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_39._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_39._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_39._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_39._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profile')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2306, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_39._Automaton = _BuildAutomaton_124() + + + + +CTD_ANON_40._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_40, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2324, 12))) + +CTD_ANON_40._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), numericString, scope=CTD_ANON_40, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2325, 12))) + +def _BuildAutomaton_125 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_125 + del _BuildAutomaton_125 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_40._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_40._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_40._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2324, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_40._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2325, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_40._Automaton = _BuildAutomaton_125() + + + + +CTD_ANON_41._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile'), customerPaymentProfileMaskedType, scope=CTD_ANON_41, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2343, 12))) + +def _BuildAutomaton_126 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_126 + del _BuildAutomaton_126 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2343, 12)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_41._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_41._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_41._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_41._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2343, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_41._Automaton = _BuildAutomaton_126() + + + + +CTD_ANON_42._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_42, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2361, 12))) + +CTD_ANON_42._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId'), numericString, scope=CTD_ANON_42, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2362, 12))) + +def _BuildAutomaton_127 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_127 + del _BuildAutomaton_127 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_42._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_42._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_42._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2361, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_42._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2362, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_42._Automaton = _BuildAutomaton_127() + + + + +CTD_ANON_43._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'address'), customerAddressExType, scope=CTD_ANON_43, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2380, 12))) + +def _BuildAutomaton_128 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_128 + del _BuildAutomaton_128 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2380, 12)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_43._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_43._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_43._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_43._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'address')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2380, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_43._Automaton = _BuildAutomaton_128() + + + + +CTD_ANON_44._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profile'), customerProfileExType, scope=CTD_ANON_44, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2398, 12))) + +def _BuildAutomaton_129 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_129 + del _BuildAutomaton_129 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_44._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_44._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_44._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profile')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2398, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_44._Automaton = _BuildAutomaton_129() + + + + +def _BuildAutomaton_130 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_130 + del _BuildAutomaton_130 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_45._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_45._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_45._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_45._Automaton = _BuildAutomaton_130() + + + + +CTD_ANON_46._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_46, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2430, 12))) + +CTD_ANON_46._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile'), customerPaymentProfileExType, scope=CTD_ANON_46, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2431, 12))) + +CTD_ANON_46._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'validationMode'), validationModeEnum, scope=CTD_ANON_46, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2432, 12))) + +def _BuildAutomaton_131 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_131 + del _BuildAutomaton_131 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2432, 12)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_46._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_46._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_46._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2430, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_46._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentProfile')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2431, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_46._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'validationMode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2432, 12)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_46._Automaton = _BuildAutomaton_131() + + + + +CTD_ANON_47._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'validationDirectResponse'), STD_ANON_89, scope=CTD_ANON_47, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2450, 12))) + +def _BuildAutomaton_132 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_132 + del _BuildAutomaton_132 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2450, 12)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_47._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_47._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_47._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_47._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'validationDirectResponse')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2450, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_47._Automaton = _BuildAutomaton_132() + + + + +CTD_ANON_48._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_48, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2474, 12))) + +CTD_ANON_48._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'address'), customerAddressExType, scope=CTD_ANON_48, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2475, 12))) + +def _BuildAutomaton_133 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_133 + del _BuildAutomaton_133 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_48._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_48._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_48._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2474, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_48._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'address')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2475, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_48._Automaton = _BuildAutomaton_133() + + + + +def _BuildAutomaton_134 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_134 + del _BuildAutomaton_134 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_49._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_49._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_49._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_49._Automaton = _BuildAutomaton_134() + + + + +CTD_ANON_50._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_50, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2508, 12))) + +def _BuildAutomaton_135 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_135 + del _BuildAutomaton_135 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_50._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_50._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_50._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2508, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_50._Automaton = _BuildAutomaton_135() + + + + +def _BuildAutomaton_136 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_136 + del _BuildAutomaton_136 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_51._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_51._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_51._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_51._Automaton = _BuildAutomaton_136() + + + + +CTD_ANON_52._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_52, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2540, 12))) + +CTD_ANON_52._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), numericString, scope=CTD_ANON_52, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2541, 12))) + +def _BuildAutomaton_137 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_137 + del _BuildAutomaton_137 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_52._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_52._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_52._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2540, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_52._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2541, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_52._Automaton = _BuildAutomaton_137() + + + + +def _BuildAutomaton_138 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_138 + del _BuildAutomaton_138 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_53._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_53._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_53._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_53._Automaton = _BuildAutomaton_138() + + + + +CTD_ANON_54._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_54, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2573, 12))) + +CTD_ANON_54._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId'), numericString, scope=CTD_ANON_54, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2574, 12))) + +def _BuildAutomaton_139 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_139 + del _BuildAutomaton_139 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2573, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2574, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_54._Automaton = _BuildAutomaton_139() + + + + +def _BuildAutomaton_140 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_140 + del _BuildAutomaton_140 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_55._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_55._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_55._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_55._Automaton = _BuildAutomaton_140() + + + + +CTD_ANON_56._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transaction'), profileTransactionType, scope=CTD_ANON_56, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2606, 12))) + +CTD_ANON_56._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'extraOptions'), STD_ANON_90, scope=CTD_ANON_56, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2607, 12))) + +def _BuildAutomaton_141 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_141 + del _BuildAutomaton_141 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2607, 12)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_56._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_56._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_56._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transaction')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2606, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_56._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'extraOptions')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2607, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_56._Automaton = _BuildAutomaton_141() + + + + +CTD_ANON_57._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionResponse'), transactionResponse, scope=CTD_ANON_57, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2630, 48))) + +CTD_ANON_57._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'directResponse'), STD_ANON_91, scope=CTD_ANON_57, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2631, 12))) + +def _BuildAutomaton_142 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_142 + del _BuildAutomaton_142 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2630, 48)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2631, 12)) + counters.add(cc_3) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionResponse')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2630, 48)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'directResponse')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2631, 12)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_57._Automaton = _BuildAutomaton_142() + + + + +CTD_ANON_58._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_58, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2655, 12))) + +CTD_ANON_58._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), numericString, scope=CTD_ANON_58, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2656, 12))) + +CTD_ANON_58._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId'), numericString, scope=CTD_ANON_58, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2657, 12))) + +CTD_ANON_58._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cardCode'), cardCode, scope=CTD_ANON_58, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2658, 12))) + +CTD_ANON_58._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'validationMode'), validationModeEnum, scope=CTD_ANON_58, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2659, 12))) + +def _BuildAutomaton_143 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_143 + del _BuildAutomaton_143 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2657, 12)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2658, 12)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_58._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_58._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_58._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2655, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_58._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2656, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_58._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2657, 12)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_58._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2658, 12)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_58._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'validationMode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2659, 12)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + st_6._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_58._Automaton = _BuildAutomaton_143() + + + + +CTD_ANON_59._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'directResponse'), STD_ANON_92, scope=CTD_ANON_59, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2676, 12))) + +def _BuildAutomaton_144 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_144 + del _BuildAutomaton_144 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2676, 12)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_59._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_59._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_59._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_59._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'directResponse')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2676, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_59._Automaton = _BuildAutomaton_144() + + + + +def _BuildAutomaton_145 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_145 + del _BuildAutomaton_145 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_60._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_60._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_60._Automaton = _BuildAutomaton_145() + + + + +CTD_ANON_61._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ids'), ArrayOfNumericString, scope=CTD_ANON_61, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2714, 12))) + +def _BuildAutomaton_146 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_146 + del _BuildAutomaton_146 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_61._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_61._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_61._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_61._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ids')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2714, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_61._Automaton = _BuildAutomaton_146() + + + + +CTD_ANON_62._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId'), pyxb.binding.datatypes.string, scope=CTD_ANON_62, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2731, 12))) + +CTD_ANON_62._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'splitTenderStatus'), splitTenderStatusEnum, scope=CTD_ANON_62, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2732, 12))) + +def _BuildAutomaton_147 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_147 + del _BuildAutomaton_147 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_62._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_62._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_62._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2731, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_62._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderStatus')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2732, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_62._Automaton = _BuildAutomaton_147() + + + + +def _BuildAutomaton_148 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_148 + del _BuildAutomaton_148 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_63._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_63._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_63._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_63._Automaton = _BuildAutomaton_148() + + + + +CTD_ANON_64._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transId'), numericString, scope=CTD_ANON_64, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2763, 12))) + +def _BuildAutomaton_149 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_149 + del _BuildAutomaton_149 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_64._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_64._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_64._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2763, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_64._Automaton = _BuildAutomaton_149() + + + + +CTD_ANON_65._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transaction'), transactionDetailsType, scope=CTD_ANON_65, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2780, 6))) + +def _BuildAutomaton_150 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_150 + del _BuildAutomaton_150 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_65._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_65._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_65._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_65._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transaction')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2780, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_65._Automaton = _BuildAutomaton_150() + + + + +CTD_ANON_66._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionRequest'), transactionRequestType, scope=CTD_ANON_66, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2798, 6))) + +def _BuildAutomaton_151 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_151 + del _BuildAutomaton_151 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_66._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_66._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_66._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionRequest')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2798, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_66._Automaton = _BuildAutomaton_151() + + + + +CTD_ANON_67._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactionResponse'), transactionResponse, scope=CTD_ANON_67, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2816, 6))) + +CTD_ANON_67._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'profileResponse'), createProfileResponse, scope=CTD_ANON_67, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2817, 12))) + +def _BuildAutomaton_152 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_152 + del _BuildAutomaton_152 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2817, 12)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_67._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_67._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_67._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_67._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactionResponse')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2816, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_67._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'profileResponse')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2817, 12)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_67._Automaton = _BuildAutomaton_152() + + + + +CTD_ANON_68._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'batchId'), numericString, scope=CTD_ANON_68, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2834, 6))) + +def _BuildAutomaton_153 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_153 + del _BuildAutomaton_153 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_68._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_68._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_68._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'batchId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2834, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_68._Automaton = _BuildAutomaton_153() + + + + +CTD_ANON_69._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'batch'), batchDetailsType, scope=CTD_ANON_69, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2851, 6))) + +def _BuildAutomaton_154 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_154 + del _BuildAutomaton_154 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2851, 6)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_69._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_69._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_69._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_69._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'batch')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2851, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_69._Automaton = _BuildAutomaton_154() + + + + +CTD_ANON_70._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'includeStatistics'), pyxb.binding.datatypes.boolean, scope=CTD_ANON_70, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2868, 6))) + +CTD_ANON_70._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'firstSettlementDate'), pyxb.binding.datatypes.dateTime, scope=CTD_ANON_70, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2869, 6))) + +CTD_ANON_70._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'lastSettlementDate'), pyxb.binding.datatypes.dateTime, scope=CTD_ANON_70, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2870, 6))) + +def _BuildAutomaton_155 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_155 + del _BuildAutomaton_155 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2868, 6)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2869, 6)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2870, 6)) + counters.add(cc_3) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_70._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_70._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_70._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'includeStatistics')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2868, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_70._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'firstSettlementDate')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2869, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_70._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lastSettlementDate')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2870, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_70._Automaton = _BuildAutomaton_155() + + + + +CTD_ANON_71._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'batchList'), ArrayOfBatchDetailsType, scope=CTD_ANON_71, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2887, 6))) + +def _BuildAutomaton_156 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_156 + del _BuildAutomaton_156 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2887, 6)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_71._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_71._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_71._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_71._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'batchList')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2887, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_71._Automaton = _BuildAutomaton_156() + + + + +CTD_ANON_72._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'batchId'), numericString, scope=CTD_ANON_72, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2904, 6))) + +def _BuildAutomaton_157 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_157 + del _BuildAutomaton_157 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2904, 6)) + counters.add(cc_1) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_72._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_72._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_72._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'batchId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2904, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_72._Automaton = _BuildAutomaton_157() + + + + +CTD_ANON_73._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactions'), ArrayOfTransactionSummaryType, scope=CTD_ANON_73, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2921, 6))) + +def _BuildAutomaton_158 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_158 + del _BuildAutomaton_158 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2921, 6)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_73._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_73._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_73._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_73._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactions')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2921, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_73._Automaton = _BuildAutomaton_158() + + + + +CTD_ANON_74._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), numericString, scope=CTD_ANON_74, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2939, 6))) + +CTD_ANON_74._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'hostedProfileSettings'), ArrayOfSetting, scope=CTD_ANON_74, documentation='Allowed values for settingName are: hostedProfileReturnUrl, hostedProfileReturnUrlText, hostedProfilePageBorderVisible, hostedProfileIFrameCommunicatorUrl, hostedProfileHeadingBgColor, hostedProfileBillingAddressRequired, hostedProfileCardCodeRequired.', location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2940, 6))) + +def _BuildAutomaton_159 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_159 + del _BuildAutomaton_159 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2940, 6)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_74._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_74._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_74._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2939, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_74._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'hostedProfileSettings')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2940, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_74._Automaton = _BuildAutomaton_159() + + + + +CTD_ANON_75._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'token'), pyxb.binding.datatypes.string, scope=CTD_ANON_75, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2961, 6))) + +def _BuildAutomaton_160 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_160 + del _BuildAutomaton_160 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_75._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_75._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_75._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_75._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'token')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2961, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_75._Automaton = _BuildAutomaton_160() + + + + +def _BuildAutomaton_161 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_161 + del _BuildAutomaton_161 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_76._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_76._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_76._Automaton = _BuildAutomaton_161() + + + + +CTD_ANON_77._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transactions'), ArrayOfTransactionSummaryType, scope=CTD_ANON_77, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2992, 6))) + +def _BuildAutomaton_162 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_162 + del _BuildAutomaton_162 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2992, 6)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_77._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_77._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_77._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_77._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transactions')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 2992, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_77._Automaton = _BuildAutomaton_162() + + + + +CTD_ANON_78._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'mobileDevice'), mobileDeviceType, scope=CTD_ANON_78, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3010, 6))) + +def _BuildAutomaton_163 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_163 + del _BuildAutomaton_163 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_78._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_78._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_78._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'mobileDevice')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3010, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_78._Automaton = _BuildAutomaton_163() + + + + +def _BuildAutomaton_164 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_164 + del _BuildAutomaton_164 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_79._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_79._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_79._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_79._Automaton = _BuildAutomaton_164() + + + + +def _BuildAutomaton_165 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_165 + del _BuildAutomaton_165 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_80._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_80._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_80._Automaton = _BuildAutomaton_165() + + + + +CTD_ANON_81._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantContact'), merchantContactType, scope=CTD_ANON_81, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3053, 6))) + +CTD_ANON_81._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'userPermissions'), ArrayOfPermissionType, scope=CTD_ANON_81, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3054, 6))) + +CTD_ANON_81._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'merchantAccount'), transRetailInfoType, scope=CTD_ANON_81, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3055, 24))) + +def _BuildAutomaton_166 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_166 + del _BuildAutomaton_166 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3055, 24)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantContact')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3053, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'userPermissions')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3054, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAccount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3055, 24)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, True) ])) + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_81._Automaton = _BuildAutomaton_166() + + + + +def _BuildAutomaton_167 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_167 + del _BuildAutomaton_167 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_82._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_82._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_82._Automaton = _BuildAutomaton_167() + + + + +def _BuildAutomaton_168 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_168 + del _BuildAutomaton_168 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_83._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_83._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_83._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_83._Automaton = _BuildAutomaton_168() + + + + +CTD_ANON_84._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'transId'), numericString, scope=CTD_ANON_84, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3098, 6))) + +CTD_ANON_84._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerEmail'), pyxb.binding.datatypes.string, scope=CTD_ANON_84, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3099, 6))) + +CTD_ANON_84._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'emailSettings'), emailSettingsType, scope=CTD_ANON_84, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3100, 6))) + +def _BuildAutomaton_169 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_169 + del _BuildAutomaton_169 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3100, 6)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'transId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3098, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerEmail')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3099, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'emailSettings')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3100, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_84._Automaton = _BuildAutomaton_169() + + + + +def _BuildAutomaton_170 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_170 + del _BuildAutomaton_170 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_85._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_85._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_85._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_85._Automaton = _BuildAutomaton_170() + + + + +CTD_ANON_86._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'searchType'), ARBGetSubscriptionListSearchTypeEnum, scope=CTD_ANON_86, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3175, 6))) + +CTD_ANON_86._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'sorting'), ARBGetSubscriptionListSorting, scope=CTD_ANON_86, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3176, 6))) + +CTD_ANON_86._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paging'), Paging, scope=CTD_ANON_86, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3177, 6))) + +def _BuildAutomaton_171 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_171 + del _BuildAutomaton_171 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3176, 6)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3177, 6)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantAuthentication')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1830, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1831, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'searchType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3175, 6)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sorting')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3176, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paging')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3177, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_86._Automaton = _BuildAutomaton_171() + + + + +CTD_ANON_87._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'totalNumInResultSet'), pyxb.binding.datatypes.int, scope=CTD_ANON_87, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3235, 6))) + +CTD_ANON_87._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'subscriptionDetails'), ArrayOfSubscription, scope=CTD_ANON_87, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3236, 6))) + +def _BuildAutomaton_172 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_172 + del _BuildAutomaton_172 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3235, 6)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3236, 6)) + counters.add(cc_3) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(CTD_ANON_87._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'refId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1899, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_87._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'messages')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1901, 4)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_87._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'sessionToken')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1903, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_87._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'totalNumInResultSet')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3235, 6)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_87._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'subscriptionDetails')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3236, 6)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +CTD_ANON_87._Automaton = _BuildAutomaton_172() + + + + +customerProfileSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId'), pyxb.binding.datatypes.string, scope=customerProfileSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3288, 20))) + +customerProfileSummaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'description'), pyxb.binding.datatypes.string, scope=customerProfileSummaryType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3289, 20))) + +def _BuildAutomaton_173 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_173 + del _BuildAutomaton_173 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3280, 12)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3288, 20)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3289, 20)) + counters.add(cc_2) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(customerProfileSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantCustomerId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3279, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'email')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3280, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3288, 20)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileSummaryType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 3289, 20)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +customerProfileSummaryType._Automaton = _BuildAutomaton_173() + + + + +customerPaymentProfileExType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId'), numericString, scope=customerPaymentProfileExType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1220, 5))) + +def _BuildAutomaton_174 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_174 + del _BuildAutomaton_174 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1191, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1192, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1200, 5)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1201, 5)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1203, 5)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1220, 5)) + counters.add(cc_5) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerType')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1191, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'billTo')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1192, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'payment')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1200, 5)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'driversLicense')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1201, 5)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1203, 5)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(customerPaymentProfileExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1220, 5)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerPaymentProfileExType._Automaton = _BuildAutomaton_174() + + + + +customerProfileMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'paymentProfiles'), customerPaymentProfileMaskedType, scope=customerProfileMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1296, 5))) + +customerProfileMaskedType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'shipToList'), customerAddressExType, scope=customerProfileMaskedType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1297, 5))) + +def _BuildAutomaton_175 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_175 + del _BuildAutomaton_175 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1247, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1254, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1261, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1286, 5)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1296, 5)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1297, 5)) + counters.add(cc_5) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'merchantCustomerId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1247, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1254, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'email')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1261, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1286, 5)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'paymentProfiles')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1296, 5)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(customerProfileMaskedType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipToList')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1297, 5)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerProfileMaskedType._Automaton = _BuildAutomaton_175() + + + + +customerAddressExType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId'), numericString, scope=customerAddressExType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1331, 5))) + +def _BuildAutomaton_176 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_176 + del _BuildAutomaton_176 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 305, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 312, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 319, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 326, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 333, 3)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 340, 3)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 347, 3)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 354, 3)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1307, 5)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1314, 5)) + counters.add(cc_9) + cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1321, 14)) + counters.add(cc_10) + cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1331, 5)) + counters.add(cc_11) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'firstName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 305, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lastName')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 312, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'company')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 319, 3)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'address')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 326, 3)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'city')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 333, 3)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'state')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 340, 3)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'zip')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 347, 3)) + st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'country')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 354, 3)) + st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'phoneNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1307, 5)) + st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_9, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'faxNumber')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1314, 5)) + st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_10, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'email')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1321, 14)) + st_10 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_11, False)) + symbol = pyxb.binding.content.ElementUse(customerAddressExType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1331, 5)) + st_11 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_1, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_2, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_3, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_4, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_5, False) ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_6, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_7, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_8, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_9, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_9, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_9, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_10, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_10, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_11, True) ])) + st_11._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +customerAddressExType._Automaton = _BuildAutomaton_176() + + + + +def _BuildAutomaton_177 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_177 + del _BuildAutomaton_177 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=30, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1432, 5)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1433, 5)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1434, 5)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1435, 5)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1436, 5)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1437, 5)) + counters.add(cc_9) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1411, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tax')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipping')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'duty')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lineItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1430, 5)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1431, 5)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1432, 5)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'order')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1433, 5)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxExempt')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1434, 5)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'recurringBilling')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1435, 5)) + st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1436, 5)) + st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_9, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthCaptureType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1437, 5)) + st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + transitions.append(fac.Transition(st_9, [ + ])) + transitions.append(fac.Transition(st_10, [ + ])) + transitions.append(fac.Transition(st_11, [ + ])) + transitions.append(fac.Transition(st_12, [ + ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_4, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_5, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_6, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_7, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_8, False) ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_9, True) ])) + st_12._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +profileTransAuthCaptureType._Automaton = _BuildAutomaton_177() + + + + +def _BuildAutomaton_178 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_178 + del _BuildAutomaton_178 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=30, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1432, 5)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1433, 5)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1434, 5)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1435, 5)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1436, 5)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1437, 5)) + counters.add(cc_9) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1411, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tax')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipping')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'duty')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lineItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1430, 5)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1431, 5)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1432, 5)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'order')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1433, 5)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxExempt')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1434, 5)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'recurringBilling')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1435, 5)) + st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_8, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1436, 5)) + st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_9, False)) + symbol = pyxb.binding.content.ElementUse(profileTransAuthOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1437, 5)) + st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + transitions.append(fac.Transition(st_9, [ + ])) + transitions.append(fac.Transition(st_10, [ + ])) + transitions.append(fac.Transition(st_11, [ + ])) + transitions.append(fac.Transition(st_12, [ + ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_4, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_5, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_6, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_7, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_8, False) ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_9, True) ])) + st_12._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +profileTransAuthOnlyType._Automaton = _BuildAutomaton_178() + + + + +profileTransCaptureOnlyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'approvalCode'), STD_ANON_73, scope=profileTransCaptureOnlyType, location=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1474, 5))) + +def _BuildAutomaton_179 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_179 + del _BuildAutomaton_179 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=30, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1432, 5)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1433, 5)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1434, 5)) + counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1435, 5)) + counters.add(cc_7) + cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1436, 5)) + counters.add(cc_8) + cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1437, 5)) + counters.add(cc_9) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'amount')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1411, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tax')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1419, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'shipping')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1420, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'duty')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1421, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'lineItems')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1422, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1430, 5)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerPaymentProfileId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1431, 5)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'customerShippingAddressId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1432, 5)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'order')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1433, 5)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'taxExempt')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1434, 5)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'recurringBilling')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1435, 5)) + st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_10) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cardCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1436, 5)) + st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_11) + final_update = None + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'splitTenderId')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1437, 5)) + st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_12) + final_update = set() + symbol = pyxb.binding.content.ElementUse(profileTransCaptureOnlyType._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'approvalCode')), pyxb.utils.utility.Location('https://api.authorize.net/xml/v1/schema/AnetApiSchema.xsd', 1474, 5)) + st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_13) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_1, False) ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_2, True) ])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False) ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_3, True) ])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, False) ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + transitions.append(fac.Transition(st_9, [ + ])) + transitions.append(fac.Transition(st_10, [ + ])) + transitions.append(fac.Transition(st_11, [ + ])) + transitions.append(fac.Transition(st_12, [ + ])) + transitions.append(fac.Transition(st_13, [ + ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, True) ])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_4, False) ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_5, False) ])) + st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_6, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_6, False) ])) + st_9._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_10, [ + fac.UpdateInstruction(cc_7, True) ])) + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_7, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_7, False) ])) + st_10._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_11, [ + fac.UpdateInstruction(cc_8, True) ])) + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_8, False) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_8, False) ])) + st_11._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_12, [ + fac.UpdateInstruction(cc_9, True) ])) + transitions.append(fac.Transition(st_13, [ + fac.UpdateInstruction(cc_9, False) ])) + st_12._set_transitionSet(transitions) + transitions = [] + st_13._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +profileTransCaptureOnlyType._Automaton = _BuildAutomaton_179() + diff --git a/src/controller/ARBCancelSubscriptionController.py b/src/controller/ARBCancelSubscriptionController.py new file mode 100644 index 0000000..3971f85 --- /dev/null +++ b/src/controller/ARBCancelSubscriptionController.py @@ -0,0 +1,20 @@ +''' +Created on Jun 9, 2015 + +@author: egodolja +''' +from controller import ARBOperationBase +from contract import binding + +class ARBCancelSubscriptionController(ARBOperationBase.ARBOperationBase): + + def ARBCancelSubscriptionController(self, requestObject): + if not requestObject.subscriptionId: + return 'SubscriptionId Cannot be Null' + + request = super(ARBCancelSubscriptionController, self).buildRequest('ARBCancelSubscriptionRequest', requestObject) + + return request + + def getResponseClass(self): + return binding.ARBCancelSubscriptionResponse() \ No newline at end of file diff --git a/src/controller/ARBCreateSubscriptionController.py b/src/controller/ARBCreateSubscriptionController.py new file mode 100644 index 0000000..e2c5074 --- /dev/null +++ b/src/controller/ARBCreateSubscriptionController.py @@ -0,0 +1,21 @@ +''' +Created on Jun 9, 2015 + +@author: egodolja +''' +from controller import ARBOperationBase +from contract import binding + +class ARBCreateSubscriptionController(ARBOperationBase.ARBOperationBase): + + def ARBCreateSubscriptionController(self, requestObject): + if not requestObject.subscription: + return 'Subscription Cannot be Null' + + request = super(ARBCreateSubscriptionController, self).buildRequest('ARBCreateSubscriptionRequest', requestObject) + + return request + + def getResponseClass(self): + return binding.ARBCreateSubscriptionResponse() + diff --git a/src/controller/ARBGetSubscriptionListController.py b/src/controller/ARBGetSubscriptionListController.py new file mode 100644 index 0000000..c2bc8c5 --- /dev/null +++ b/src/controller/ARBGetSubscriptionListController.py @@ -0,0 +1,23 @@ +''' +Created on Jun 22, 2015 + +@author: egodolja +''' + +from controller import ARBOperationBase +from contract import binding + +class ARBGetSubscriptionListController(ARBOperationBase.ARBOperationBase): + + def ARBGetSubscriptionListController(self, requestObject): + if not requestObject.searchType : + return "searchType Cannot be Null" + if not requestObject.paging : + return "paging Cannot be Null" + + request = super(ARBGetSubscriptionListController, self).buildRequest('ARBGetSubscriptionListRequest', requestObject) + + return request + + def getResponseClass(self): + return binding.ARBGetSubscriptionListResponse() \ No newline at end of file diff --git a/src/controller/ARBGetSubscriptionStatusController.py b/src/controller/ARBGetSubscriptionStatusController.py new file mode 100644 index 0000000..f6b8787 --- /dev/null +++ b/src/controller/ARBGetSubscriptionStatusController.py @@ -0,0 +1,20 @@ +''' +Created on Jun 9, 2015 + +@author: egodolja +''' +from controller import ARBOperationBase +from contract import binding + +class ARBGetSubscriptionStatusController(ARBOperationBase.ARBOperationBase): + + def ARBGetSubscriptionStatusController(self, requestObject): + if not requestObject.subscriptionId: + return 'SubscriptionId cannot be null' + + request = super(ARBGetSubscriptionStatusController, self).buildRequest('ARBGetSubscriptionStatusRequest', requestObject) + + return request + + def getResponseClass(self): + return binding.ARBGetSubscriptionStatusResponse() diff --git a/src/controller/ARBOperationBase.py b/src/controller/ARBOperationBase.py new file mode 100644 index 0000000..87d36be --- /dev/null +++ b/src/controller/ARBOperationBase.py @@ -0,0 +1,58 @@ +''' +Created on Jun 1, 2015 + +@author: egodolja +''' +from contract import binding + +from pip._vendor import requests +from constants import * + +import logging +import xml.dom.minidom + + +class ARBOperationBase(object): + logging.basicConfig(filename='logFile.log', level=logging.DEBUG, format='%(asctime)s %(message)s') + + + def buildRequest(self, requestType, requestObject): + logging.debug('building request..') + request = requestObject.toxml(encoding=constants.xml_encoding, element_name=requestType) + + #remove namespaces that toxml() generates + request = request.replace(constants.nsNamespace1, '') + request = request.replace(constants.nsNamespace2, '') + + xml_str = xml.dom.minidom.parseString(request) + logging.debug('request is: %s' % xml_str.toprettyxml()) + return request + + + def execute(self, request, responseClass): + logging.debug('fetching response...') + global response + response = requests.post(constants.SANDBOX_TESTMODE, data=request, headers=constants.headers, proxies=constants.proxyDictionary) + + #encoding of response should be changed to retrieve text of response + response.encoding = constants.response_encoding + if response: + + response = response.text[3:] + if constants.StatusStart in response: + response = response.replace(constants.note, '') + response = self.afterExecuteStatus(response) + + order = binding.CreateFromDocument(response) + + if type(order) == type(responseClass): + xml_str = xml.dom.minidom.parseString(response) + logging.debug('Received the following response: %s' % xml_str.toprettyxml()) + else: + logging.debug('There was an error: %s' % request) + + def afterExecuteStatus(self, response): + start = response.index(constants.StatusStart) + end = response.index(constants.StatusEnd) + response = response.replace(response[start:end+9], '') + return response \ No newline at end of file diff --git a/src/controller/__init__.py b/src/controller/__init__.py new file mode 100644 index 0000000..e4413eb --- /dev/null +++ b/src/controller/__init__.py @@ -0,0 +1 @@ +from controller import ARBCancelSubscriptionController \ No newline at end of file diff --git a/src/controller/constants.py b/src/controller/constants.py new file mode 100644 index 0000000..5e99895 --- /dev/null +++ b/src/controller/constants.py @@ -0,0 +1,38 @@ +''' +Created on Jun 8, 2015 + +@author: egodolja +''' +class constants(object): + CONST_API_LOGIN_ID = '7uSHkqw7k88' + CONST_TRANSACTION_KEY = '4k2vP25FC59zA8WG' + CONST_REFID = 'Sample' + + '''Environments''' + SANDBOX_TESTMODE = 'https://apitest.authorize.net/xml/v1/request.api' + PRODUCTION = 'https://api.authorize.net/xml/v1/request.api' + + '''xml headers''' + headers = {'Content-Type' : 'application/xml', 'version' : '1.0', 'encoding' : 'utf-8'} + + '''proxy configuration''' + proxyDictionary = {'http' : 'internet.visa.com', 'https' : 'internet.visa.com', 'ftp' : 'internet.visa.com'} + + '''ARBGetSubscriptionStatus tag''' + StatusStart = '' + StatusEnd = '' + + '''xml encoding''' + xml_encoding = 'utf-8' + + '''response encoding''' + response_encoding = 'ISO-8859-1' + + '''note section of subscription status response''' + note = ' note="Status with a capital \'S\' is obsolete."' + + '''ns namespace 1''' + nsNamespace1 = 'ns1:' + + '''ns namespace 2''' + nsNamespace2 = ':ns1' \ No newline at end of file diff --git a/src/script/__init__.py b/src/script/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/script/generateObjectsFromXSD.bat b/src/script/generateObjectsFromXSD.bat new file mode 100644 index 0000000..f1fc538 --- /dev/null +++ b/src/script/generateObjectsFromXSD.bat @@ -0,0 +1,13 @@ +@echo off +rem first script +echo current folder.. +dir +echo going into pyxb folder.. +cd PyxB-1.2.4 +echo running pyxbgen on %DATE%-%TIME% +echo what is %TEMP% +set xsd=https://apitest.authorize.net/xml/v1/schema/AnetApiSchema.xsd +rem !!Must have python already installed!! +python pyxbgen -u %xsd% -m bind +echo file is generated +Pause diff --git a/src/tests/ARBCancelSubscriptionTest.py b/src/tests/ARBCancelSubscriptionTest.py new file mode 100644 index 0000000..26ade46 --- /dev/null +++ b/src/tests/ARBCancelSubscriptionTest.py @@ -0,0 +1,22 @@ +''' +Created on Jun 15, 2015 + +@author: egodolja +''' +from contract import binding +from controller.constants import * +from controller.ARBCancelSubscriptionController import ARBCancelSubscriptionController + + +class ARBCancelSubscriptionTest(object): + merchantAuthentication = binding.merchantAuthenticationType() + merchantAuthentication.name = constants.CONST_API_LOGIN_ID + merchantAuthentication.transactionKey = constants.CONST_TRANSACTION_KEY + cancelSubscriptionRequest = binding.ARBCancelSubscriptionRequest() + cancelSubscriptionRequest.merchantAuthentication = merchantAuthentication + cancelSubscriptionRequest.refId = 'Sample' + cancelSubscriptionRequest.subscriptionId = '2582968' + + ARBCancelSubscriptionController = ARBCancelSubscriptionController() + request = ARBCancelSubscriptionController.ARBCancelSubscriptionController(cancelSubscriptionRequest) + ARBCancelSubscriptionController.execute(request, ARBCancelSubscriptionController.getResponseClass()) \ No newline at end of file diff --git a/src/tests/ARBCreateSubscriptionTest.py b/src/tests/ARBCreateSubscriptionTest.py new file mode 100644 index 0000000..3e5b365 --- /dev/null +++ b/src/tests/ARBCreateSubscriptionTest.py @@ -0,0 +1,39 @@ +''' +Created on Jun 16, 2015 + +@author: egodolja +''' +from contract import binding +from controller.constants import * +from controller.ARBCreateSubscriptionController import ARBCreateSubscriptionController +from contract.binding import CTD_ANON +import datetime + +class ARBCreateSubscriptionTest(object): + merchantAuthentication = binding.merchantAuthenticationType() + merchantAuthentication.name = constants.CONST_API_LOGIN_ID + merchantAuthentication.transactionKey = constants.CONST_TRANSACTION_KEY + + dateOne = datetime.date(2020, 8, 30) + interval = CTD_ANON() + interval.length = 1 + interval.unit = 'months' + paymentSchedule = binding.paymentScheduleType() + paymentSchedule.interval = interval + paymentSchedule.startDate = dateOne + paymentSchedule.totalOccurrences = 12 + paymentSchedule.trialOccurrences = 1 + + subscription = binding.ARBSubscriptionType() + subscription.paymentSchedule = paymentSchedule + + createSubscriptionRequest = binding.ARBCreateSubscriptionRequest() + createSubscriptionRequest.merchantAuthentication = merchantAuthentication + createSubscriptionRequest.refId = constants.CONST_REFID + createSubscriptionRequest.subscription = subscription + + ARBCreateSubscriptionController = ARBCreateSubscriptionController() + request = ARBCreateSubscriptionController.ARBCreateSubscriptionController(createSubscriptionRequest) + ARBCreateSubscriptionController.execute(request, ARBCreateSubscriptionController.getResponseClass()) + + \ No newline at end of file diff --git a/src/tests/ARBGetSubscriptionStatusTest.py b/src/tests/ARBGetSubscriptionStatusTest.py new file mode 100644 index 0000000..9d55caa --- /dev/null +++ b/src/tests/ARBGetSubscriptionStatusTest.py @@ -0,0 +1,24 @@ +''' +Created on Jun 15, 2015 + +@author: egodolja +''' +from contract import binding +from controller.constants import * +from controller.ARBGetSubscriptionStatusController import ARBGetSubscriptionStatusController + +class ARBGetSubscriptionStatusTest(object): + merchantAuthentication = binding.merchantAuthenticationType() + merchantAuthentication.name = constants.CONST_API_LOGIN_ID + merchantAuthentication.transactionKey = constants.CONST_TRANSACTION_KEY + + getSubscriptionStatusRequest = binding.ARBGetSubscriptionStatusRequest() + getSubscriptionStatusRequest.merchantAuthentication = merchantAuthentication + getSubscriptionStatusRequest.refId = 'Sample' + getSubscriptionStatusRequest.subscriptionId = '2580111' + + + ARBGetSubscriptionStatusController = ARBGetSubscriptionStatusController() + request = ARBGetSubscriptionStatusController.ARBGetSubscriptionStatusController(getSubscriptionStatusRequest) + ARBGetSubscriptionStatusController.execute(request, binding.ARBGetSubscriptionStatusResponse()) + \ No newline at end of file diff --git a/src/tests/__init__.py b/src/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/tests/demoTest.py b/src/tests/demoTest.py new file mode 100644 index 0000000..4aeae40 --- /dev/null +++ b/src/tests/demoTest.py @@ -0,0 +1,118 @@ +''' +Created on Jun 22, 2015 + +@author: egodolja +''' +from contract import binding +from controller.constants import * +from contract.binding import CTD_ANON +from controller.ARBCreateSubscriptionController import ARBCreateSubscriptionController +from controller.ARBGetSubscriptionStatusController import ARBGetSubscriptionStatusController +from controller.ARBCancelSubscriptionController import ARBCancelSubscriptionController +from decimal import * +import datetime + +''' +1. Create a subscription +2. Get status of that subscription +3. Cancel subscription +4. Get status of cancelled subscription +''' +class demoTest(): + '''1. Create a subscription + - create a createSubscription request object + - create a createSubscripiton controller + - build request + - execute request + - get subscriptionId from response to use in the following tests + ''' + merchantAuthentication = binding.merchantAuthenticationType() + merchantAuthentication.name = constants.CONST_API_LOGIN_ID + merchantAuthentication.transactionKey = constants.CONST_TRANSACTION_KEY + + dateOne = datetime.date(2020, 8, 30) + interval = CTD_ANON() + interval.length = 1 + interval.unit = 'months' + paymentSchedule = binding.paymentScheduleType() + paymentSchedule.interval = interval + paymentSchedule.startDate = dateOne + paymentSchedule.totalOccurrences = 12 + paymentSchedule.trialOccurrences = 1 + + creditCardOne = binding.creditCardType() + creditCardOne.cardNumber = '4111111111111111' + creditCardOne.expirationDate = '2020-12' + + payment = binding.paymentType() + payment.creditCard = creditCardOne + + customerOne = binding.nameAndAddressType() + customerOne.firstName = 'John' + customerOne.lastName = 'Smith' + + subscription = binding.ARBSubscriptionType() + subscription.paymentSchedule = paymentSchedule + subscription.amount = Decimal('23.45') + subscription.trialAmount = Decimal('0.01') + subscription.payment = payment + subscription.billTo = customerOne + + createSubscriptionRequest = binding.ARBCreateSubscriptionRequest() + createSubscriptionRequest.merchantAuthentication = merchantAuthentication + createSubscriptionRequest.refId = constants.CONST_REFID + createSubscriptionRequest.subscription = subscription + + ARBCreateSubscriptionController = ARBCreateSubscriptionController() + createRequest = ARBCreateSubscriptionController.ARBCreateSubscriptionController(createSubscriptionRequest) + ARBCreateSubscriptionController.execute(createRequest, ARBCreateSubscriptionController.getResponseClass()) + subscriptionId = ARBCreateSubscriptionController.getSubscriptionIdFromResponse() + + '''2. Get subscription status + - create a getSubscriptionStatus request object + - use the subscriptionId from create subscription + - create a getSubscriptionStatus controller + - build request + - execute request''' + getSubscriptionStatusRequest = binding.ARBGetSubscriptionStatusRequest() + getSubscriptionStatusRequest.merchantAuthentication = merchantAuthentication + getSubscriptionStatusRequest.refId = constants.CONST_REFID + getSubscriptionStatusRequest.subscriptionId = subscriptionId + + ARBGetSubscriptionStatusController = ARBGetSubscriptionStatusController() + statusRequest = ARBGetSubscriptionStatusController.ARBGetSubscriptionStatusController(getSubscriptionStatusRequest) + ARBGetSubscriptionStatusController.execute(statusRequest, ARBGetSubscriptionStatusController.getResponseClass()) + + '''3. Cancel subscription + - create a cancelSubscription request object + - use the subscriptionId from create subscription + - create a cancelSubscription controller + - build request + - execute request + ''' + cancelSubscriptionRequest = binding.ARBCancelSubscriptionRequest() + cancelSubscriptionRequest.merchantAuthentication = merchantAuthentication + cancelSubscriptionRequest.refId = constants.CONST_REFID + cancelSubscriptionRequest.subscriptionId = subscriptionId + + ARBCancelSubscriptionController = ARBCancelSubscriptionController() + cancelRequest = ARBCancelSubscriptionController.ARBCancelSubscriptionController(cancelSubscriptionRequest) + ARBCancelSubscriptionController.execute(cancelRequest, ARBCancelSubscriptionController.getResponseClass()) + + '''4. Get subscription status + - execute getSubscriptionStatus request from previously created request object + ''' + ARBGetSubscriptionStatusController.execute(statusRequest, ARBGetSubscriptionStatusController.getResponseClass()) + + + +'''helper function to be added to ARBOperationBase for demoTest + def getSubscriptionIdFromResponse(self,): + order = binding.CreateFromDocument(response) + return order.subscriptionId +''' + + + + + \ No newline at end of file