killbill-aplcache

diff --git a/api/src/main/java/org/killbill/billing/overdue/config/api/BillingState.java b/api/src/main/java/org/killbill/billing/overdue/config/api/BillingState.java
index 35b7c02..2f781c5 100644
--- a/api/src/main/java/org/killbill/billing/overdue/config/api/BillingState.java
+++ b/api/src/main/java/org/killbill/billing/overdue/config/api/BillingState.java
@@ -22,6 +22,7 @@ import java.util.UUID;
 import org.joda.time.DateTimeZone;
 import org.joda.time.LocalDate;
 
+import org.killbill.billing.payment.api.PaymentResponse;
 import org.killbill.billing.util.tag.Tag;
 
 public class BillingState {

diff --git a/api/src/main/java/org/killbill/billing/overdue/config/api/OverdueStateSet.java b/api/src/main/java/org/killbill/billing/overdue/config/api/OverdueStateSet.java
index 5378ed3..03e270f 100644
--- a/api/src/main/java/org/killbill/billing/overdue/config/api/OverdueStateSet.java
+++ b/api/src/main/java/org/killbill/billing/overdue/config/api/OverdueStateSet.java
@@ -18,9 +18,8 @@ package org.killbill.billing.overdue.config.api;
 
 import org.joda.time.LocalDate;
 import org.joda.time.Period;
-
-import org.killbill.billing.overdue.OverdueApiException;
-import org.killbill.billing.overdue.OverdueState;
+import org.killbill.billing.overdue.api.OverdueApiException;
+import org.killbill.billing.overdue.api.OverdueState;
 
 public interface OverdueStateSet {
 

diff --git a/api/src/main/java/org/killbill/billing/overdue/OverdueService.java b/api/src/main/java/org/killbill/billing/overdue/OverdueService.java
index 23e7fe9..59bec21 100644
--- a/api/src/main/java/org/killbill/billing/overdue/OverdueService.java
+++ b/api/src/main/java/org/killbill/billing/overdue/OverdueService.java
@@ -26,5 +26,5 @@ public interface OverdueService extends KillbillService {
 
     public String getName();
 
-    public OverdueUserApi getUserApi();
+    public OverdueInternalApi getUserApi();
 }

diff --git a/api/src/main/java/org/killbill/billing/subscription/api/user/SubscriptionBaseBundle.java b/api/src/main/java/org/killbill/billing/subscription/api/user/SubscriptionBaseBundle.java
index db81f92..ed4276e 100644
--- a/api/src/main/java/org/killbill/billing/subscription/api/user/SubscriptionBaseBundle.java
+++ b/api/src/main/java/org/killbill/billing/subscription/api/user/SubscriptionBaseBundle.java
@@ -21,7 +21,6 @@ import java.util.UUID;
 import org.joda.time.DateTime;
 
 import org.killbill.billing.entitlement.api.Blockable;
-import org.killbill.billing.overdue.OverdueState;
 import org.killbill.billing.util.entity.Entity;
 
 public interface SubscriptionBaseBundle extends Blockable, Entity {

diff --git a/beatrix/src/test/java/org/killbill/billing/beatrix/integration/overdue/MockOverdueService.java b/beatrix/src/test/java/org/killbill/billing/beatrix/integration/overdue/MockOverdueService.java
index aece71d..1230db1 100644
--- a/beatrix/src/test/java/org/killbill/billing/beatrix/integration/overdue/MockOverdueService.java
+++ b/beatrix/src/test/java/org/killbill/billing/beatrix/integration/overdue/MockOverdueService.java
@@ -21,8 +21,8 @@ package org.killbill.billing.beatrix.integration.overdue;
 import javax.inject.Named;
 
 import org.killbill.billing.lifecycle.api.BusService;
+import org.killbill.billing.overdue.OverdueInternalApi;
 import org.killbill.billing.overdue.OverdueProperties;
-import org.killbill.billing.overdue.OverdueUserApi;
 import org.killbill.billing.overdue.glue.DefaultOverdueModule;
 import org.killbill.billing.overdue.listener.OverdueListener;
 import org.killbill.billing.overdue.notification.OverdueNotifier;
@@ -34,7 +34,7 @@ import com.google.inject.Inject;
 public class MockOverdueService extends DefaultOverdueService {
 
     @Inject
-    public MockOverdueService(final OverdueUserApi userApi, final OverdueProperties properties,
+    public MockOverdueService(final OverdueInternalApi userApi, final OverdueProperties properties,
                               @Named(DefaultOverdueModule.OVERDUE_NOTIFIER_CHECK_NAMED) final OverdueNotifier checkNotifier,
                               @Named(DefaultOverdueModule.OVERDUE_NOTIFIER_ASYNC_BUS_NAMED) final OverdueNotifier asyncNotifier,
                               final BusService busService, final OverdueListener listener, final OverdueWrapperFactory factory) {

diff --git a/beatrix/src/test/java/org/killbill/billing/beatrix/integration/overdue/TestOverdueBase.java b/beatrix/src/test/java/org/killbill/billing/beatrix/integration/overdue/TestOverdueBase.java
index 613cd98..c9d3f15 100644
--- a/beatrix/src/test/java/org/killbill/billing/beatrix/integration/overdue/TestOverdueBase.java
+++ b/beatrix/src/test/java/org/killbill/billing/beatrix/integration/overdue/TestOverdueBase.java
@@ -30,8 +30,8 @@ import org.killbill.billing.catalog.api.BillingPeriod;
 import org.killbill.billing.entitlement.api.BlockingStateType;
 import org.killbill.billing.entitlement.api.SubscriptionBundle;
 import org.killbill.billing.overdue.OverdueService;
-import org.killbill.billing.overdue.api.DefaultOverdueUserApi;
-import org.killbill.billing.overdue.config.OverdueConfig;
+import org.killbill.billing.overdue.api.DefaultOverdueInternalApi;
+import org.killbill.billing.overdue.config.DefaultOverdueConfig;
 import org.killbill.billing.payment.api.PaymentMethodPlugin;
 import org.killbill.billing.payment.api.TestPaymentMethodPluginBase;
 import org.killbill.xmlloader.XMLLoader;
@@ -59,10 +59,10 @@ public abstract class TestOverdueBase extends TestIntegrationBase {
         super.beforeMethod();
         final String configXml = getOverdueConfig();
         final InputStream is = new ByteArrayInputStream(configXml.getBytes());
-        final OverdueConfig config = XMLLoader.getObjectFromStreamNoValidation(is, OverdueConfig.class);
+        final DefaultOverdueConfig config = XMLLoader.getObjectFromStreamNoValidation(is, DefaultOverdueConfig.class);
         overdueWrapperFactory.setOverdueConfig(config);
         overdueListener.setOverdueConfig(config);
-        ((DefaultOverdueUserApi) overdueUserApi).setOverdueConfig(config);
+        ((DefaultOverdueInternalApi) overdueUserApi).setOverdueConfig(config);
 
         account = createAccountWithNonOsgiPaymentMethod(getAccountData(0));
         assertNotNull(account);

diff --git a/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestIntegrationBase.java b/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestIntegrationBase.java
index 65df382..8eb8204 100644
--- a/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestIntegrationBase.java
+++ b/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestIntegrationBase.java
@@ -71,7 +71,7 @@ import org.killbill.billing.lifecycle.api.Lifecycle;
 import org.killbill.billing.lifecycle.glue.BusModule;
 import org.killbill.billing.mock.MockAccountBuilder;
 import org.killbill.billing.osgi.config.OSGIConfig;
-import org.killbill.billing.overdue.OverdueUserApi;
+import org.killbill.billing.overdue.OverdueInternalApi;
 import org.killbill.billing.overdue.listener.OverdueListener;
 import org.killbill.billing.overdue.wrapper.OverdueWrapperFactory;
 import org.killbill.billing.payment.api.Payment;
@@ -171,7 +171,7 @@ public class TestIntegrationBase extends BeatrixTestSuiteWithEmbeddedDB {
     protected SubscriptionBaseTimelineApi repairApi;
 
     @Inject
-    protected OverdueUserApi overdueUserApi;
+    protected OverdueInternalApi overdueUserApi;
 
     @Inject
     protected InvoiceUserApi invoiceUserApi;

diff --git a/jaxrs/pom.xml b/jaxrs/pom.xml
index 1ca264c..0af961c 100644
--- a/jaxrs/pom.xml
+++ b/jaxrs/pom.xml
@@ -104,6 +104,10 @@
         </dependency>
         <dependency>
             <groupId>org.kill-bill.billing</groupId>
+            <artifactId>killbill-overdue</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.kill-bill.billing</groupId>
             <artifactId>killbill-platform-api</artifactId>
         </dependency>
         <dependency>

diff --git a/jaxrs/src/main/java/org/killbill/billing/jaxrs/json/OverdueStateJson.java b/jaxrs/src/main/java/org/killbill/billing/jaxrs/json/OverdueStateJson.java
index 79af69f..a5446ce 100644
--- a/jaxrs/src/main/java/org/killbill/billing/jaxrs/json/OverdueStateJson.java
+++ b/jaxrs/src/main/java/org/killbill/billing/jaxrs/json/OverdueStateJson.java
@@ -16,10 +16,12 @@
 
 package org.killbill.billing.jaxrs.json;
 
-import org.joda.time.Period;
+import java.util.List;
 
-import org.killbill.billing.overdue.OverdueApiException;
-import org.killbill.billing.overdue.OverdueState;
+import org.joda.time.Period;
+import org.killbill.billing.overdue.api.OverdueApiException;
+import org.killbill.billing.overdue.api.OverdueState;
+import org.killbill.billing.util.config.PaymentConfig;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
@@ -28,7 +30,7 @@ public class OverdueStateJson {
 
     private final String name;
     private final String externalMessage;
-    private final Integer daysBetweenPaymentRetries;
+    private final List<Integer> daysBetweenPaymentRetries;
     private final Boolean disableEntitlementAndChangesBlocked;
     private final Boolean blockChanges;
     private final Boolean isClearState;
@@ -37,7 +39,7 @@ public class OverdueStateJson {
     @JsonCreator
     public OverdueStateJson(@JsonProperty("name") final String name,
                             @JsonProperty("externalMessage") final String externalMessage,
-                            @JsonProperty("daysBetweenPaymentRetries") final Integer daysBetweenPaymentRetries,
+                            @JsonProperty("daysBetweenPaymentRetries") final List<Integer> daysBetweenPaymentRetries,
                             @JsonProperty("disableEntitlementAndChangesBlocked") final Boolean disableEntitlementAndChangesBlocked,
                             @JsonProperty("blockChanges") final Boolean blockChanges,
                             @JsonProperty("clearState") final Boolean isClearState,
@@ -51,17 +53,17 @@ public class OverdueStateJson {
         this.reevaluationIntervalDays = reevaluationIntervalDays;
     }
 
-    public OverdueStateJson(final OverdueState overdueState) {
+    public OverdueStateJson(final OverdueState overdueState, final PaymentConfig paymentConfig) {
         this.name = overdueState.getName();
         this.externalMessage = overdueState.getExternalMessage();
-        this.daysBetweenPaymentRetries = overdueState.getDaysBetweenPaymentRetries();
-        this.disableEntitlementAndChangesBlocked = overdueState.disableEntitlementAndChangesBlocked();
-        this.blockChanges = overdueState.blockChanges();
+        this.daysBetweenPaymentRetries = paymentConfig.getPaymentRetryDays();
+        this.disableEntitlementAndChangesBlocked = overdueState.isDisableEntitlementAndChangesBlocked();
+        this.blockChanges = overdueState.isBlockChanges();
         this.isClearState = overdueState.isClearState();
 
         Period reevaluationIntervalPeriod = null;
         try {
-            reevaluationIntervalPeriod = overdueState.getReevaluationInterval();
+            reevaluationIntervalPeriod = overdueState.getAutoReevaluationInterval();
         } catch (final OverdueApiException ignored) {
         }
 
@@ -80,7 +82,7 @@ public class OverdueStateJson {
         return externalMessage;
     }
 
-    public Integer getDaysBetweenPaymentRetries() {
+    public List<Integer> getDaysBetweenPaymentRetries() {
         return daysBetweenPaymentRetries;
     }
 

diff --git a/jaxrs/src/main/java/org/killbill/billing/jaxrs/mappers/ExceptionMapperBase.java b/jaxrs/src/main/java/org/killbill/billing/jaxrs/mappers/ExceptionMapperBase.java
index 047d76e..8794159 100644
--- a/jaxrs/src/main/java/org/killbill/billing/jaxrs/mappers/ExceptionMapperBase.java
+++ b/jaxrs/src/main/java/org/killbill/billing/jaxrs/mappers/ExceptionMapperBase.java
@@ -30,7 +30,7 @@ import org.killbill.billing.entitlement.api.SubscriptionApiException;
 import org.killbill.billing.entity.EntityPersistenceException;
 import org.killbill.billing.invoice.api.InvoiceApiException;
 import org.killbill.billing.jaxrs.json.BillingExceptionJson;
-import org.killbill.billing.overdue.OverdueApiException;
+import org.killbill.billing.overdue.api.OverdueApiException;
 import org.killbill.billing.payment.api.PaymentApiException;
 import org.killbill.billing.subscription.api.SubscriptionBillingApiException;
 import org.killbill.billing.subscription.api.timeline.SubscriptionBaseRepairException;

diff --git a/jaxrs/src/main/java/org/killbill/billing/jaxrs/mappers/OverdueApiExceptionMapper.java b/jaxrs/src/main/java/org/killbill/billing/jaxrs/mappers/OverdueApiExceptionMapper.java
index 869e374..a7ce9a6 100644
--- a/jaxrs/src/main/java/org/killbill/billing/jaxrs/mappers/OverdueApiExceptionMapper.java
+++ b/jaxrs/src/main/java/org/killbill/billing/jaxrs/mappers/OverdueApiExceptionMapper.java
@@ -23,7 +23,7 @@ import javax.ws.rs.core.UriInfo;
 import javax.ws.rs.ext.ExceptionMapper;
 import javax.ws.rs.ext.Provider;
 
-import org.killbill.billing.overdue.OverdueApiException;
+import org.killbill.billing.overdue.api.OverdueApiException;
 
 @Singleton
 @Provider

diff --git a/jaxrs/src/main/java/org/killbill/billing/jaxrs/resources/AccountResource.java b/jaxrs/src/main/java/org/killbill/billing/jaxrs/resources/AccountResource.java
index e66f187..b060132 100644
--- a/jaxrs/src/main/java/org/killbill/billing/jaxrs/resources/AccountResource.java
+++ b/jaxrs/src/main/java/org/killbill/billing/jaxrs/resources/AccountResource.java
@@ -75,9 +75,9 @@ import org.killbill.billing.jaxrs.json.PaymentTransactionJson;
 import org.killbill.billing.jaxrs.json.TagJson;
 import org.killbill.billing.jaxrs.util.Context;
 import org.killbill.billing.jaxrs.util.JaxrsUriBuilder;
-import org.killbill.billing.overdue.OverdueApiException;
-import org.killbill.billing.overdue.OverdueState;
-import org.killbill.billing.overdue.OverdueUserApi;
+import org.killbill.billing.overdue.OverdueInternalApi;
+import org.killbill.billing.overdue.api.OverdueApiException;
+import org.killbill.billing.overdue.api.OverdueState;
 import org.killbill.billing.overdue.config.api.OverdueException;
 import org.killbill.billing.payment.api.Payment;
 import org.killbill.billing.payment.api.PaymentApi;
@@ -96,6 +96,7 @@ import org.killbill.billing.util.api.TagUserApi;
 import org.killbill.billing.util.audit.AccountAuditLogs;
 import org.killbill.billing.util.callcontext.CallContext;
 import org.killbill.billing.util.callcontext.TenantContext;
+import org.killbill.billing.util.config.PaymentConfig;
 import org.killbill.billing.util.entity.Pagination;
 import org.killbill.billing.util.tag.ControlTagType;
 import org.killbill.clock.Clock;
@@ -126,7 +127,8 @@ public class AccountResource extends JaxRsResourceBase {
     private final SubscriptionApi subscriptionApi;
     private final InvoiceUserApi invoiceApi;
     private final InvoicePaymentApi invoicePaymentApi;
-    private final OverdueUserApi overdueApi;
+    private final OverdueInternalApi overdueApi;
+    private final PaymentConfig paymentConfig;
 
     @Inject
     public AccountResource(final JaxrsUriBuilder uriBuilder,
@@ -138,14 +140,16 @@ public class AccountResource extends JaxRsResourceBase {
                            final AuditUserApi auditUserApi,
                            final CustomFieldUserApi customFieldUserApi,
                            final SubscriptionApi subscriptionApi,
-                           final OverdueUserApi overdueApi,
+                           final OverdueInternalApi overdueApi,
                            final Clock clock,
+                           final PaymentConfig paymentConfig,
                            final Context context) {
         super(uriBuilder, tagUserApi, customFieldUserApi, auditUserApi, accountApi, paymentApi, clock, context);
         this.subscriptionApi = subscriptionApi;
         this.invoiceApi = invoiceApi;
         this.invoicePaymentApi = invoicePaymentApi;
         this.overdueApi = overdueApi;
+        this.paymentConfig = paymentConfig;
     }
 
     @Timed
@@ -776,7 +780,7 @@ public class AccountResource extends JaxRsResourceBase {
         final Account account = accountUserApi.getAccountById(UUID.fromString(accountId), tenantContext);
         final OverdueState overdueState = overdueApi.getOverdueStateFor(account, tenantContext);
 
-        return Response.status(Status.OK).entity(new OverdueStateJson(overdueState)).build();
+        return Response.status(Status.OK).entity(new OverdueStateJson(overdueState, paymentConfig)).build();
     }
 
     /*

diff --git a/jaxrs/src/main/java/org/killbill/billing/jaxrs/resources/OverdueResource.java b/jaxrs/src/main/java/org/killbill/billing/jaxrs/resources/OverdueResource.java
new file mode 100644
index 0000000..d850fd2
--- /dev/null
+++ b/jaxrs/src/main/java/org/killbill/billing/jaxrs/resources/OverdueResource.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2014 Groupon, Inc
+ * Copyright 2014 The Billing Project, LLC
+ *
+ * The Billing Project licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.killbill.billing.jaxrs.resources;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.net.URI;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.GET;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.core.UriInfo;
+
+import org.killbill.billing.account.api.AccountUserApi;
+import org.killbill.billing.catalog.StandaloneCatalog;
+import org.killbill.billing.catalog.VersionedCatalog;
+import org.killbill.billing.jaxrs.util.Context;
+import org.killbill.billing.jaxrs.util.JaxrsUriBuilder;
+import org.killbill.billing.overdue.api.OverdueApi;
+import org.killbill.billing.overdue.api.OverdueConfig;
+import org.killbill.billing.overdue.config.DefaultOverdueConfig;
+import org.killbill.billing.payment.api.PaymentApi;
+import org.killbill.billing.tenant.api.TenantKV.TenantKey;
+import org.killbill.billing.tenant.api.TenantUserApi;
+import org.killbill.billing.util.api.AuditUserApi;
+import org.killbill.billing.util.api.CustomFieldUserApi;
+import org.killbill.billing.util.api.TagUserApi;
+import org.killbill.billing.util.callcontext.CallContext;
+import org.killbill.billing.util.callcontext.TenantContext;
+import org.killbill.clock.Clock;
+import org.killbill.xmlloader.XMLLoader;
+import org.killbill.xmlloader.XMLWriter;
+
+import com.codahale.metrics.annotation.Timed;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import com.wordnik.swagger.annotations.Api;
+import com.wordnik.swagger.annotations.ApiOperation;
+import com.wordnik.swagger.annotations.ApiResponses;
+
+import static javax.ws.rs.core.MediaType.APPLICATION_XML;
+
+@Singleton
+@Path(JaxrsResource.OVERDUE_PATH)
+@Api(value = JaxrsResource.OVERDUE_PATH, description = "Overdue information")
+public class OverdueResource extends JaxRsResourceBase {
+
+    private final OverdueApi overdueApi;
+    private final TenantUserApi tenantApi;
+
+    @Inject
+    public OverdueResource(final JaxrsUriBuilder uriBuilder,
+                           final TagUserApi tagUserApi,
+                           final CustomFieldUserApi customFieldUserApi,
+                           final AuditUserApi auditUserApi,
+                           final AccountUserApi accountUserApi,
+                           final PaymentApi paymentApi,
+                           final OverdueApi overdueApi,
+                           final TenantUserApi tenantUserApi,
+                           final Clock clock,
+                           final Context context) {
+        super(uriBuilder, tagUserApi, customFieldUserApi, auditUserApi, accountUserApi, paymentApi, clock, context);
+        this.overdueApi = overdueApi;
+        this.tenantApi = tenantUserApi;
+    }
+
+    @Timed
+    @GET
+    @Produces(APPLICATION_XML)
+    @ApiOperation(value = "Retrieve the full catalog as XML", response = String.class, hidden = true)
+    @ApiResponses(value = {})
+    public Response getOverdueConfigXml(@javax.ws.rs.core.Context final HttpServletRequest request) throws Exception {
+        final TenantContext tenantContext = context.createContext(request);
+        return Response.status(Status.OK).entity(XMLWriter.writeXML(overdueApi.getOverdueConfig(tenantContext), OverdueConfig.class)).build();
+    }
+
+    @Timed
+    @POST
+    @Produces(APPLICATION_XML)
+    @Consumes(APPLICATION_XML)
+    @ApiOperation(value = "Upload the full catalog as XML")
+    @ApiResponses(value = {})
+    public Response uploadOverdueConfigXml(final String overdueXML,
+                                     @HeaderParam(HDR_CREATED_BY) final String createdBy,
+                                     @HeaderParam(HDR_REASON) final String reason,
+                                     @HeaderParam(HDR_COMMENT) final String comment,
+                                     @javax.ws.rs.core.Context final HttpServletRequest request,
+                                     @javax.ws.rs.core.Context final UriInfo uriInfo) throws Exception {
+        // Validation purpose:  Will throw if bad XML or catalog validation fails
+        final InputStream stream = new ByteArrayInputStream(overdueXML.getBytes());
+        XMLLoader.getObjectFromStream(new URI(JaxrsResource.OVERDUE_PATH), stream, DefaultOverdueConfig.class);
+
+        final CallContext callContext = context.createContext(createdBy, reason, comment, request);
+        tenantApi.addTenantKeyValue(TenantKey.OVERDUE_CONFIG.toString(), overdueXML, callContext);
+        return uriBuilder.buildResponse(uriInfo, OverdueResource.class, null, null);
+    }
+}

diff --git a/jaxrs/src/test/java/org/killbill/billing/jaxrs/json/TestOverdueStateJson.java b/jaxrs/src/test/java/org/killbill/billing/jaxrs/json/TestOverdueStateJson.java
index a86d679..9f46558 100644
--- a/jaxrs/src/test/java/org/killbill/billing/jaxrs/json/TestOverdueStateJson.java
+++ b/jaxrs/src/test/java/org/killbill/billing/jaxrs/json/TestOverdueStateJson.java
@@ -16,6 +16,7 @@
 
 package org.killbill.billing.jaxrs.json;
 
+import java.util.List;
 import java.util.UUID;
 
 import org.testng.Assert;
@@ -23,13 +24,15 @@ import org.testng.annotations.Test;
 
 import org.killbill.billing.jaxrs.JaxrsTestSuiteNoDB;
 
+import com.google.common.collect.ImmutableList;
+
 public class TestOverdueStateJson extends JaxrsTestSuiteNoDB {
 
     @Test(groups = "fast")
     public void testJson() throws Exception {
         final String name = UUID.randomUUID().toString();
         final String externalMessage = UUID.randomUUID().toString();
-        final int daysBetweenPaymentRetries = 12;
+        final List<Integer> daysBetweenPaymentRetries = ImmutableList.of(new Integer(12));
         final boolean disableEntitlementAndChangesBlocked = true;
         final boolean blockChanges = false;
         final boolean clearState = true;
@@ -39,7 +42,7 @@ public class TestOverdueStateJson extends JaxrsTestSuiteNoDB {
                                                                        reevaluationIntervalDays);
         Assert.assertEquals(overdueStateJson.getName(), name);
         Assert.assertEquals(overdueStateJson.getExternalMessage(), externalMessage);
-        Assert.assertEquals(overdueStateJson.getDaysBetweenPaymentRetries(), (Integer) daysBetweenPaymentRetries);
+        Assert.assertEquals(overdueStateJson.getDaysBetweenPaymentRetries().size(), daysBetweenPaymentRetries.size());
         Assert.assertEquals(overdueStateJson.isDisableEntitlementAndChangesBlocked(), (Boolean) disableEntitlementAndChangesBlocked);
         Assert.assertEquals(overdueStateJson.isBlockChanges(), (Boolean) blockChanges);
         Assert.assertEquals(overdueStateJson.isClearState(), (Boolean) clearState);

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueEmailGenerator.java b/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueEmailGenerator.java
index bfbc990..8cb44b2 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueEmailGenerator.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueEmailGenerator.java
@@ -21,8 +21,7 @@ import java.util.HashMap;
 import java.util.Map;
 
 import org.killbill.billing.account.api.Account;
-import org.killbill.billing.entitlement.api.Blockable;
-import org.killbill.billing.overdue.OverdueState;
+import org.killbill.billing.overdue.api.OverdueState;
 import org.killbill.billing.overdue.applicator.formatters.OverdueEmailFormatterFactory;
 import org.killbill.billing.overdue.config.api.BillingState;
 import org.killbill.billing.util.email.templates.TemplateEngine;
@@ -51,6 +50,6 @@ public class OverdueEmailGenerator {
         data.put("nextOverdueState", nextOverdueState);
 
         // TODO single template for all languages for now
-        return templateEngine.executeTemplate(nextOverdueState.getEnterStateEmailNotification().getTemplateName(), data);
+        return templateEngine.executeTemplate(nextOverdueState.getEmailNotification().getTemplateName(), data);
     }
 }

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueStateApplicator.java b/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueStateApplicator.java
index cf3e203..7a5735a 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueStateApplicator.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueStateApplicator.java
@@ -44,10 +44,10 @@ import org.killbill.billing.entitlement.api.EntitlementApiException;
 import org.killbill.billing.events.OverdueChangeInternalEvent;
 import org.killbill.billing.junction.BlockingInternalApi;
 import org.killbill.billing.junction.DefaultBlockingState;
-import org.killbill.billing.overdue.OverdueApiException;
-import org.killbill.billing.overdue.OverdueCancellationPolicy;
 import org.killbill.billing.overdue.OverdueService;
-import org.killbill.billing.overdue.OverdueState;
+import org.killbill.billing.overdue.api.OverdueApiException;
+import org.killbill.billing.overdue.api.OverdueCancellationPolicy;
+import org.killbill.billing.overdue.api.OverdueState;
 import org.killbill.billing.overdue.config.api.BillingState;
 import org.killbill.billing.overdue.config.api.OverdueException;
 import org.killbill.billing.overdue.config.api.OverdueStateSet;
@@ -121,7 +121,7 @@ public class OverdueStateApplicator {
 
     public void apply(final OverdueStateSet overdueStateSet, final BillingState billingState,
                       final Account account, final OverdueState previousOverdueState,
-                      final OverdueState nextOverdueState, final InternalCallContext context) throws OverdueException {
+                      final OverdueState nextOverdueState, final InternalCallContext context) throws OverdueException, OverdueApiException {
         try {
 
             if (isAccountTaggedWith_OVERDUE_ENFORCEMENT_OFF(context)) {
@@ -137,7 +137,7 @@ public class OverdueStateApplicator {
                                                         (firstOverdueState != null && billingState != null && billingState.getDateOfEarliestUnpaidInvoice() != null);
 
             if (conditionForNextNotfication) {
-                final Period reevaluationInterval = nextOverdueState.isClearState() ? overdueStateSet.getInitialReevaluationInterval() : nextOverdueState.getReevaluationInterval();
+                final Period reevaluationInterval = nextOverdueState.isClearState() ? overdueStateSet.getInitialReevaluationInterval() : nextOverdueState.getAutoReevaluationInterval();
                 // If there is no configuration in the config, we assume this is because the overdue conditions are not time based and so there is nothing to retry
                 if (reevaluationInterval == null) {
                     log.debug("OverdueStateApplicator <notificationQ> : Missing InitialReevaluationInterval from config, NOT inserting notification for account " + account.getId());
@@ -258,15 +258,15 @@ public class OverdueStateApplicator {
     }
 
     private boolean blockChanges(final OverdueState nextOverdueState) {
-        return nextOverdueState.blockChanges();
+        return nextOverdueState.isBlockChanges();
     }
 
     private boolean blockBilling(final OverdueState nextOverdueState) {
-        return nextOverdueState.disableEntitlementAndChangesBlocked();
+        return nextOverdueState.isDisableEntitlementAndChangesBlocked();
     }
 
     private boolean blockEntitlement(final OverdueState nextOverdueState) {
-        return nextOverdueState.disableEntitlementAndChangesBlocked();
+        return nextOverdueState.isDisableEntitlementAndChangesBlocked();
     }
 
     protected void createFutureNotification(final Account account, final DateTime timeOfNextCheck, final InternalCallContext context) {
@@ -280,12 +280,12 @@ public class OverdueStateApplicator {
     }
 
     private void cancelSubscriptionsIfRequired(final Account account, final OverdueState nextOverdueState, final InternalCallContext context) throws OverdueException {
-        if (nextOverdueState.getSubscriptionCancellationPolicy() == OverdueCancellationPolicy.NONE) {
+        if (nextOverdueState.getOverdueCancellationPolicy() == OverdueCancellationPolicy.NONE) {
             return;
         }
         try {
             final BillingActionPolicy actionPolicy;
-            switch (nextOverdueState.getSubscriptionCancellationPolicy()) {
+            switch (nextOverdueState.getOverdueCancellationPolicy()) {
                 case END_OF_TERM:
                     actionPolicy = BillingActionPolicy.END_OF_TERM;
                     break;
@@ -293,7 +293,7 @@ public class OverdueStateApplicator {
                     actionPolicy = BillingActionPolicy.IMMEDIATE;
                     break;
                 default:
-                    throw new IllegalStateException("Unexpected OverdueCancellationPolicy " + nextOverdueState.getSubscriptionCancellationPolicy());
+                    throw new IllegalStateException("Unexpected OverdueCancellationPolicy " + nextOverdueState.getOverdueCancellationPolicy());
             }
             final List<Entitlement> toBeCancelled = new LinkedList<Entitlement>();
             computeEntitlementsToCancel(account, toBeCancelled, context);
@@ -335,19 +335,19 @@ public class OverdueStateApplicator {
         // The alternative would be to: throw new OverdueApiException(e, ErrorCode.EMAIL_SENDING_FAILED);
 
         // If sending is not configured, skip
-        if (nextOverdueState.getEnterStateEmailNotification() == null) {
+        if (nextOverdueState.getEmailNotification() == null) {
             return;
         }
 
         final List<String> to = ImmutableList.<String>of(account.getEmail());
         // TODO - should we look at the account CC: list?
         final List<String> cc = ImmutableList.<String>of();
-        final String subject = nextOverdueState.getEnterStateEmailNotification().getSubject();
+        final String subject = nextOverdueState.getEmailNotification().getSubject();
 
         try {
             // Generate and send the email
             final String emailBody = overdueEmailGenerator.generateEmail(account, billingState, account, nextOverdueState);
-            if (nextOverdueState.getEnterStateEmailNotification().isHTML()) {
+            if (nextOverdueState.getEmailNotification().isHTML()) {
                 emailSender.sendHTMLEmail(to, cc, subject, emailBody);
             } else {
                 emailSender.sendPlainTextEmail(to, cc, subject, emailBody);

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/calculator/BillingStateCalculator.java b/overdue/src/main/java/org/killbill/billing/overdue/calculator/BillingStateCalculator.java
index 80ca3cc..734264b 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/calculator/BillingStateCalculator.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/calculator/BillingStateCalculator.java
@@ -28,11 +28,11 @@ import org.joda.time.DateTimeZone;
 import org.joda.time.LocalDate;
 
 import org.killbill.billing.account.api.Account;
+import org.killbill.billing.payment.api.PaymentResponse;
 import org.killbill.clock.Clock;
 import org.killbill.billing.invoice.api.Invoice;
 import org.killbill.billing.overdue.config.api.BillingState;
 import org.killbill.billing.overdue.config.api.OverdueException;
-import org.killbill.billing.overdue.config.api.PaymentResponse;
 import org.killbill.billing.callcontext.InternalTenantContext;
 import org.killbill.billing.invoice.api.InvoiceInternalApi;
 import org.killbill.billing.util.tag.Tag;

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultDuration.java b/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultDuration.java
index 18bd8d7..dc259ff 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultDuration.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultDuration.java
@@ -29,7 +29,7 @@ import org.killbill.xmlloader.ValidatingConfig;
 import org.killbill.xmlloader.ValidationErrors;
 
 @XmlAccessorType(XmlAccessType.NONE)
-public class DefaultDuration extends ValidatingConfig<OverdueConfig> implements Duration {
+public class DefaultDuration extends ValidatingConfig<DefaultOverdueConfig> implements Duration {
     @XmlElement(required = true)
     private TimeUnit unit;
 
@@ -93,7 +93,7 @@ public class DefaultDuration extends ValidatingConfig<OverdueConfig> implements 
     }
 
     @Override
-    public ValidationErrors validate(final OverdueConfig catalog, final ValidationErrors errors) {
+    public ValidationErrors validate(final DefaultOverdueConfig catalog, final ValidationErrors errors) {
         //TODO MDW - Validation TimeUnit UNLIMITED iff number == -1
         return errors;
     }

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultEmailNotification.java b/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultEmailNotification.java
index 054a694..ea314cb 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultEmailNotification.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultEmailNotification.java
@@ -20,7 +20,7 @@ import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlElement;
 
-import org.killbill.billing.overdue.EmailNotification;
+import org.killbill.billing.overdue.api.EmailNotification;
 
 @XmlAccessorType(XmlAccessType.NONE)
 public class DefaultEmailNotification implements EmailNotification {

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultOverdueState.java b/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultOverdueState.java
index 13fd5cc..156ccec 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultOverdueState.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultOverdueState.java
@@ -23,24 +23,25 @@ import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlID;
 
 import org.joda.time.Period;
-
 import org.killbill.billing.ErrorCode;
 import org.killbill.billing.catalog.api.TimeUnit;
-import org.killbill.billing.overdue.EmailNotification;
-import org.killbill.billing.overdue.OverdueApiException;
-import org.killbill.billing.overdue.OverdueCancellationPolicy;
-import org.killbill.billing.overdue.OverdueState;
+import org.killbill.billing.overdue.ConditionEvaluation;
+import org.killbill.billing.overdue.api.EmailNotification;
+import org.killbill.billing.overdue.api.OverdueApiException;
+import org.killbill.billing.overdue.api.OverdueCancellationPolicy;
+import org.killbill.billing.overdue.api.OverdueCondition;
+import org.killbill.billing.overdue.api.OverdueState;
 import org.killbill.xmlloader.ValidatingConfig;
 import org.killbill.xmlloader.ValidationError;
 import org.killbill.xmlloader.ValidationErrors;
 
 @XmlAccessorType(XmlAccessType.NONE)
-public class DefaultOverdueState extends ValidatingConfig<OverdueConfig> implements OverdueState {
+public class DefaultOverdueState extends ValidatingConfig<DefaultOverdueConfig> implements OverdueState {
 
     private static final int MAX_NAME_LENGTH = 50;
 
     @XmlElement(required = false, name = "condition")
-    private DefaultCondition condition;
+    private DefaultOverdueCondition condition;
 
     @XmlAttribute(required = true, name = "name")
     @XmlID
@@ -74,6 +75,15 @@ public class DefaultOverdueState extends ValidatingConfig<OverdueConfig> impleme
     // - set payment retry interval
     // - backup payment mechanism?
 
+    public ConditionEvaluation getConditionEvaluation() {
+        return condition;
+    }
+
+    @Override
+    public OverdueCondition getOverdueCondition() {
+        return condition;
+    }
+
     @Override
     public String getName() {
         return name;
@@ -85,33 +95,28 @@ public class DefaultOverdueState extends ValidatingConfig<OverdueConfig> impleme
     }
 
     @Override
-    public boolean blockChanges() {
+    public boolean isBlockChanges() {
         return blockChanges || disableEntitlement;
     }
 
     @Override
-    public boolean disableEntitlementAndChangesBlocked() {
+    public boolean isDisableEntitlementAndChangesBlocked() {
         return disableEntitlement;
     }
 
     @Override
-    public OverdueCancellationPolicy getSubscriptionCancellationPolicy() {
+    public OverdueCancellationPolicy getOverdueCancellationPolicy() {
         return subscriptionCancellationPolicy;
     }
 
     @Override
-    public Period getReevaluationInterval() throws OverdueApiException {
+    public Period getAutoReevaluationInterval() throws OverdueApiException {
         if (autoReevaluationInterval == null || autoReevaluationInterval.getUnit() == TimeUnit.UNLIMITED || autoReevaluationInterval.getNumber() == 0) {
             throw new OverdueApiException(ErrorCode.OVERDUE_NO_REEVALUATION_INTERVAL, name);
         }
         return autoReevaluationInterval.toJodaPeriod();
     }
 
-    @Override
-    public DefaultCondition getCondition() {
-        return condition;
-    }
-
     protected DefaultOverdueState setName(final String name) {
         this.name = name;
         return this;
@@ -142,7 +147,7 @@ public class DefaultOverdueState extends ValidatingConfig<OverdueConfig> impleme
         return this;
     }
 
-    protected DefaultOverdueState setCondition(final DefaultCondition condition) {
+    protected DefaultOverdueState setCondition(final DefaultOverdueCondition condition) {
         this.condition = condition;
         return this;
     }
@@ -152,8 +157,9 @@ public class DefaultOverdueState extends ValidatingConfig<OverdueConfig> impleme
         return isClearState;
     }
 
+
     @Override
-    public ValidationErrors validate(final OverdueConfig root,
+    public ValidationErrors validate(final DefaultOverdueConfig root,
                                      final ValidationErrors errors) {
         if (name.length() > MAX_NAME_LENGTH) {
             errors.add(new ValidationError(String.format("Name of state '%s' exceeds the maximum length of %d", name, MAX_NAME_LENGTH), root.getURI(), DefaultOverdueState.class, name));
@@ -162,12 +168,7 @@ public class DefaultOverdueState extends ValidatingConfig<OverdueConfig> impleme
     }
 
     @Override
-    public int getDaysBetweenPaymentRetries() {
-        return 8;
-    }
-
-    @Override
-    public EmailNotification getEnterStateEmailNotification() {
+    public EmailNotification getEmailNotification() {
         return enterStateEmailNotification;
     }
 }

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultOverdueStateSet.java b/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultOverdueStateSet.java
index abf0518..522a065 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultOverdueStateSet.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/config/DefaultOverdueStateSet.java
@@ -23,8 +23,8 @@ import org.joda.time.LocalDate;
 import org.joda.time.Period;
 
 import org.killbill.billing.ErrorCode;
-import org.killbill.billing.overdue.OverdueApiException;
-import org.killbill.billing.overdue.OverdueState;
+import org.killbill.billing.overdue.api.OverdueApiException;
+import org.killbill.billing.overdue.api.OverdueState;
 import org.killbill.billing.overdue.config.api.BillingState;
 import org.killbill.billing.overdue.config.api.OverdueStateSet;
 import org.killbill.xmlloader.ValidatingConfig;
@@ -32,7 +32,7 @@ import org.killbill.xmlloader.ValidationErrors;
 import org.killbill.billing.junction.DefaultBlockingState;
 
 @XmlAccessorType(XmlAccessType.NONE)
-public abstract class DefaultOverdueStateSet extends ValidatingConfig<OverdueConfig> implements OverdueStateSet {
+public abstract class DefaultOverdueStateSet extends ValidatingConfig<DefaultOverdueConfig> implements OverdueStateSet {
 
     private static final Period ZERO_PERIOD = new Period();
     private final DefaultOverdueState clearState = new DefaultOverdueState().setName(DefaultBlockingState.CLEAR_STATE_NAME).setClearState(true);
@@ -64,7 +64,7 @@ public abstract class DefaultOverdueStateSet extends ValidatingConfig<OverdueCon
     @Override
     public DefaultOverdueState calculateOverdueState(final BillingState billingState, final LocalDate now) throws OverdueApiException {
         for (final DefaultOverdueState overdueState : getStates()) {
-            if (overdueState.getCondition() != null && overdueState.getCondition().evaluate(billingState, now)) {
+            if (overdueState.getConditionEvaluation() != null && overdueState.getConditionEvaluation().evaluate(billingState, now)) {
                 return overdueState;
             }
         }
@@ -72,7 +72,7 @@ public abstract class DefaultOverdueStateSet extends ValidatingConfig<OverdueCon
     }
 
     @Override
-    public ValidationErrors validate(final OverdueConfig root,
+    public ValidationErrors validate(final DefaultOverdueConfig root,
                                      final ValidationErrors errors) {
         for (final DefaultOverdueState state : getStates()) {
             state.validate(root, errors);

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/CreateOverdueConfigSchema.java b/overdue/src/main/java/org/killbill/billing/overdue/CreateOverdueConfigSchema.java
index 7ed3f66..6bc3060 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/CreateOverdueConfigSchema.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/CreateOverdueConfigSchema.java
@@ -20,7 +20,7 @@ import java.io.File;
 import java.io.FileWriter;
 import java.io.Writer;
 
-import org.killbill.billing.overdue.config.OverdueConfig;
+import org.killbill.billing.overdue.config.DefaultOverdueConfig;
 import org.killbill.xmlloader.XMLSchemaGenerator;
 
 public class CreateOverdueConfigSchema {
@@ -36,7 +36,7 @@ public class CreateOverdueConfigSchema {
 
         final File f = new File(args[0]);
         final Writer w = new FileWriter(f);
-        w.write(XMLSchemaGenerator.xmlSchemaAsString(OverdueConfig.class));
+        w.write(XMLSchemaGenerator.xmlSchemaAsString(DefaultOverdueConfig.class));
         w.close();
     }
 }

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/glue/DefaultOverdueModule.java b/overdue/src/main/java/org/killbill/billing/overdue/glue/DefaultOverdueModule.java
index d3a5b46..655674d 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/glue/DefaultOverdueModule.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/glue/DefaultOverdueModule.java
@@ -19,10 +19,12 @@
 package org.killbill.billing.overdue.glue;
 
 import org.killbill.billing.glue.OverdueModule;
+import org.killbill.billing.overdue.OverdueInternalApi;
 import org.killbill.billing.overdue.OverdueProperties;
 import org.killbill.billing.overdue.OverdueService;
-import org.killbill.billing.overdue.OverdueUserApi;
-import org.killbill.billing.overdue.api.DefaultOverdueUserApi;
+import org.killbill.billing.overdue.api.DefaultOverdueApi;
+import org.killbill.billing.overdue.api.DefaultOverdueInternalApi;
+import org.killbill.billing.overdue.api.OverdueApi;
 import org.killbill.billing.overdue.applicator.OverdueEmailGenerator;
 import org.killbill.billing.overdue.applicator.formatters.DefaultOverdueEmailFormatterFactory;
 import org.killbill.billing.overdue.applicator.formatters.OverdueEmailFormatterFactory;
@@ -86,6 +88,7 @@ public class DefaultOverdueModule extends KillBillModule implements OverdueModul
 
     @Override
     public void installOverdueUserApi() {
-        bind(OverdueUserApi.class).to(DefaultOverdueUserApi.class).asEagerSingleton();
+        bind(OverdueInternalApi.class).to(DefaultOverdueInternalApi.class).asEagerSingleton();
+        bind(OverdueApi.class).to(DefaultOverdueApi.class).asEagerSingleton();
     }
 }

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/listener/OverdueListener.java b/overdue/src/main/java/org/killbill/billing/overdue/listener/OverdueListener.java
index 2bcd2b8..dccb0b6 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/listener/OverdueListener.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/listener/OverdueListener.java
@@ -29,8 +29,8 @@ import org.killbill.billing.events.ControlTagDeletionInternalEvent;
 import org.killbill.billing.events.InvoiceAdjustmentInternalEvent;
 import org.killbill.billing.events.PaymentErrorInternalEvent;
 import org.killbill.billing.events.PaymentInfoInternalEvent;
+import org.killbill.billing.overdue.config.DefaultOverdueConfig;
 import org.killbill.billing.overdue.config.DefaultOverdueState;
-import org.killbill.billing.overdue.config.OverdueConfig;
 import org.killbill.billing.overdue.glue.DefaultOverdueModule;
 import org.killbill.billing.overdue.notification.OverdueAsyncBusNotificationKey;
 import org.killbill.billing.overdue.notification.OverdueAsyncBusNotificationKey.OverdueAsyncBusNotificationAction;
@@ -54,7 +54,7 @@ public class OverdueListener {
     private final OverduePoster asyncPoster;
     private final Clock clock;
 
-    private OverdueConfig config;
+    private DefaultOverdueConfig config;
 
     private static final Logger log = LoggerFactory.getLogger(OverdueListener.class);
 
@@ -110,12 +110,12 @@ public class OverdueListener {
 
     // Optimization: don't bother running the Overdue machinery if it's disabled
     private boolean shouldInsertNotification() {
-        if (config == null || config.getStateSet() == null || config.getStateSet().getStates() == null) {
+        if (config == null || config.getOverdueStatesAccount() == null || config.getOverdueStatesAccount().getStates() == null) {
             return false;
         }
 
-        for (final DefaultOverdueState state : config.getStateSet().getStates()) {
-            if (state.getCondition() != null) {
+        for (final DefaultOverdueState state : config.getOverdueStatesAccount().getStates()) {
+            if (state.getConditionEvaluation() != null) {
                 return true;
             }
         }
@@ -127,7 +127,7 @@ public class OverdueListener {
         return internalCallContextFactory.createInternalCallContext(tenantRecordId, accountRecordId, "OverdueService", CallOrigin.INTERNAL, UserType.SYSTEM, userToken);
     }
 
-    public void setOverdueConfig(final OverdueConfig config) {
+    public void setOverdueConfig(final DefaultOverdueConfig config) {
         this.config = config;
     }
 }

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/service/DefaultOverdueService.java b/overdue/src/main/java/org/killbill/billing/overdue/service/DefaultOverdueService.java
index b60fc57..ef5cfcf 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/service/DefaultOverdueService.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/service/DefaultOverdueService.java
@@ -24,11 +24,11 @@ import java.net.URISyntaxException;
 import javax.inject.Named;
 
 import org.killbill.billing.lifecycle.api.BusService;
+import org.killbill.billing.overdue.OverdueInternalApi;
 import org.killbill.billing.overdue.OverdueProperties;
 import org.killbill.billing.overdue.OverdueService;
-import org.killbill.billing.overdue.OverdueUserApi;
-import org.killbill.billing.overdue.api.DefaultOverdueUserApi;
-import org.killbill.billing.overdue.config.OverdueConfig;
+import org.killbill.billing.overdue.api.DefaultOverdueInternalApi;
+import org.killbill.billing.overdue.config.DefaultOverdueConfig;
 import org.killbill.billing.overdue.glue.DefaultOverdueModule;
 import org.killbill.billing.overdue.listener.OverdueListener;
 import org.killbill.billing.overdue.notification.OverdueNotifier;
@@ -48,7 +48,7 @@ public class DefaultOverdueService implements OverdueService {
 
     public static final String OVERDUE_SERVICE_NAME = "overdue-service";
 
-    private final OverdueUserApi userApi;
+    private final OverdueInternalApi userApi;
     private final OverdueProperties properties;
     private final OverdueNotifier asyncNotifier;
     private final OverdueNotifier checkNotifier;
@@ -56,12 +56,12 @@ public class DefaultOverdueService implements OverdueService {
     private final OverdueListener listener;
     private final OverdueWrapperFactory factory;
 
-    private OverdueConfig overdueConfig;
+    private DefaultOverdueConfig overdueConfig;
     private boolean isConfigLoaded;
 
     @Inject
     public DefaultOverdueService(
-            final OverdueUserApi userApi,
+            final OverdueInternalApi userApi,
             final OverdueProperties properties,
             @Named(DefaultOverdueModule.OVERDUE_NOTIFIER_CHECK_NAMED) final OverdueNotifier checkNotifier,
             @Named(DefaultOverdueModule.OVERDUE_NOTIFIER_ASYNC_BUS_NAMED) final OverdueNotifier asyncNotifier,
@@ -84,7 +84,7 @@ public class DefaultOverdueService implements OverdueService {
     }
 
     @Override
-    public OverdueUserApi getUserApi() {
+    public OverdueInternalApi getUserApi() {
         return userApi;
     }
 
@@ -93,20 +93,20 @@ public class DefaultOverdueService implements OverdueService {
         if (!isConfigLoaded) {
             try {
                 final URI u = new URI(properties.getConfigURI());
-                overdueConfig = XMLLoader.getObjectFromUri(u, OverdueConfig.class);
+                overdueConfig = XMLLoader.getObjectFromUri(u, DefaultOverdueConfig.class);
                 // File not found?
                 if (overdueConfig == null) {
                     log.warn("Overdue system disabled: unable to load the overdue config from " + properties.getConfigURI());
-                    overdueConfig = new OverdueConfig();
+                    overdueConfig = new DefaultOverdueConfig();
                 }
 
                 isConfigLoaded = true;
             } catch (final URISyntaxException e) {
                 log.warn("Overdue system disabled: unable to load the overdue config from " + properties.getConfigURI(), e);
-                overdueConfig = new OverdueConfig();
+                overdueConfig = new DefaultOverdueConfig();
             } catch (final IllegalArgumentException e) {
                 log.warn("Overdue system disabled: unable to load the overdue config from " + properties.getConfigURI(), e);
-                overdueConfig = new OverdueConfig();
+                overdueConfig = new DefaultOverdueConfig();
             } catch (final Exception e) {
                 log.warn("Unable to load the overdue config from " + properties.getConfigURI(), e);
                 throw new ServiceException(e);
@@ -114,7 +114,7 @@ public class DefaultOverdueService implements OverdueService {
 
             factory.setOverdueConfig(overdueConfig);
             listener.setOverdueConfig(overdueConfig);
-            ((DefaultOverdueUserApi) userApi).setOverdueConfig(overdueConfig);
+            ((DefaultOverdueInternalApi) userApi).setOverdueConfig(overdueConfig);
         }
     }
 

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/wrapper/OverdueWrapper.java b/overdue/src/main/java/org/killbill/billing/overdue/wrapper/OverdueWrapper.java
index 70e572c..1439ae5 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/wrapper/OverdueWrapper.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/wrapper/OverdueWrapper.java
@@ -19,17 +19,17 @@ package org.killbill.billing.overdue.wrapper;
 import org.killbill.billing.account.api.Account;
 import org.killbill.billing.callcontext.InternalCallContext;
 import org.killbill.billing.callcontext.InternalTenantContext;
-import org.killbill.clock.Clock;
 import org.killbill.billing.entitlement.api.BlockingStateType;
 import org.killbill.billing.junction.BlockingInternalApi;
-import org.killbill.billing.overdue.OverdueApiException;
 import org.killbill.billing.overdue.OverdueService;
-import org.killbill.billing.overdue.OverdueState;
+import org.killbill.billing.overdue.api.OverdueApiException;
+import org.killbill.billing.overdue.api.OverdueState;
 import org.killbill.billing.overdue.applicator.OverdueStateApplicator;
 import org.killbill.billing.overdue.calculator.BillingStateCalculator;
 import org.killbill.billing.overdue.config.api.BillingState;
 import org.killbill.billing.overdue.config.api.OverdueException;
 import org.killbill.billing.overdue.config.api.OverdueStateSet;
+import org.killbill.clock.Clock;
 
 public class OverdueWrapper {
 

diff --git a/overdue/src/main/java/org/killbill/billing/overdue/wrapper/OverdueWrapperFactory.java b/overdue/src/main/java/org/killbill/billing/overdue/wrapper/OverdueWrapperFactory.java
index 5f8323b..c234726 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/wrapper/OverdueWrapperFactory.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/wrapper/OverdueWrapperFactory.java
@@ -19,6 +19,7 @@ package org.killbill.billing.overdue.wrapper;
 import java.util.UUID;
 
 import org.joda.time.Period;
+import org.killbill.billing.overdue.config.DefaultOverdueConfig;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -27,10 +28,8 @@ import org.killbill.billing.account.api.AccountApiException;
 import org.killbill.clock.Clock;
 import org.killbill.billing.overdue.applicator.OverdueStateApplicator;
 import org.killbill.billing.overdue.calculator.BillingStateCalculator;
-import org.killbill.billing.overdue.config.DefaultDuration;
 import org.killbill.billing.overdue.config.DefaultOverdueState;
 import org.killbill.billing.overdue.config.DefaultOverdueStateSet;
-import org.killbill.billing.overdue.config.OverdueConfig;
 import org.killbill.billing.overdue.config.api.OverdueException;
 import org.killbill.billing.overdue.config.api.OverdueStateSet;
 import org.killbill.billing.callcontext.InternalTenantContext;
@@ -48,7 +47,7 @@ public class OverdueWrapperFactory {
     private final OverdueStateApplicator overdueStateApplicator;
     private final BlockingInternalApi api;
     private final Clock clock;
-    private OverdueConfig config;
+    private DefaultOverdueConfig config;
 
     @Inject
     public OverdueWrapperFactory(final BlockingInternalApi api, final Clock clock,
@@ -82,7 +81,7 @@ public class OverdueWrapperFactory {
     }
 
     private OverdueStateSet getOverdueStateSet() {
-        if (config == null || config.getStateSet() == null) {
+        if (config == null || config.getOverdueStatesAccount() == null) {
             return new DefaultOverdueStateSet() {
 
                 @SuppressWarnings("unchecked")
@@ -97,11 +96,11 @@ public class OverdueWrapperFactory {
                 }
             };
         } else {
-            return config.getStateSet();
+            return config.getOverdueStatesAccount();
         }
     }
 
-    public void setOverdueConfig(final OverdueConfig config) {
+    public void setOverdueConfig(final DefaultOverdueConfig config) {
         this.config = config;
     }
 

diff --git a/overdue/src/test/java/org/killbill/billing/overdue/applicator/TestOverdueStateApplicator.java b/overdue/src/test/java/org/killbill/billing/overdue/applicator/TestOverdueStateApplicator.java
index 11c2201..457696e 100644
--- a/overdue/src/test/java/org/killbill/billing/overdue/applicator/TestOverdueStateApplicator.java
+++ b/overdue/src/test/java/org/killbill/billing/overdue/applicator/TestOverdueStateApplicator.java
@@ -22,14 +22,14 @@ import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.Callable;
 
+import org.killbill.billing.overdue.api.OverdueState;
+import org.killbill.billing.overdue.config.DefaultOverdueConfig;
 import org.mockito.Mockito;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
 import org.killbill.billing.account.api.Account;
-import org.killbill.billing.overdue.OverdueState;
 import org.killbill.billing.overdue.OverdueTestSuiteWithEmbeddedDB;
-import org.killbill.billing.overdue.config.OverdueConfig;
 import org.killbill.billing.overdue.config.api.OverdueStateSet;
 import org.killbill.xmlloader.XMLLoader;
 import org.killbill.billing.events.OverdueChangeInternalEvent;
@@ -43,27 +43,27 @@ public class TestOverdueStateApplicator extends OverdueTestSuiteWithEmbeddedDB {
     @Test(groups = "slow")
     public void testApplicator() throws Exception {
         final InputStream is = new ByteArrayInputStream(testOverdueHelper.getConfigXml().getBytes());
-        final OverdueConfig config = XMLLoader.getObjectFromStreamNoValidation(is, OverdueConfig.class);
+        final DefaultOverdueConfig config = XMLLoader.getObjectFromStreamNoValidation(is, DefaultOverdueConfig.class);
         overdueWrapperFactory.setOverdueConfig(config);
 
         final Account account = Mockito.mock(Account.class);
         Mockito.when(account.getId()).thenReturn(UUID.randomUUID());
 
-        final OverdueStateSet overdueStateSet = config.getStateSet();
-        final OverdueState clearState = config.getStateSet().findState(DefaultBlockingState.CLEAR_STATE_NAME);
+        final OverdueStateSet overdueStateSet = config.getOverdueStatesAccount();
+        final OverdueState clearState = config.getOverdueStatesAccount().findState(DefaultBlockingState.CLEAR_STATE_NAME);
         OverdueState state;
 
-        state = config.getStateSet().findState("OD1");
+        state = config.getOverdueStatesAccount().findState("OD1");
         applicator.apply(overdueStateSet, null, account, clearState, state, internalCallContext);
         testOverdueHelper.checkStateApplied(state);
         checkBussEvent("OD1");
 
-        state = config.getStateSet().findState("OD2");
+        state = config.getOverdueStatesAccount().findState("OD2");
         applicator.apply(overdueStateSet, null, account, clearState, state, internalCallContext);
         testOverdueHelper.checkStateApplied(state);
         checkBussEvent("OD2");
 
-        state = config.getStateSet().findState("OD3");
+        state = config.getOverdueStatesAccount().findState("OD3");
         applicator.apply(overdueStateSet, null, account, clearState, state, internalCallContext);
         testOverdueHelper.checkStateApplied(state);
         checkBussEvent("OD3");

diff --git a/overdue/src/test/java/org/killbill/billing/overdue/config/io/TestReadConfig.java b/overdue/src/test/java/org/killbill/billing/overdue/config/io/TestReadConfig.java
index f3cdfe5..13255fe 100644
--- a/overdue/src/test/java/org/killbill/billing/overdue/config/io/TestReadConfig.java
+++ b/overdue/src/test/java/org/killbill/billing/overdue/config/io/TestReadConfig.java
@@ -16,10 +16,10 @@
 
 package org.killbill.billing.overdue.config.io;
 
+import org.killbill.billing.overdue.config.DefaultOverdueConfig;
 import org.testng.annotations.Test;
 
 import org.killbill.billing.overdue.OverdueTestSuiteNoDB;
-import org.killbill.billing.overdue.config.OverdueConfig;
 import org.killbill.xmlloader.XMLLoader;
 
 import com.google.common.io.Resources;
@@ -28,6 +28,6 @@ public class TestReadConfig extends OverdueTestSuiteNoDB {
 
     @Test(groups = "fast")
     public void testConfigLoad() throws Exception {
-        XMLLoader.getObjectFromString(Resources.getResource("OverdueConfig.xml").toExternalForm(), OverdueConfig.class);
+        XMLLoader.getObjectFromString(Resources.getResource("OverdueConfig.xml").toExternalForm(), DefaultOverdueConfig.class);
     }
 }

diff --git a/overdue/src/test/java/org/killbill/billing/overdue/config/MockOverdueRules.java b/overdue/src/test/java/org/killbill/billing/overdue/config/MockOverdueRules.java
index 9c4ea10..091ea55 100644
--- a/overdue/src/test/java/org/killbill/billing/overdue/config/MockOverdueRules.java
+++ b/overdue/src/test/java/org/killbill/billing/overdue/config/MockOverdueRules.java
@@ -16,13 +16,13 @@
 
 package org.killbill.billing.overdue.config;
 
-public class MockOverdueRules extends OverdueConfig {
+public class MockOverdueRules extends DefaultOverdueConfig {
 
     public static final String CLEAR_STATE = "Clear";
 
     @SuppressWarnings("unchecked")
     public MockOverdueRules() {
-        final OverdueStatesAccount bundleODS = new OverdueStatesAccount();
+        final DefaultOverdueStatesAccount bundleODS = new DefaultOverdueStatesAccount();
         bundleODS.setAccountOverdueStates(new DefaultOverdueState[]{new DefaultOverdueState().setName(CLEAR_STATE)});
         setOverdueStates(bundleODS);
 

diff --git a/overdue/src/test/java/org/killbill/billing/overdue/config/TestCondition.java b/overdue/src/test/java/org/killbill/billing/overdue/config/TestCondition.java
index c856e6a..1e6ee8c 100644
--- a/overdue/src/test/java/org/killbill/billing/overdue/config/TestCondition.java
+++ b/overdue/src/test/java/org/killbill/billing/overdue/config/TestCondition.java
@@ -25,13 +25,13 @@ import javax.xml.bind.annotation.XmlRootElement;
 
 import org.joda.time.DateTimeZone;
 import org.joda.time.LocalDate;
+import org.killbill.billing.payment.api.PaymentResponse;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
 import org.killbill.billing.ObjectType;
 import org.killbill.billing.overdue.OverdueTestSuiteNoDB;
 import org.killbill.billing.overdue.config.api.BillingState;
-import org.killbill.billing.overdue.config.api.PaymentResponse;
 import org.killbill.xmlloader.XMLLoader;
 import org.killbill.billing.util.tag.ControlTagType;
 import org.killbill.billing.util.tag.DefaultControlTag;
@@ -41,7 +41,7 @@ import org.killbill.billing.util.tag.Tag;
 public class TestCondition extends OverdueTestSuiteNoDB {
 
     @XmlRootElement(name = "condition")
-    private static class MockCondition extends DefaultCondition {}
+    private static class MockCondition extends DefaultOverdueCondition {}
 
     @Test(groups = "fast")
     public void testNumberOfUnpaidInvoicesEqualsOrExceeds() throws Exception {

diff --git a/overdue/src/test/java/org/killbill/billing/overdue/config/TestOverdueConfig.java b/overdue/src/test/java/org/killbill/billing/overdue/config/TestOverdueConfig.java
index 48dc0f3..c15f26f 100644
--- a/overdue/src/test/java/org/killbill/billing/overdue/config/TestOverdueConfig.java
+++ b/overdue/src/test/java/org/killbill/billing/overdue/config/TestOverdueConfig.java
@@ -19,11 +19,10 @@ package org.killbill.billing.overdue.config;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 
+import org.killbill.billing.overdue.api.EmailNotification;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
-import org.killbill.billing.catalog.api.TimeUnit;
-import org.killbill.billing.overdue.EmailNotification;
 import org.killbill.billing.overdue.OverdueTestSuiteNoDB;
 import org.killbill.xmlloader.XMLLoader;
 
@@ -68,15 +67,15 @@ public class TestOverdueConfig extends OverdueTestSuiteNoDB {
                            "   </accountOverdueStates>" +
                            "</overdueConfig>";
         final InputStream is = new ByteArrayInputStream(xml.getBytes());
-        final OverdueConfig c = XMLLoader.getObjectFromStreamNoValidation(is, OverdueConfig.class);
-        Assert.assertEquals(c.getStateSet().size(), 2);
+        final DefaultOverdueConfig c = XMLLoader.getObjectFromStreamNoValidation(is, DefaultOverdueConfig.class);
+        Assert.assertEquals(c.getOverdueStatesAccount().size(), 2);
 
-        Assert.assertNull(c.getStateSet().getStates()[0].getEnterStateEmailNotification());
+        Assert.assertNull(c.getOverdueStatesAccount().getStates()[0].getEmailNotification());
 
-        Assert.assertNotNull(c.getStateSet().getInitialReevaluationInterval());
-        Assert.assertEquals(c.getStateSet().getInitialReevaluationInterval().getDays(), 1);
+        Assert.assertNotNull(c.getOverdueStatesAccount().getInitialReevaluationInterval());
+        Assert.assertEquals(c.getOverdueStatesAccount().getInitialReevaluationInterval().getDays(), 1);
 
-        final EmailNotification secondNotification = c.getStateSet().getStates()[1].getEnterStateEmailNotification();
+        final EmailNotification secondNotification = c.getOverdueStatesAccount().getStates()[1].getEmailNotification();
         Assert.assertEquals(secondNotification.getSubject(), "ToTo");
         Assert.assertEquals(secondNotification.getTemplateName(), "Titi");
         Assert.assertFalse(secondNotification.isHTML());

diff --git a/overdue/src/test/java/org/killbill/billing/overdue/OverdueTestSuiteNoDB.java b/overdue/src/test/java/org/killbill/billing/overdue/OverdueTestSuiteNoDB.java
index 0ecdf61..4bb38a8 100644
--- a/overdue/src/test/java/org/killbill/billing/overdue/OverdueTestSuiteNoDB.java
+++ b/overdue/src/test/java/org/killbill/billing/overdue/OverdueTestSuiteNoDB.java
@@ -82,7 +82,7 @@ public abstract class OverdueTestSuiteNoDB extends GuicyKillbillTestSuiteNoDB {
     @Inject
     protected OverdueStateApplicator applicator;
     @Inject
-    protected OverdueUserApi overdueApi;
+    protected OverdueInternalApi overdueApi;
     @Inject
     protected OverdueProperties overdueProperties;
     @Inject

diff --git a/overdue/src/test/java/org/killbill/billing/overdue/OverdueTestSuiteWithEmbeddedDB.java b/overdue/src/test/java/org/killbill/billing/overdue/OverdueTestSuiteWithEmbeddedDB.java
index 4a27afc..b89b3c0 100644
--- a/overdue/src/test/java/org/killbill/billing/overdue/OverdueTestSuiteWithEmbeddedDB.java
+++ b/overdue/src/test/java/org/killbill/billing/overdue/OverdueTestSuiteWithEmbeddedDB.java
@@ -86,7 +86,7 @@ public abstract class OverdueTestSuiteWithEmbeddedDB extends GuicyKillbillTestSu
     @Inject
     protected OverdueStateApplicator applicator;
     @Inject
-    protected OverdueUserApi overdueApi;
+    protected OverdueInternalApi overdueApi;
     @Inject
     protected OverdueProperties overdueProperties;
     @Inject

diff --git a/overdue/src/test/java/org/killbill/billing/overdue/TestOverdueHelper.java b/overdue/src/test/java/org/killbill/billing/overdue/TestOverdueHelper.java
index 5f49aba..b8ebdb2 100644
--- a/overdue/src/test/java/org/killbill/billing/overdue/TestOverdueHelper.java
+++ b/overdue/src/test/java/org/killbill/billing/overdue/TestOverdueHelper.java
@@ -23,6 +23,7 @@ import java.util.UUID;
 
 import org.joda.time.DateTimeZone;
 import org.joda.time.LocalDate;
+import org.killbill.billing.overdue.api.OverdueState;
 import org.mockito.Mockito;
 import org.testng.Assert;
 
@@ -110,9 +111,9 @@ public class TestOverdueHelper {
 
     public void checkStateApplied(final BlockingState result, final OverdueState state) {
         Assert.assertEquals(result.getStateName(), state.getName());
-        Assert.assertEquals(result.isBlockChange(), state.blockChanges());
-        Assert.assertEquals(result.isBlockEntitlement(), state.disableEntitlementAndChangesBlocked());
-        Assert.assertEquals(result.isBlockBilling(), state.disableEntitlementAndChangesBlocked());
+        Assert.assertEquals(result.isBlockChange(), state.isBlockChanges());
+        Assert.assertEquals(result.isBlockEntitlement(), state.isDisableEntitlementAndChangesBlocked());
+        Assert.assertEquals(result.isBlockBilling(), state.isDisableEntitlementAndChangesBlocked());
     }
 
     public Account createAccount(final LocalDate dateOfLastUnPaidInvoice) throws SubscriptionBaseApiException, AccountApiException {

diff --git a/overdue/src/test/java/org/killbill/billing/overdue/wrapper/TestOverdueWrapper.java b/overdue/src/test/java/org/killbill/billing/overdue/wrapper/TestOverdueWrapper.java
index dcfe139..644e19f 100644
--- a/overdue/src/test/java/org/killbill/billing/overdue/wrapper/TestOverdueWrapper.java
+++ b/overdue/src/test/java/org/killbill/billing/overdue/wrapper/TestOverdueWrapper.java
@@ -19,13 +19,13 @@ package org.killbill.billing.overdue.wrapper;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 
+import org.killbill.billing.overdue.api.OverdueState;
+import org.killbill.billing.overdue.config.DefaultOverdueConfig;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
 import org.killbill.billing.account.api.Account;
-import org.killbill.billing.overdue.OverdueState;
 import org.killbill.billing.overdue.OverdueTestSuiteWithEmbeddedDB;
-import org.killbill.billing.overdue.config.OverdueConfig;
 import org.killbill.xmlloader.XMLLoader;
 import org.killbill.billing.junction.DefaultBlockingState;
 
@@ -34,26 +34,26 @@ public class TestOverdueWrapper extends OverdueTestSuiteWithEmbeddedDB {
     @Test(groups = "slow")
     public void testWrapperBasic() throws Exception {
         final InputStream is = new ByteArrayInputStream(testOverdueHelper.getConfigXml().getBytes());
-        final OverdueConfig config = XMLLoader.getObjectFromStreamNoValidation(is, OverdueConfig.class);
+        final DefaultOverdueConfig config = XMLLoader.getObjectFromStreamNoValidation(is, DefaultOverdueConfig.class);
         overdueWrapperFactory.setOverdueConfig(config);
 
         Account account;
         OverdueWrapper wrapper;
         OverdueState state;
 
-        state = config.getStateSet().findState("OD1");
+        state = config.getOverdueStatesAccount().findState("OD1");
         account = testOverdueHelper.createAccount(clock.getUTCToday().minusDays(31));
         wrapper = overdueWrapperFactory.createOverdueWrapperFor(account);
         wrapper.refresh(internalCallContext);
         testOverdueHelper.checkStateApplied(state);
 
-        state = config.getStateSet().findState("OD2");
+        state = config.getOverdueStatesAccount().findState("OD2");
         account = testOverdueHelper.createAccount(clock.getUTCToday().minusDays(41));
         wrapper = overdueWrapperFactory.createOverdueWrapperFor(account);
         wrapper.refresh(internalCallContext);
         testOverdueHelper.checkStateApplied(state);
 
-        state = config.getStateSet().findState("OD3");
+        state = config.getOverdueStatesAccount().findState("OD3");
         account = testOverdueHelper.createAccount(clock.getUTCToday().minusDays(51));
         wrapper = overdueWrapperFactory.createOverdueWrapperFor(account);
         wrapper.refresh(internalCallContext);
@@ -69,14 +69,14 @@ public class TestOverdueWrapper extends OverdueTestSuiteWithEmbeddedDB {
         final OverdueState state;
 
         final InputStream is = new ByteArrayInputStream(testOverdueHelper.getConfigXml().getBytes());
-        final OverdueConfig config = XMLLoader.getObjectFromStreamNoValidation(is, OverdueConfig.class);
-        state = config.getStateSet().findState(DefaultBlockingState.CLEAR_STATE_NAME);
+        final DefaultOverdueConfig config = XMLLoader.getObjectFromStreamNoValidation(is, DefaultOverdueConfig.class);
+        state = config.getOverdueStatesAccount().findState(DefaultBlockingState.CLEAR_STATE_NAME);
         account = testOverdueHelper.createAccount(clock.getUTCToday().minusDays(31));
         wrapper = overdueWrapperFactory.createOverdueWrapperFor(account);
         final OverdueState result = wrapper.refresh(internalCallContext);
 
         Assert.assertEquals(result.getName(), state.getName());
-        Assert.assertEquals(result.blockChanges(), state.blockChanges());
-        Assert.assertEquals(result.disableEntitlementAndChangesBlocked(), state.disableEntitlementAndChangesBlocked());
+        Assert.assertEquals(result.isBlockChanges(), state.isBlockChanges());
+        Assert.assertEquals(result.isDisableEntitlementAndChangesBlocked(), state.isDisableEntitlementAndChangesBlocked());
     }
 }

diff --git a/util/src/test/java/org/killbill/billing/mock/glue/MockOverdueModule.java b/util/src/test/java/org/killbill/billing/mock/glue/MockOverdueModule.java
index a2085a9..3749060 100644
--- a/util/src/test/java/org/killbill/billing/mock/glue/MockOverdueModule.java
+++ b/util/src/test/java/org/killbill/billing/mock/glue/MockOverdueModule.java
@@ -19,7 +19,8 @@
 package org.killbill.billing.mock.glue;
 
 import org.killbill.billing.glue.OverdueModule;
-import org.killbill.billing.overdue.OverdueUserApi;
+import org.killbill.billing.overdue.OverdueInternalApi;
+import org.killbill.billing.overdue.api.OverdueApi;
 import org.killbill.billing.platform.api.KillbillConfigSource;
 import org.killbill.billing.util.glue.KillBillModule;
 import org.mockito.Mockito;
@@ -32,7 +33,8 @@ public class MockOverdueModule extends KillBillModule implements OverdueModule {
 
     @Override
     public void installOverdueUserApi() {
-        bind(OverdueUserApi.class).toInstance(Mockito.mock(OverdueUserApi.class));
+        bind(OverdueInternalApi.class).toInstance(Mockito.mock(OverdueInternalApi.class));
+        bind(OverdueApi.class).toInstance(Mockito.mock(OverdueApi.class));
     }
 
     @Override