public LatLonOptions unmarshall(StaxUnmarshallerContext context) throws Exception {
    LatLonOptions latLonOptions = new LatLonOptions();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return latLonOptions;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("DefaultValue", targetDepth)) {
          latLonOptions.setDefaultValue(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("SourceField", targetDepth)) {
          latLonOptions.setSourceField(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("FacetEnabled", targetDepth)) {
          latLonOptions.setFacetEnabled(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("SearchEnabled", targetDepth)) {
          latLonOptions.setSearchEnabled(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("ReturnEnabled", targetDepth)) {
          latLonOptions.setReturnEnabled(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("SortEnabled", targetDepth)) {
          latLonOptions.setSortEnabled(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return latLonOptions;
        }
      }
    }
  }
  public LoginProfile unmarshall(StaxUnmarshallerContext context) throws Exception {
    LoginProfile loginProfile = new LoginProfile();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return loginProfile;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("UserName", targetDepth)) {
          loginProfile.setUserName(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("CreateDate", targetDepth)) {
          loginProfile.setCreateDate(DateStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("PasswordResetRequired", targetDepth)) {
          loginProfile.setPasswordResetRequired(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return loginProfile;
        }
      }
    }
  }
  public EnableVpcClassicLinkDnsSupportResult unmarshall(StaxUnmarshallerContext context)
      throws Exception {
    EnableVpcClassicLinkDnsSupportResult enableVpcClassicLinkDnsSupportResult =
        new EnableVpcClassicLinkDnsSupportResult();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return enableVpcClassicLinkDnsSupportResult;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("return", targetDepth)) {
          enableVpcClassicLinkDnsSupportResult.setReturn(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return enableVpcClassicLinkDnsSupportResult;
        }
      }
    }
  }
  public ListUsersResult unmarshall(StaxUnmarshallerContext context) throws Exception {
    ListUsersResult listUsersResult = new ListUsersResult();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 2;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return listUsersResult;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("Users/member", targetDepth)) {
          listUsersResult.getUsers().add(UserStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("IsTruncated", targetDepth)) {
          listUsersResult.setIsTruncated(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("Marker", targetDepth)) {
          listUsersResult.setMarker(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return listUsersResult;
        }
      }
    }
  }
  public AvailabilityOptionsStatus unmarshall(StaxUnmarshallerContext context) throws Exception {
    AvailabilityOptionsStatus availabilityOptionsStatus = new AvailabilityOptionsStatus();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 2;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return availabilityOptionsStatus;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {
        if (context.testExpression("Options", targetDepth)) {
          availabilityOptionsStatus.setOptions(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Status", targetDepth)) {
          availabilityOptionsStatus.setStatus(
              OptionStatusStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return availabilityOptionsStatus;
        }
      }
    }
  }
  public InstanceNetworkInterfaceAttachment unmarshall(StaxUnmarshallerContext context)
      throws Exception {
    InstanceNetworkInterfaceAttachment instanceNetworkInterfaceAttachment =
        new InstanceNetworkInterfaceAttachment();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return instanceNetworkInterfaceAttachment;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("attachmentId", targetDepth)) {
          instanceNetworkInterfaceAttachment.setAttachmentId(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("deviceIndex", targetDepth)) {
          instanceNetworkInterfaceAttachment.setDeviceIndex(
              IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("status", targetDepth)) {
          instanceNetworkInterfaceAttachment.setStatus(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("attachTime", targetDepth)) {
          instanceNetworkInterfaceAttachment.setAttachTime(
              DateStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("deleteOnTermination", targetDepth)) {
          instanceNetworkInterfaceAttachment.setDeleteOnTermination(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return instanceNetworkInterfaceAttachment;
        }
      }
    }
  }
  public DescribeVpcAttributeResult unmarshall(StaxUnmarshallerContext context) throws Exception {
    DescribeVpcAttributeResult describeVpcAttributeResult = new DescribeVpcAttributeResult();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return describeVpcAttributeResult;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("vpcId", targetDepth)) {
          describeVpcAttributeResult.setVpcId(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("enableDnsSupport/value", targetDepth)) {
          describeVpcAttributeResult.setEnableDnsSupport(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("enableDnsHostnames/value", targetDepth)) {
          describeVpcAttributeResult.setEnableDnsHostnames(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return describeVpcAttributeResult;
        }
      }
    }
  }
  public Instance unmarshall(StaxUnmarshallerContext context) throws Exception {
    Instance instance = new Instance();

    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 2;

    while (true) {
      int xmlEvent = context.nextEvent();
      if (xmlEvent == XmlPullParser.END_DOCUMENT) break;

      if (xmlEvent == XmlPullParser.START_TAG) {
        if (context.testExpression("InstanceId", targetDepth)) {
          instance.setInstanceId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("AvailabilityZone", targetDepth)) {
          instance.setAvailabilityZone(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("LifecycleState", targetDepth)) {
          instance.setLifecycleState(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("HealthStatus", targetDepth)) {
          instance.setHealthStatus(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("LaunchConfigurationName", targetDepth)) {
          instance.setLaunchConfigurationName(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ProtectedFromScaleIn", targetDepth)) {
          instance.setProtectedFromScaleIn(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent == XmlPullParser.END_TAG) {
        if (context.getCurrentDepth() < originalDepth) {
          break;
        }
      }
    }
    return instance;
  }
  public IdentityNotificationAttributes unmarshall(StaxUnmarshallerContext context)
      throws Exception {
    IdentityNotificationAttributes identityNotificationAttributes =
        new IdentityNotificationAttributes();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return identityNotificationAttributes;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("BounceTopic", targetDepth)) {
          identityNotificationAttributes.setBounceTopic(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("ComplaintTopic", targetDepth)) {
          identityNotificationAttributes.setComplaintTopic(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("DeliveryTopic", targetDepth)) {
          identityNotificationAttributes.setDeliveryTopic(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("ForwardingEnabled", targetDepth)) {
          identityNotificationAttributes.setForwardingEnabled(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return identityNotificationAttributes;
        }
      }
    }
  }
  public IdentityDkimAttributes unmarshall(StaxUnmarshallerContext context) throws Exception {
    IdentityDkimAttributes identityDkimAttributes = new IdentityDkimAttributes();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return identityDkimAttributes;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("DkimEnabled", targetDepth)) {
          identityDkimAttributes.setDkimEnabled(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("DkimVerificationStatus", targetDepth)) {
          identityDkimAttributes.setDkimVerificationStatus(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("DkimTokens", targetDepth)) {
          identityDkimAttributes.withDkimTokens(new ArrayList<String>());
          continue;
        }

        if (context.testExpression("DkimTokens/member", targetDepth)) {
          identityDkimAttributes.withDkimTokens(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return identityDkimAttributes;
        }
      }
    }
  }
  public VpnConnectionOptions unmarshall(StaxUnmarshallerContext context) throws Exception {
    VpnConnectionOptions vpnConnectionOptions = new VpnConnectionOptions();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return vpnConnectionOptions;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {
        if (context.testExpression("staticRoutesOnly", targetDepth)) {
          vpnConnectionOptions.setStaticRoutesOnly(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return vpnConnectionOptions;
        }
      }
    }
  }
  public ModifyVpcEndpointResult unmarshall(StaxUnmarshallerContext context) throws Exception {
    ModifyVpcEndpointResult modifyVpcEndpointResult = new ModifyVpcEndpointResult();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      int xmlEvent = context.nextEvent();
      if (xmlEvent == XmlPullParser.END_DOCUMENT) return modifyVpcEndpointResult;

      if (xmlEvent == XmlPullParser.START_TAG) {
        if (context.testExpression("return", targetDepth)) {
          modifyVpcEndpointResult.setReturn(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent == XmlPullParser.END_TAG) {
        if (context.getCurrentDepth() < originalDepth) {
          return modifyVpcEndpointResult;
        }
      }
    }
  }
  public DistributionConfig unmarshall(StaxUnmarshallerContext context) throws Exception {
    DistributionConfig distributionConfig = new DistributionConfig();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return distributionConfig;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("CallerReference", targetDepth)) {
          distributionConfig.setCallerReference(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("Aliases", targetDepth)) {
          distributionConfig.setAliases(AliasesStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("DefaultRootObject", targetDepth)) {
          distributionConfig.setDefaultRootObject(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("Origins", targetDepth)) {
          distributionConfig.setOrigins(OriginsStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("DefaultCacheBehavior", targetDepth)) {
          distributionConfig.setDefaultCacheBehavior(
              DefaultCacheBehaviorStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("CacheBehaviors", targetDepth)) {
          distributionConfig.setCacheBehaviors(
              CacheBehaviorsStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("CustomErrorResponses", targetDepth)) {
          distributionConfig.setCustomErrorResponses(
              CustomErrorResponsesStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("Comment", targetDepth)) {
          distributionConfig.setComment(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("Logging", targetDepth)) {
          distributionConfig.setLogging(
              LoggingConfigStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("PriceClass", targetDepth)) {
          distributionConfig.setPriceClass(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("Enabled", targetDepth)) {
          distributionConfig.setEnabled(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("ViewerCertificate", targetDepth)) {
          distributionConfig.setViewerCertificate(
              ViewerCertificateStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("Restrictions", targetDepth)) {
          distributionConfig.setRestrictions(
              RestrictionsStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("WebACLId", targetDepth)) {
          distributionConfig.setWebACLId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return distributionConfig;
        }
      }
    }
  }
  public Cluster unmarshall(StaxUnmarshallerContext context) throws Exception {
    Cluster cluster = new Cluster();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 2;

    if (context.isStartOfDocument()) targetDepth++;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return cluster;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {
        if (context.testExpression("ClusterIdentifier", targetDepth)) {
          cluster.setClusterIdentifier(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("NodeType", targetDepth)) {
          cluster.setNodeType(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterStatus", targetDepth)) {
          cluster.setClusterStatus(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ModifyStatus", targetDepth)) {
          cluster.setModifyStatus(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("MasterUsername", targetDepth)) {
          cluster.setMasterUsername(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("DBName", targetDepth)) {
          cluster.setDBName(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Endpoint", targetDepth)) {
          cluster.setEndpoint(EndpointStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterCreateTime", targetDepth)) {
          cluster.setClusterCreateTime(DateStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("AutomatedSnapshotRetentionPeriod", targetDepth)) {
          cluster.setAutomatedSnapshotRetentionPeriod(
              IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterSecurityGroups/ClusterSecurityGroup", targetDepth)) {
          cluster
              .getClusterSecurityGroups()
              .add(
                  ClusterSecurityGroupMembershipStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("VpcSecurityGroups/VpcSecurityGroup", targetDepth)) {
          cluster
              .getVpcSecurityGroups()
              .add(VpcSecurityGroupMembershipStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterParameterGroups/ClusterParameterGroup", targetDepth)) {
          cluster
              .getClusterParameterGroups()
              .add(ClusterParameterGroupStatusStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterSubnetGroupName", targetDepth)) {
          cluster.setClusterSubnetGroupName(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("VpcId", targetDepth)) {
          cluster.setVpcId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("AvailabilityZone", targetDepth)) {
          cluster.setAvailabilityZone(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("PreferredMaintenanceWindow", targetDepth)) {
          cluster.setPreferredMaintenanceWindow(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("PendingModifiedValues", targetDepth)) {
          cluster.setPendingModifiedValues(
              PendingModifiedValuesStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterVersion", targetDepth)) {
          cluster.setClusterVersion(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("AllowVersionUpgrade", targetDepth)) {
          cluster.setAllowVersionUpgrade(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("NumberOfNodes", targetDepth)) {
          cluster.setNumberOfNodes(IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("PubliclyAccessible", targetDepth)) {
          cluster.setPubliclyAccessible(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Encrypted", targetDepth)) {
          cluster.setEncrypted(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("RestoreStatus", targetDepth)) {
          cluster.setRestoreStatus(RestoreStatusStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("HsmStatus", targetDepth)) {
          cluster.setHsmStatus(HsmStatusStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterSnapshotCopyStatus", targetDepth)) {
          cluster.setClusterSnapshotCopyStatus(
              ClusterSnapshotCopyStatusStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterPublicKey", targetDepth)) {
          cluster.setClusterPublicKey(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterNodes/member", targetDepth)) {
          cluster
              .getClusterNodes()
              .add(ClusterNodeStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ElasticIpStatus", targetDepth)) {
          cluster.setElasticIpStatus(
              ElasticIpStatusStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return cluster;
        }
      }
    }
  }
  public Subnet unmarshall(StaxUnmarshallerContext context) throws Exception {
    Subnet subnet = new Subnet();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return subnet;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("subnetId", targetDepth)) {
          subnet.setSubnetId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("state", targetDepth)) {
          subnet.setState(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("vpcId", targetDepth)) {
          subnet.setVpcId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("cidrBlock", targetDepth)) {
          subnet.setCidrBlock(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("ipv6CidrBlockAssociationSet", targetDepth)) {
          subnet.withIpv6CidrBlockAssociationSet(new ArrayList<SubnetIpv6CidrBlockAssociation>());
          continue;
        }

        if (context.testExpression("ipv6CidrBlockAssociationSet/item", targetDepth)) {
          subnet.withIpv6CidrBlockAssociationSet(
              SubnetIpv6CidrBlockAssociationStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("assignIpv6AddressOnCreation", targetDepth)) {
          subnet.setAssignIpv6AddressOnCreation(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("availableIpAddressCount", targetDepth)) {
          subnet.setAvailableIpAddressCount(
              IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("availabilityZone", targetDepth)) {
          subnet.setAvailabilityZone(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("defaultForAz", targetDepth)) {
          subnet.setDefaultForAz(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("mapPublicIpOnLaunch", targetDepth)) {
          subnet.setMapPublicIpOnLaunch(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("tagSet", targetDepth)) {
          subnet.withTags(new ArrayList<Tag>());
          continue;
        }

        if (context.testExpression("tagSet/item", targetDepth)) {
          subnet.withTags(TagStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return subnet;
        }
      }
    }
  }
  public HealthCheckConfig unmarshall(StaxUnmarshallerContext context) throws Exception {
    HealthCheckConfig healthCheckConfig = new HealthCheckConfig();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;
    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return healthCheckConfig;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {
        if (context.testExpression("IPAddress", targetDepth)) {
          healthCheckConfig.setIPAddress(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Port", targetDepth)) {
          healthCheckConfig.setPort(IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Type", targetDepth)) {
          healthCheckConfig.setType(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ResourcePath", targetDepth)) {
          healthCheckConfig.setResourcePath(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("FullyQualifiedDomainName", targetDepth)) {
          healthCheckConfig.setFullyQualifiedDomainName(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("SearchString", targetDepth)) {
          healthCheckConfig.setSearchString(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("RequestInterval", targetDepth)) {
          healthCheckConfig.setRequestInterval(
              IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("FailureThreshold", targetDepth)) {
          healthCheckConfig.setFailureThreshold(
              IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("MeasureLatency", targetDepth)) {
          healthCheckConfig.setMeasureLatency(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Inverted", targetDepth)) {
          healthCheckConfig.setInverted(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("HealthThreshold", targetDepth)) {
          healthCheckConfig.setHealthThreshold(
              IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ChildHealthChecks/ChildHealthCheck", targetDepth)) {
          healthCheckConfig
              .getChildHealthChecks()
              .add(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return healthCheckConfig;
        }
      }
    }
  }
  public DistributionConfig unmarshall(StaxUnmarshallerContext context) throws Exception {
    DistributionConfig distributionConfig = new DistributionConfig();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;
    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return distributionConfig;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {
        if (context.testExpression("S3Origin", targetDepth)) {
          distributionConfig.setS3Origin(
              S3OriginStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("CustomOrigin", targetDepth)) {
          distributionConfig.setCustomOrigin(
              CustomOriginStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("CallerReference", targetDepth)) {
          distributionConfig.setCallerReference(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("CNAME", targetDepth)) {
          distributionConfig
              .getCNAME()
              .add(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Comment", targetDepth)) {
          distributionConfig.setComment(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Enabled", targetDepth)) {
          distributionConfig.setEnabled(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Logging", targetDepth)) {
          distributionConfig.setLogging(
              LoggingConfigStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("TrustedSigners", targetDepth)) {
          distributionConfig.setTrustedSigners(
              TrustedSignersStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("RequiredProtocols", targetDepth)) {
          distributionConfig.setRequiredProtocols(
              RequiredProtocolsStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("DefaultRootObject", targetDepth)) {
          distributionConfig.setDefaultRootObject(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("CachingBehavior", targetDepth)) {
          distributionConfig.setCachingBehavior(
              CachingBehaviorStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return distributionConfig;
        }
      }
    }
  }
  public Instance unmarshall(StaxUnmarshallerContext context) throws Exception {
    Instance instance = new Instance();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return instance;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("instanceId", targetDepth)) {
          instance.setInstanceId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("imageId", targetDepth)) {
          instance.setImageId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("instanceState", targetDepth)) {
          instance.setState(InstanceStateStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("privateDnsName", targetDepth)) {
          instance.setPrivateDnsName(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("dnsName", targetDepth)) {
          instance.setPublicDnsName(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("reason", targetDepth)) {
          instance.setStateTransitionReason(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("keyName", targetDepth)) {
          instance.setKeyName(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("amiLaunchIndex", targetDepth)) {
          instance.setAmiLaunchIndex(IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("productCodes/item", targetDepth)) {
          instance.withProductCodes(ProductCodeStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("instanceType", targetDepth)) {
          instance.setInstanceType(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("launchTime", targetDepth)) {
          instance.setLaunchTime(DateStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("placement", targetDepth)) {
          instance.setPlacement(PlacementStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("kernelId", targetDepth)) {
          instance.setKernelId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("ramdiskId", targetDepth)) {
          instance.setRamdiskId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("platform", targetDepth)) {
          instance.setPlatform(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("monitoring", targetDepth)) {
          instance.setMonitoring(MonitoringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("subnetId", targetDepth)) {
          instance.setSubnetId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("vpcId", targetDepth)) {
          instance.setVpcId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("privateIpAddress", targetDepth)) {
          instance.setPrivateIpAddress(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("ipAddress", targetDepth)) {
          instance.setPublicIpAddress(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("stateReason", targetDepth)) {
          instance.setStateReason(StateReasonStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("architecture", targetDepth)) {
          instance.setArchitecture(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("rootDeviceType", targetDepth)) {
          instance.setRootDeviceType(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("rootDeviceName", targetDepth)) {
          instance.setRootDeviceName(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("blockDeviceMapping/item", targetDepth)) {
          instance.withBlockDeviceMappings(
              InstanceBlockDeviceMappingStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("virtualizationType", targetDepth)) {
          instance.setVirtualizationType(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("instanceLifecycle", targetDepth)) {
          instance.setInstanceLifecycle(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("spotInstanceRequestId", targetDepth)) {
          instance.setSpotInstanceRequestId(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("clientToken", targetDepth)) {
          instance.setClientToken(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("tagSet/item", targetDepth)) {
          instance.withTags(TagStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("groupSet/item", targetDepth)) {
          instance.withSecurityGroups(
              GroupIdentifierStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("sourceDestCheck", targetDepth)) {
          instance.setSourceDestCheck(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("hypervisor", targetDepth)) {
          instance.setHypervisor(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("networkInterfaceSet/item", targetDepth)) {
          instance.withNetworkInterfaces(
              InstanceNetworkInterfaceStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("iamInstanceProfile", targetDepth)) {
          instance.setIamInstanceProfile(
              IamInstanceProfileStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("ebsOptimized", targetDepth)) {
          instance.setEbsOptimized(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("sriovNetSupport", targetDepth)) {
          instance.setSriovNetSupport(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return instance;
        }
      }
    }
  }
  public NetworkInterface unmarshall(StaxUnmarshallerContext context) throws Exception {
    NetworkInterface networkInterface = new NetworkInterface();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return networkInterface;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {
        if (context.testExpression("networkInterfaceId", targetDepth)) {
          networkInterface.setNetworkInterfaceId(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("subnetId", targetDepth)) {
          networkInterface.setSubnetId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("vpcId", targetDepth)) {
          networkInterface.setVpcId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("availabilityZone", targetDepth)) {
          networkInterface.setAvailabilityZone(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("description", targetDepth)) {
          networkInterface.setDescription(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ownerId", targetDepth)) {
          networkInterface.setOwnerId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("requesterId", targetDepth)) {
          networkInterface.setRequesterId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("requesterManaged", targetDepth)) {
          networkInterface.setRequesterManaged(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("status", targetDepth)) {
          networkInterface.setStatus(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("macAddress", targetDepth)) {
          networkInterface.setMacAddress(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("privateIpAddress", targetDepth)) {
          networkInterface.setPrivateIpAddress(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("privateDnsName", targetDepth)) {
          networkInterface.setPrivateDnsName(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("sourceDestCheck", targetDepth)) {
          networkInterface.setSourceDestCheck(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("groupSet/item", targetDepth)) {
          networkInterface
              .getGroups()
              .add(GroupIdentifierStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("attachment", targetDepth)) {
          networkInterface.setAttachment(
              NetworkInterfaceAttachmentStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("association", targetDepth)) {
          networkInterface.setAssociation(
              NetworkInterfaceAssociationStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("tagSet/item", targetDepth)) {
          networkInterface.getTagSet().add(TagStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("privateIpAddressesSet/item", targetDepth)) {
          networkInterface
              .getPrivateIpAddresses()
              .add(
                  NetworkInterfacePrivateIpAddressStaxUnmarshaller.getInstance()
                      .unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return networkInterface;
        }
      }
    }
  }
  public ReservedInstancesOffering unmarshall(StaxUnmarshallerContext context) throws Exception {
    ReservedInstancesOffering reservedInstancesOffering = new ReservedInstancesOffering();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return reservedInstancesOffering;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("reservedInstancesOfferingId", targetDepth)) {
          reservedInstancesOffering.setReservedInstancesOfferingId(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("instanceType", targetDepth)) {
          reservedInstancesOffering.setInstanceType(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("availabilityZone", targetDepth)) {
          reservedInstancesOffering.setAvailabilityZone(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("duration", targetDepth)) {
          reservedInstancesOffering.setDuration(
              LongStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("usagePrice", targetDepth)) {
          reservedInstancesOffering.setUsagePrice(
              FloatStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("fixedPrice", targetDepth)) {
          reservedInstancesOffering.setFixedPrice(
              FloatStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("productDescription", targetDepth)) {
          reservedInstancesOffering.setProductDescription(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("instanceTenancy", targetDepth)) {
          reservedInstancesOffering.setInstanceTenancy(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("currencyCode", targetDepth)) {
          reservedInstancesOffering.setCurrencyCode(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("offeringType", targetDepth)) {
          reservedInstancesOffering.setOfferingType(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("recurringCharges", targetDepth)) {
          reservedInstancesOffering.withRecurringCharges(new ArrayList<RecurringCharge>());
          continue;
        }

        if (context.testExpression("recurringCharges/item", targetDepth)) {
          reservedInstancesOffering.withRecurringCharges(
              RecurringChargeStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("marketplace", targetDepth)) {
          reservedInstancesOffering.setMarketplace(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("pricingDetailsSet", targetDepth)) {
          reservedInstancesOffering.withPricingDetails(new ArrayList<PricingDetail>());
          continue;
        }

        if (context.testExpression("pricingDetailsSet/item", targetDepth)) {
          reservedInstancesOffering.withPricingDetails(
              PricingDetailStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("offeringClass", targetDepth)) {
          reservedInstancesOffering.setOfferingClass(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("scope", targetDepth)) {
          reservedInstancesOffering.setScope(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return reservedInstancesOffering;
        }
      }
    }
  }
  public PasswordPolicy unmarshall(StaxUnmarshallerContext context) throws Exception {
    PasswordPolicy passwordPolicy = new PasswordPolicy();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return passwordPolicy;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("MinimumPasswordLength", targetDepth)) {
          passwordPolicy.setMinimumPasswordLength(
              IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("RequireSymbols", targetDepth)) {
          passwordPolicy.setRequireSymbols(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("RequireNumbers", targetDepth)) {
          passwordPolicy.setRequireNumbers(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("RequireUppercaseCharacters", targetDepth)) {
          passwordPolicy.setRequireUppercaseCharacters(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("RequireLowercaseCharacters", targetDepth)) {
          passwordPolicy.setRequireLowercaseCharacters(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("AllowUsersToChangePassword", targetDepth)) {
          passwordPolicy.setAllowUsersToChangePassword(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("ExpirePasswords", targetDepth)) {
          passwordPolicy.setExpirePasswords(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("MaxPasswordAge", targetDepth)) {
          passwordPolicy.setMaxPasswordAge(
              IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("PasswordReusePrevention", targetDepth)) {
          passwordPolicy.setPasswordReusePrevention(
              IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("HardExpiry", targetDepth)) {
          passwordPolicy.setHardExpiry(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return passwordPolicy;
        }
      }
    }
  }
  public ReservedInstancesOffering unmarshall(StaxUnmarshallerContext context) throws Exception {
    ReservedInstancesOffering reservedInstancesOffering = new ReservedInstancesOffering();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      int xmlEvent = context.nextEvent();
      if (xmlEvent == XmlPullParser.END_DOCUMENT) return reservedInstancesOffering;

      if (xmlEvent == XmlPullParser.START_TAG) {
        if (context.testExpression("reservedInstancesOfferingId", targetDepth)) {
          reservedInstancesOffering.setReservedInstancesOfferingId(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("instanceType", targetDepth)) {
          reservedInstancesOffering.setInstanceType(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("availabilityZone", targetDepth)) {
          reservedInstancesOffering.setAvailabilityZone(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("duration", targetDepth)) {
          reservedInstancesOffering.setDuration(
              LongStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("usagePrice", targetDepth)) {
          reservedInstancesOffering.setUsagePrice(
              FloatStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("fixedPrice", targetDepth)) {
          reservedInstancesOffering.setFixedPrice(
              FloatStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("productDescription", targetDepth)) {
          reservedInstancesOffering.setProductDescription(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("instanceTenancy", targetDepth)) {
          reservedInstancesOffering.setInstanceTenancy(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("currencyCode", targetDepth)) {
          reservedInstancesOffering.setCurrencyCode(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("offeringType", targetDepth)) {
          reservedInstancesOffering.setOfferingType(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("recurringCharges/item", targetDepth)) {
          reservedInstancesOffering
              .getRecurringCharges()
              .add(RecurringChargeStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("marketplace", targetDepth)) {
          reservedInstancesOffering.setMarketplace(
              BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("pricingDetailsSet/item", targetDepth)) {
          reservedInstancesOffering
              .getPricingDetails()
              .add(PricingDetailStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent == XmlPullParser.END_TAG) {
        if (context.getCurrentDepth() < originalDepth) {
          return reservedInstancesOffering;
        }
      }
    }
  }
  public DistributionSummary unmarshall(StaxUnmarshallerContext context) throws Exception {
    DistributionSummary distributionSummary = new DistributionSummary();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;
    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return distributionSummary;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {
        if (context.testExpression("Id", targetDepth)) {
          distributionSummary.setId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Status", targetDepth)) {
          distributionSummary.setStatus(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("LastModifiedTime", targetDepth)) {
          distributionSummary.setLastModifiedTime(
              DateStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("DomainName", targetDepth)) {
          distributionSummary.setDomainName(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Aliases", targetDepth)) {
          distributionSummary.setAliases(AliasesStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Origins", targetDepth)) {
          distributionSummary.setOrigins(OriginsStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("DefaultCacheBehavior", targetDepth)) {
          distributionSummary.setDefaultCacheBehavior(
              DefaultCacheBehaviorStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("CacheBehaviors", targetDepth)) {
          distributionSummary.setCacheBehaviors(
              CacheBehaviorsStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("CustomErrorResponses", targetDepth)) {
          distributionSummary.setCustomErrorResponses(
              CustomErrorResponsesStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Comment", targetDepth)) {
          distributionSummary.setComment(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("PriceClass", targetDepth)) {
          distributionSummary.setPriceClass(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Enabled", targetDepth)) {
          distributionSummary.setEnabled(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ViewerCertificate", targetDepth)) {
          distributionSummary.setViewerCertificate(
              ViewerCertificateStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Restrictions", targetDepth)) {
          distributionSummary.setRestrictions(
              RestrictionsStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("WebACLId", targetDepth)) {
          distributionSummary.setWebACLId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return distributionSummary;
        }
      }
    }
  }
  public Snapshot unmarshall(StaxUnmarshallerContext context) throws Exception {
    Snapshot snapshot = new Snapshot();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 2;

    if (context.isStartOfDocument()) targetDepth++;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return snapshot;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {
        if (context.testExpression("SnapshotIdentifier", targetDepth)) {
          snapshot.setSnapshotIdentifier(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterIdentifier", targetDepth)) {
          snapshot.setClusterIdentifier(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("SnapshotCreateTime", targetDepth)) {
          snapshot.setSnapshotCreateTime(DateStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Status", targetDepth)) {
          snapshot.setStatus(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Port", targetDepth)) {
          snapshot.setPort(IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("AvailabilityZone", targetDepth)) {
          snapshot.setAvailabilityZone(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterCreateTime", targetDepth)) {
          snapshot.setClusterCreateTime(DateStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("MasterUsername", targetDepth)) {
          snapshot.setMasterUsername(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ClusterVersion", targetDepth)) {
          snapshot.setClusterVersion(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("SnapshotType", targetDepth)) {
          snapshot.setSnapshotType(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("NodeType", targetDepth)) {
          snapshot.setNodeType(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("NumberOfNodes", targetDepth)) {
          snapshot.setNumberOfNodes(IntegerStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("DBName", targetDepth)) {
          snapshot.setDBName(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("VpcId", targetDepth)) {
          snapshot.setVpcId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("Encrypted", targetDepth)) {
          snapshot.setEncrypted(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("EncryptedWithHSM", targetDepth)) {
          snapshot.setEncryptedWithHSM(BooleanStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression(
            "AccountsWithRestoreAccess/AccountWithRestoreAccess", targetDepth)) {
          snapshot
              .getAccountsWithRestoreAccess()
              .add(AccountWithRestoreAccessStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("OwnerAccount", targetDepth)) {
          snapshot.setOwnerAccount(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("TotalBackupSizeInMegaBytes", targetDepth)) {
          snapshot.setTotalBackupSizeInMegaBytes(
              DoubleStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ActualIncrementalBackupSizeInMegaBytes", targetDepth)) {
          snapshot.setActualIncrementalBackupSizeInMegaBytes(
              DoubleStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("BackupProgressInMegaBytes", targetDepth)) {
          snapshot.setBackupProgressInMegaBytes(
              DoubleStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("CurrentBackupRateInMegaBytesPerSecond", targetDepth)) {
          snapshot.setCurrentBackupRateInMegaBytesPerSecond(
              DoubleStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("EstimatedSecondsToCompletion", targetDepth)) {
          snapshot.setEstimatedSecondsToCompletion(
              LongStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("ElapsedTimeInSeconds", targetDepth)) {
          snapshot.setElapsedTimeInSeconds(LongStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
        if (context.testExpression("SourceRegion", targetDepth)) {
          snapshot.setSourceRegion(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return snapshot;
        }
      }
    }
  }