docs: public boolean insertBlockingEvents(final SortedSet<BillingEvent> billingEvents, final Set<UUID> skippedSubscriptions, final Map<UUID, List<SubscriptionBase>> subscriptionsForAccount, final Catalog catalog, final InternalTenantContext context) throws CatalogApiException {
          if (billingEvents.size() <= 0) {
              return false;
          }
  
          final SortedSet<BillingEvent> billingEventsToAdd = new TreeSet<BillingEvent>();
          final SortedSet<BillingEvent> billingEventsToRemove = new TreeSet<BillingEvent>();
  
          final List<BlockingState> blockingEvents = blockingApi.getBlockingAllForAccount(catalog, context);
  
          final Iterable<BlockingState> accountBlockingEvents = Iterables.filter(blockingEvents, new Predicate<BlockingState>() {
              @Override
              public boolean apply(final BlockingState input) {
                  return BlockingStateType.ACCOUNT == input.getType();
              }
          });
  
          final Map<UUID, List<BlockingState>> perBundleBlockingEvents = getPerTypeBlockingEvents(BlockingStateType.SUBSCRIPTION_BUNDLE, blockingEvents);
          final Map<UUID, List<BlockingState>> perSubscriptionBlockingEvents = getPerTypeBlockingEvents(BlockingStateType.SUBSCRIPTION, blockingEvents);
  
          for (final UUID bundleId : subscriptionsForAccount.keySet()) {
  
              final List<BlockingState> bundleBlockingEvents = perBundleBlockingEvents.get(bundleId) != null ? perBundleBlockingEvents.get(bundleId) : ImmutableList.<BlockingState>of();
  
              for (final SubscriptionBase subscription : subscriptionsForAccount.get(bundleId)) {
                  // Avoid inserting additional events for subscriptions that don't even have a START event
                  if (skippedSubscriptions.contains(subscription.getId())) {
                      continue;
                  }
  
                  final List<BlockingState> subscriptionBlockingEvents = perSubscriptionBlockingEvents.get(subscription.getId()) != null ? perSubscriptionBlockingEvents.get(subscription.getId()) : ImmutableList.<BlockingState>of();
                  final List<BlockingState> aggregateSubscriptionBlockingEvents = getAggregateBlockingEventsPerSubscription(subscription.getEndDate(), subscriptionBlockingEvents, bundleBlockingEvents, accountBlockingEvents);
                  final List<DisabledDuration> accountBlockingDurations = createBlockingDurations(aggregateSubscriptionBlockingEvents);
  
                  final SortedSet<BillingEvent> subscriptionBillingEvents = filter(billingEvents, subscription);
  
                  final SortedSet<BillingEvent> newEvents = createNewEvents(accountBlockingDurations, subscriptionBillingEvents, catalog, context);
                  billingEventsToAdd.addAll(newEvents);
  
                  final SortedSet<BillingEvent> removedEvents = eventsToRemove(accountBlockingDurations, subscriptionBillingEvents);
                  billingEventsToRemove.addAll(removedEvents);
              }
          }
  
          for (final BillingEvent eventToAdd : billingEventsToAdd) {
              billingEvents.add(eventToAdd);
          }
  
          for (final BillingEvent eventToRemove : billingEventsToRemove) {
              billingEvents.remove(eventToRemove);
          }
  
          return !(billingEventsToAdd.isEmpty() && billingEventsToRemove.isEmpty());
      }