@otr-app/shared-backend-generated-client 3.0.5-experimental → 4.0.0

package/dist/otrBackendService.js

@@ -236,6 +236,7 @@ angular.module('otrBackendService', [])
              * @param {boolean} parameters.hasProfilePicture - hasProfilePicture
              * @param {integer} parameters.limit - limit
              * @param {string} parameters.nextPageToken - nextPageToken
+             * @param {boolean} parameters.preferredRegionCode - preferredRegionCode
              * @param {string} parameters.previousPageToken - previousPageToken
              * @param {string} parameters.regionCode - regionCode
              */
@@ -278,6 +279,10 @@ angular.module('otrBackendService', [])
                     queryParameters['nextPageToken'] = parameters['nextPageToken'];
                 }
 
+                if (parameters['preferredRegionCode'] !== undefined) {
+                    queryParameters['preferredRegionCode'] = parameters['preferredRegionCode'];
+                }
+
                 if (parameters['previousPageToken'] !== undefined) {
                     queryParameters['previousPageToken'] = parameters['previousPageToken'];
                 }
@@ -675,10 +680,11 @@ angular.module('otrBackendService', [])
              * @method
              * @name OtrService#listBillingProductsUsingGET
              * @param {object} parameters - method options and parameters
-             * @param {boolean} parameters.active - active
-             * @param {string} parameters.audience - audience
-             * @param {integer} parameters.limit - limit
-             * @param {string} parameters.userId - userId
+                 * @param {boolean} parameters.active - active
+                 * @param {string} parameters.audience - audience
+                 * @param {integer} parameters.limit - limit
+                
+                 * @param {string} parameters.userId - userId
              */
             OtrService.prototype.listBillingProductsUsingGET = function(parameters) {
                 if (parameters === undefined) {
@@ -712,6 +718,8 @@ angular.module('otrBackendService', [])
                     queryParameters['limit'] = parameters['limit'];
                 }
 
+                queryParameters['promoOfferCampaign'] = 'FALL_2025_OFFER';
+
                 if (parameters['userId'] !== undefined) {
                     queryParameters['userId'] = parameters['userId'];
                 }
@@ -1006,43 +1014,6 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
-            /**
-             * handleBounceComplaintEmails
-             * @method
-             * @name OtrService#handleBounceComplaintEmailsUsingPOST
-             * @param {object} parameters - method options and parameters
-             * @param {} parameters.request - request
-             */
-            OtrService.prototype.handleBounceComplaintEmailsUsingPOST = function(parameters) {
-                if (parameters === undefined) {
-                    parameters = {};
-                }
-                var deferred = $q.defer();
-                var domain = this.domain,
-                    path = '/api/v1/blacklists/ses/emails/';
-                var body = {},
-                    queryParameters = {},
-                    headers = {},
-                    form = {};
-
-                headers['Accept'] = ['*/*'];
-                headers['Content-Type'] = ['application/json,text/plain'];
-
-                if (parameters['request'] !== undefined) {
-                    body = parameters['request'];
-                }
-
-                if (parameters['request'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: request'));
-                    return deferred.promise;
-                }
-
-                queryParameters = mergeQueryParams(parameters, queryParameters);
-
-                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
-
-                return deferred.promise;
-            };
             /**
              * createBranchLink
              * @method
@@ -1179,6 +1150,48 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * deleteCaseUser
+             * @method
+             * @name OtrService#deleteCaseUserUsingDELETE
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.caseId - caseId
+             * @param {integer} parameters.caseUsersId - caseUsersId
+             */
+            OtrService.prototype.deleteCaseUserUsingDELETE = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/case-users/{caseUsersId}/cases/{caseId}';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                path = path.replace('{caseId}', parameters['caseId']);
+
+                if (parameters['caseId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: caseId'));
+                    return deferred.promise;
+                }
+
+                path = path.replace('{caseUsersId}', parameters['caseUsersId']);
+
+                if (parameters['caseUsersId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: caseUsersId'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('DELETE', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * getAllActions
              * @method
@@ -1316,6 +1329,51 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * setTyping
+             * @method
+             * @name OtrService#setTypingUsingPUT
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.caseId - caseId
+             * @param {string} parameters.connectionId - connectionId
+             */
+            OtrService.prototype.setTypingUsingPUT = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/cases/conversation/typing/{caseId}';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                path = path.replace('{caseId}', parameters['caseId']);
+
+                if (parameters['caseId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: caseId'));
+                    return deferred.promise;
+                }
+
+                if (parameters['connectionId'] !== undefined) {
+                    headers['connectionId'] = parameters['connectionId'];
+                }
+
+                if (parameters['connectionId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: connectionId'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('PUT', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * getCaseCounterOptions
              * @method
@@ -1405,6 +1463,43 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * acceptParticipantInvite
+             * @method
+             * @name OtrService#acceptParticipantInviteUsingPUT
+             * @param {object} parameters - method options and parameters
+             * @param {} parameters.request - request
+             */
+            OtrService.prototype.acceptParticipantInviteUsingPUT = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/cases/participants/accept-invite';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                if (parameters['request'] !== undefined) {
+                    body = parameters['request'];
+                }
+
+                if (parameters['request'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: request'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('PUT', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * getPendingCases
              * @method
@@ -1941,8 +2036,7 @@ angular.module('otrBackendService', [])
              * @name OtrService#getConversationUsingGET
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
-             * @param {integer} parameters.length - length
-             * @param {integer} parameters.page - page
+             * @param {boolean} parameters.includeActions - includeActions
              */
             OtrService.prototype.getConversationUsingGET = function(parameters) {
                 if (parameters === undefined) {
@@ -1965,15 +2059,8 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
-                /** set default value **/
-                queryParameters['length'] = 9999;
-
-                if (parameters['length'] !== undefined) {
-                    queryParameters['length'] = parameters['length'];
-                }
-
-                if (parameters['page'] !== undefined) {
-                    queryParameters['page'] = parameters['page'];
+                if (parameters['includeActions'] !== undefined) {
+                    queryParameters['includeActions'] = parameters['includeActions'];
                 }
 
                 queryParameters = mergeQueryParams(parameters, queryParameters);
@@ -2491,8 +2578,6 @@ angular.module('otrBackendService', [])
              * @name OtrService#listCostItemsForCustomerUsingGET
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
-             * @param {string} parameters.period - period
-             * @param {string} parameters.productId - productId
              */
             OtrService.prototype.listCostItemsForCustomerUsingGET = function(parameters) {
                 if (parameters === undefined) {
@@ -2515,14 +2600,6 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
-                if (parameters['period'] !== undefined) {
-                    queryParameters['period'] = parameters['period'];
-                }
-
-                if (parameters['productId'] !== undefined) {
-                    queryParameters['productId'] = parameters['productId'];
-                }
-
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
                 this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
@@ -3049,19 +3126,20 @@ angular.module('otrBackendService', [])
                 return deferred.promise;
             };
             /**
-             * assignOwner
+             * sendOverduePaymentReminderIfStillOwed
              * @method
-             * @name OtrService#assignOwnerUsingPOST
+             * @name OtrService#sendOverduePaymentReminderIfStillOwedUsingPOST
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
+             * @param {} parameters.request - request
              */
-            OtrService.prototype.assignOwnerUsingPOST = function(parameters) {
+            OtrService.prototype.sendOverduePaymentReminderIfStillOwedUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/cases/{caseId}/owner';
+                    path = '/api/v1/cases/{caseId}/overdue-payment-reminder';
                 var body = {},
                     queryParameters = {},
                     headers = {},
@@ -3077,6 +3155,15 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
+                if (parameters['request'] !== undefined) {
+                    body = parameters['request'];
+                }
+
+                if (parameters['request'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: request'));
+                    return deferred.promise;
+                }
+
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
                 this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
@@ -3084,27 +3171,26 @@ angular.module('otrBackendService', [])
                 return deferred.promise;
             };
             /**
-             * assignCaseToUser
+             * getOverdueCasePayments
              * @method
-             * @name OtrService#assignCaseToUserUsingPOST
+             * @name OtrService#getOverdueCasePaymentsUsingGET
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
-             * @param {integer} parameters.userId - userId
+             * @param {boolean} parameters.includeUpcoming - includeUpcoming
              */
-            OtrService.prototype.assignCaseToUserUsingPOST = function(parameters) {
+            OtrService.prototype.getOverdueCasePaymentsUsingGET = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/cases/{caseId}/owner/{userId}';
+                    path = '/api/v1/cases/{caseId}/overdue-payments';
                 var body = {},
                     queryParameters = {},
                     headers = {},
                     form = {};
 
                 headers['Accept'] = ['*/*'];
-                headers['Content-Type'] = ['application/json'];
 
                 path = path.replace('{caseId}', parameters['caseId']);
 
@@ -3113,42 +3199,40 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
-                path = path.replace('{userId}', parameters['userId']);
+                /** set default value **/
+                queryParameters['includeUpcoming'] = true;
 
-                if (parameters['userId'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: userId'));
-                    return deferred.promise;
+                if (parameters['includeUpcoming'] !== undefined) {
+                    queryParameters['includeUpcoming'] = parameters['includeUpcoming'];
                 }
 
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
             /**
-             * getPaymentPlanOptions
+             * assignOwner
              * @method
-             * @name OtrService#getPaymentPlanOptionsUsingGET
+             * @name OtrService#assignOwnerUsingPOST
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
-             * @param {integer} parameters.feeInCents - feeInCents
-             * @param {integer} parameters.lawfirmId - lawfirmId
-             * @param {integer} parameters.userId - userId
              */
-            OtrService.prototype.getPaymentPlanOptionsUsingGET = function(parameters) {
+            OtrService.prototype.assignOwnerUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/cases/{caseId}/payment-plans';
+                    path = '/api/v1/cases/{caseId}/owner';
                 var body = {},
                     queryParameters = {},
                     headers = {},
                     form = {};
 
                 headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
 
                 path = path.replace('{caseId}', parameters['caseId']);
 
@@ -3157,52 +3241,34 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
-                if (parameters['feeInCents'] !== undefined) {
-                    queryParameters['feeInCents'] = parameters['feeInCents'];
-                }
-
-                if (parameters['lawfirmId'] !== undefined) {
-                    queryParameters['lawfirmId'] = parameters['lawfirmId'];
-                }
-
-                if (parameters['lawfirmId'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
-                    return deferred.promise;
-                }
-
-                if (parameters['userId'] !== undefined) {
-                    queryParameters['userId'] = parameters['userId'];
-                }
-
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
             /**
-             * generateCasePaymentPlan
+             * assignCaseToUser
              * @method
-             * @name OtrService#generateCasePaymentPlanUsingGET
+             * @name OtrService#assignCaseToUserUsingPOST
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
-             * @param {string} parameters.paymentPlanTypeId - paymentPlanTypeId
-             * @param {string} parameters.period - period
-             * @param {string} parameters.productId - productId
+             * @param {integer} parameters.userId - userId
              */
-            OtrService.prototype.generateCasePaymentPlanUsingGET = function(parameters) {
+            OtrService.prototype.assignCaseToUserUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/cases/{caseId}/payment-plans/{paymentPlanTypeId}';
+                    path = '/api/v1/cases/{caseId}/owner/{userId}';
                 var body = {},
                     queryParameters = {},
                     headers = {},
                     form = {};
 
                 headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
 
                 path = path.replace('{caseId}', parameters['caseId']);
 
@@ -3211,43 +3277,34 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
-                path = path.replace('{paymentPlanTypeId}', parameters['paymentPlanTypeId']);
+                path = path.replace('{userId}', parameters['userId']);
 
-                if (parameters['paymentPlanTypeId'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: paymentPlanTypeId'));
+                if (parameters['userId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: userId'));
                     return deferred.promise;
                 }
 
-                if (parameters['period'] !== undefined) {
-                    queryParameters['period'] = parameters['period'];
-                }
-
-                if (parameters['productId'] !== undefined) {
-                    queryParameters['productId'] = parameters['productId'];
-                }
-
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
             /**
-             * saveCasePaymentPlan
+             * inviteCaseParticipant
              * @method
-             * @name OtrService#saveCasePaymentPlanUsingPOST
+             * @name OtrService#inviteCaseParticipantUsingPOST
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
-             * @param {string} parameters.paymentPlanTypeId - paymentPlanTypeId
              * @param {} parameters.request - request
              */
-            OtrService.prototype.saveCasePaymentPlanUsingPOST = function(parameters) {
+            OtrService.prototype.inviteCaseParticipantUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/cases/{caseId}/payment-plans/{paymentPlanTypeId}';
+                    path = '/api/v1/cases/{caseId}/participants/invite';
                 var body = {},
                     queryParameters = {},
                     headers = {},
@@ -3263,7 +3320,204 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
-                path = path.replace('{paymentPlanTypeId}', parameters['paymentPlanTypeId']);
+                if (parameters['request'] !== undefined) {
+                    body = parameters['request'];
+                }
+
+                if (parameters['request'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: request'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * resendCaseParticipantInvite
+             * @method
+             * @name OtrService#resendCaseParticipantInviteUsingPOST
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.caseId - caseId
+             * @param {string} parameters.emailAddress - emailAddress
+             */
+            OtrService.prototype.resendCaseParticipantInviteUsingPOST = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/cases/{caseId}/participants/resend-invite';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                path = path.replace('{caseId}', parameters['caseId']);
+
+                if (parameters['caseId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: caseId'));
+                    return deferred.promise;
+                }
+
+                if (parameters['emailAddress'] !== undefined) {
+                    queryParameters['emailAddress'] = parameters['emailAddress'];
+                }
+
+                if (parameters['emailAddress'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: emailAddress'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * getPaymentPlanOptions
+             * @method
+             * @name OtrService#getPaymentPlanOptionsUsingGET
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.caseId - caseId
+             * @param {integer} parameters.feeInCents - feeInCents
+             * @param {integer} parameters.lawfirmId - lawfirmId
+             * @param {integer} parameters.userId - userId
+             */
+            OtrService.prototype.getPaymentPlanOptionsUsingGET = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/cases/{caseId}/payment-plans';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                path = path.replace('{caseId}', parameters['caseId']);
+
+                if (parameters['caseId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: caseId'));
+                    return deferred.promise;
+                }
+
+                if (parameters['feeInCents'] !== undefined) {
+                    queryParameters['feeInCents'] = parameters['feeInCents'];
+                }
+
+                if (parameters['lawfirmId'] !== undefined) {
+                    queryParameters['lawfirmId'] = parameters['lawfirmId'];
+                }
+
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
+                }
+
+                if (parameters['userId'] !== undefined) {
+                    queryParameters['userId'] = parameters['userId'];
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * generateCasePaymentPlan
+             * @method
+             * @name OtrService#generateCasePaymentPlanUsingGET
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.caseId - caseId
+             * @param {string} parameters.paymentPlanTypeId - paymentPlanTypeId
+             * @param {string} parameters.period - period
+             * @param {string} parameters.productId - productId
+             */
+            OtrService.prototype.generateCasePaymentPlanUsingGET = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/cases/{caseId}/payment-plans/{paymentPlanTypeId}';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                path = path.replace('{caseId}', parameters['caseId']);
+
+                if (parameters['caseId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: caseId'));
+                    return deferred.promise;
+                }
+
+                path = path.replace('{paymentPlanTypeId}', parameters['paymentPlanTypeId']);
+
+                if (parameters['paymentPlanTypeId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: paymentPlanTypeId'));
+                    return deferred.promise;
+                }
+
+                if (parameters['period'] !== undefined) {
+                    queryParameters['period'] = parameters['period'];
+                }
+
+                if (parameters['productId'] !== undefined) {
+                    queryParameters['productId'] = parameters['productId'];
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * saveCasePaymentPlan
+             * @method
+             * @name OtrService#saveCasePaymentPlanUsingPOST
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.caseId - caseId
+             * @param {string} parameters.paymentPlanTypeId - paymentPlanTypeId
+             * @param {} parameters.request - request
+             */
+            OtrService.prototype.saveCasePaymentPlanUsingPOST = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/cases/{caseId}/payment-plans/{paymentPlanTypeId}';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                path = path.replace('{caseId}', parameters['caseId']);
+
+                if (parameters['caseId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: caseId'));
+                    return deferred.promise;
+                }
+
+                path = path.replace('{paymentPlanTypeId}', parameters['paymentPlanTypeId']);
 
                 if (parameters['paymentPlanTypeId'] === undefined) {
                     deferred.reject(new Error('Missing required  parameter: paymentPlanTypeId'));
@@ -3286,6 +3540,7 @@ angular.module('otrBackendService', [])
              * @name OtrService#getCasePaymentsUsingGET
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
+             * @param {boolean} parameters.includeInactiveLawfirmCases - includeInactiveLawfirmCases
              */
             OtrService.prototype.getCasePaymentsUsingGET = function(parameters) {
                 if (parameters === undefined) {
@@ -3308,6 +3563,10 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
+                if (parameters['includeInactiveLawfirmCases'] !== undefined) {
+                    queryParameters['includeInactiveLawfirmCases'] = parameters['includeInactiveLawfirmCases'];
+                }
+
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
                 this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
@@ -3715,48 +3974,6 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
-            /**
-             * removeReferralCodeFromCase
-             * @method
-             * @name OtrService#removeReferralCodeFromCaseUsingDELETE
-             * @param {object} parameters - method options and parameters
-             * @param {string} parameters.caseId - caseId
-             * @param {string} parameters.codeId - codeId
-             */
-            OtrService.prototype.removeReferralCodeFromCaseUsingDELETE = function(parameters) {
-                if (parameters === undefined) {
-                    parameters = {};
-                }
-                var deferred = $q.defer();
-                var domain = this.domain,
-                    path = '/api/v1/cases/{caseId}/referralcode/{codeId}';
-                var body = {},
-                    queryParameters = {},
-                    headers = {},
-                    form = {};
-
-                headers['Accept'] = ['*/*'];
-
-                path = path.replace('{caseId}', parameters['caseId']);
-
-                if (parameters['caseId'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: caseId'));
-                    return deferred.promise;
-                }
-
-                path = path.replace('{codeId}', parameters['codeId']);
-
-                if (parameters['codeId'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: codeId'));
-                    return deferred.promise;
-                }
-
-                queryParameters = mergeQueryParams(parameters, queryParameters);
-
-                this.request('DELETE', domain + path, parameters, body, headers, queryParameters, form, deferred);
-
-                return deferred.promise;
-            };
             /**
              * updateRefundEligibilityForCase
              * @method
@@ -4186,26 +4403,27 @@ angular.module('otrBackendService', [])
                 return deferred.promise;
             };
             /**
-             * getCaseUsersByCase
+             * calculateTransferFeeDifference
              * @method
-             * @name OtrService#getCaseUsersByCaseUsingGET
+             * @name OtrService#calculateTransferFeeDifferenceUsingPOST
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
-             * @param {boolean} parameters.getRemovedUsers - getRemovedUsers
+             * @param {integer} parameters.lawfirmId - lawfirmId
              */
-            OtrService.prototype.getCaseUsersByCaseUsingGET = function(parameters) {
+            OtrService.prototype.calculateTransferFeeDifferenceUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/cases/{caseId}/users';
+                    path = '/api/v1/cases/{caseId}/transfer/{lawfirmId}/calculate-fee-difference';
                 var body = {},
                     queryParameters = {},
                     headers = {},
                     form = {};
 
                 headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
 
                 path = path.replace('{caseId}', parameters['caseId']);
 
@@ -4214,25 +4432,28 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
-                if (parameters['getRemovedUsers'] !== undefined) {
-                    queryParameters['getRemovedUsers'] = parameters['getRemovedUsers'];
+                path = path.replace('{lawfirmId}', parameters['lawfirmId']);
+
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
                 }
 
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
             /**
-             * saveCaseUser
+             * getCaseUsersByCase
              * @method
-             * @name OtrService#saveCaseUserUsingPOST
+             * @name OtrService#getCaseUsersByCaseUsingGET
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
-             * @param {} parameters.request - request
+             * @param {boolean} parameters.getRemovedUsers - getRemovedUsers
              */
-            OtrService.prototype.saveCaseUserUsingPOST = function(parameters) {
+            OtrService.prototype.getCaseUsersByCaseUsingGET = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
@@ -4245,7 +4466,6 @@ angular.module('otrBackendService', [])
                     form = {};
 
                 headers['Accept'] = ['*/*'];
-                headers['Content-Type'] = ['application/json'];
 
                 path = path.replace('{caseId}', parameters['caseId']);
 
@@ -4254,54 +4474,58 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
-                if (parameters['request'] !== undefined) {
-                    body = parameters['request'];
-                }
-
-                if (parameters['request'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: request'));
-                    return deferred.promise;
+                if (parameters['getRemovedUsers'] !== undefined) {
+                    queryParameters['getRemovedUsers'] = parameters['getRemovedUsers'];
                 }
 
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
             /**
-             * getSSLPublicCertFile
+             * saveCaseUser
              * @method
-             * @name OtrService#getSSLPublicCertFileUsingGET
+             * @name OtrService#saveCaseUserUsingPOST
              * @param {object} parameters - method options and parameters
-             * @param {string} parameters.encoding - encoding
+             * @param {string} parameters.caseId - caseId
+             * @param {} parameters.request - request
              */
-            OtrService.prototype.getSSLPublicCertFileUsingGET = function(parameters) {
+            OtrService.prototype.saveCaseUserUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/certificates/ssl';
+                    path = '/api/v1/cases/{caseId}/users';
                 var body = {},
                     queryParameters = {},
                     headers = {},
                     form = {};
 
                 headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                path = path.replace('{caseId}', parameters['caseId']);
+
+                if (parameters['caseId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: caseId'));
+                    return deferred.promise;
+                }
 
-                if (parameters['encoding'] !== undefined) {
-                    queryParameters['encoding'] = parameters['encoding'];
+                if (parameters['request'] !== undefined) {
+                    body = parameters['request'];
                 }
 
-                if (parameters['encoding'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: encoding'));
+                if (parameters['request'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: request'));
                     return deferred.promise;
                 }
 
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
@@ -5686,6 +5910,51 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * getProfile
+             * @method
+             * @name OtrService#getProfileUsingPOST
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.loginProvider - loginProvider
+             * @param {} parameters.request - request
+             */
+            OtrService.prototype.getProfileUsingPOST = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/connect/{loginProvider}/get-profile';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                path = path.replace('{loginProvider}', parameters['loginProvider']);
+
+                if (parameters['loginProvider'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: loginProvider'));
+                    return deferred.promise;
+                }
+
+                if (parameters['request'] !== undefined) {
+                    body = parameters['request'];
+                }
+
+                if (parameters['request'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: request'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * getBookings
              * @method
@@ -8004,88 +8273,93 @@ angular.module('otrBackendService', [])
                 return deferred.promise;
             };
             /**
-             * handleDripWebhook
+             * listEmployees
              * @method
-             * @name OtrService#handleDripWebhookUsingPOST
+             * @name OtrService#listEmployeesUsingGET
              * @param {object} parameters - method options and parameters
-             * @param {} parameters.request - request
+             * @param {boolean} parameters.isActive - isActive
+             * @param {integer} parameters.length - length
+             * @param {integer} parameters.page - page
+             * @param {string} parameters.team - team
              */
-            OtrService.prototype.handleDripWebhookUsingPOST = function(parameters) {
+            OtrService.prototype.listEmployeesUsingGET = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/drip/webhooks';
+                    path = '/api/v1/employees';
                 var body = {},
                     queryParameters = {},
                     headers = {},
                     form = {};
 
                 headers['Accept'] = ['*/*'];
-                headers['Content-Type'] = ['application/json'];
 
-                if (parameters['request'] !== undefined) {
-                    body = parameters['request'];
+                if (parameters['isActive'] !== undefined) {
+                    queryParameters['isActive'] = parameters['isActive'];
                 }
 
-                if (parameters['request'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: request'));
-                    return deferred.promise;
+                /** set default value **/
+                queryParameters['length'] = 10;
+
+                if (parameters['length'] !== undefined) {
+                    queryParameters['length'] = parameters['length'];
+                }
+
+                if (parameters['page'] !== undefined) {
+                    queryParameters['page'] = parameters['page'];
+                }
+
+                if (parameters['team'] !== undefined) {
+                    queryParameters['team'] = parameters['team'];
                 }
 
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
             /**
-             * listEmployees
+             * handleHardBounceComplainEvents
              * @method
-             * @name OtrService#listEmployeesUsingGET
+             * @name OtrService#handleHardBounceComplainEventsUsingPOST
              * @param {object} parameters - method options and parameters
-             * @param {boolean} parameters.isActive - isActive
-             * @param {integer} parameters.length - length
-             * @param {integer} parameters.page - page
-             * @param {string} parameters.team - team
+             * @param {} parameters.request - request
+             * @param {string} parameters.xApiToken - X-Api-Token
              */
-            OtrService.prototype.listEmployeesUsingGET = function(parameters) {
+            OtrService.prototype.handleHardBounceComplainEventsUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/employees';
+                    path = '/api/v1/event-bridge/bounce-complaint-notifications';
                 var body = {},
                     queryParameters = {},
                     headers = {},
                     form = {};
 
                 headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
 
-                if (parameters['isActive'] !== undefined) {
-                    queryParameters['isActive'] = parameters['isActive'];
-                }
-
-                /** set default value **/
-                queryParameters['length'] = 10;
-
-                if (parameters['length'] !== undefined) {
-                    queryParameters['length'] = parameters['length'];
+                if (parameters['request'] !== undefined) {
+                    body = parameters['request'];
                 }
 
-                if (parameters['page'] !== undefined) {
-                    queryParameters['page'] = parameters['page'];
+                if (parameters['request'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: request'));
+                    return deferred.promise;
                 }
 
-                if (parameters['team'] !== undefined) {
-                    queryParameters['team'] = parameters['team'];
+                if (parameters['xApiToken'] !== undefined) {
+                    headers['X-Api-Token'] = parameters['xApiToken'];
                 }
 
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
@@ -8856,6 +9130,43 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * onConversationNotification
+             * @method
+             * @name OtrService#onConversationNotificationUsingPOST
+             * @param {object} parameters - method options and parameters
+             * @param {} parameters.body - body
+             */
+            OtrService.prototype.onConversationNotificationUsingPOST = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/intercom/webhook/conversation-notification';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                if (parameters['body'] !== undefined) {
+                    body = parameters['body'];
+                }
+
+                if (parameters['body'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: body'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * refundLawfirmFee
              * @method
@@ -9387,6 +9698,32 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * getAccountManagers
+             * @method
+             * @name OtrService#getAccountManagersUsingGET
+             * @param {object} parameters - method options and parameters
+             */
+            OtrService.prototype.getAccountManagersUsingGET = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/lawfirms/account-managers';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * uploadLawfirms
              * @method
@@ -10087,6 +10424,51 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * saveLawfirmAccountManager
+             * @method
+             * @name OtrService#saveLawfirmAccountManagerUsingPOST
+             * @param {object} parameters - method options and parameters
+             * @param {integer} parameters.lawfirmId - lawfirmId
+             * @param {} parameters.request - request
+             */
+            OtrService.prototype.saveLawfirmAccountManagerUsingPOST = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/lawfirms/{lawfirmId}/account-manager';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                path = path.replace('{lawfirmId}', parameters['lawfirmId']);
+
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
+                }
+
+                if (parameters['request'] !== undefined) {
+                    body = parameters['request'];
+                }
+
+                if (parameters['request'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: request'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * getLawfirmAddresses
              * @method
@@ -10262,61 +10644,351 @@ angular.module('otrBackendService', [])
                 /** set default value **/
                 queryParameters['limit'] = 25;
 
-                if (parameters['limit'] !== undefined) {
-                    queryParameters['limit'] = parameters['limit'];
-                }
+                if (parameters['limit'] !== undefined) {
+                    queryParameters['limit'] = parameters['limit'];
+                }
+
+                if (parameters['nextPageToken'] !== undefined) {
+                    queryParameters['nextPageToken'] = parameters['nextPageToken'];
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * listLawfirmBankPayouts
+             * @method
+             * @name OtrService#listLawfirmBankPayoutsUsingGET
+             * @param {object} parameters - method options and parameters
+             * @param {boolean} parameters.includeTransactions - includeTransactions 
+             * @param {integer} parameters.index - index
+             * @param {integer} parameters.lawfirmId - lawfirmId
+             * @param {integer} parameters.size - size
+             */
+            OtrService.prototype.listLawfirmBankPayoutsUsingGET = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/lawfirms/{lawfirmId}/bank-payouts';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                if (parameters['includeTransactions'] !== undefined) {
+                    queryParameters['includeTransactions '] = parameters['includeTransactions'];
+                }
+
+                if (parameters['includeTransactions'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: includeTransactions'));
+                    return deferred.promise;
+                }
+
+                if (parameters['index'] !== undefined) {
+                    queryParameters['index'] = parameters['index'];
+                }
+
+                if (parameters['index'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: index'));
+                    return deferred.promise;
+                }
+
+                path = path.replace('{lawfirmId}', parameters['lawfirmId']);
+
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
+                }
+
+                /** set default value **/
+                queryParameters['size'] = 10;
+
+                if (parameters['size'] !== undefined) {
+                    queryParameters['size'] = parameters['size'];
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * getAcceptedCaseBreakdown
+             * @method
+             * @name OtrService#getAcceptedCaseBreakdownUsingGET
+             * @param {object} parameters - method options and parameters
+             * @param {integer} parameters.lawfirmId - lawfirmId
+             */
+            OtrService.prototype.getAcceptedCaseBreakdownUsingGET = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/lawfirms/{lawfirmId}/cases/accepted-breakdown';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                path = path.replace('{lawfirmId}', parameters['lawfirmId']);
+
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * getLeadSummary
+             * @method
+             * @name OtrService#getLeadSummaryUsingGET
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.endDate - endDate
+             * @param {integer} parameters.lawfirmId - lawfirmId
+             * @param {string} parameters.startDate - startDate
+             */
+            OtrService.prototype.getLeadSummaryUsingGET = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/lawfirms/{lawfirmId}/cases/lead-summary';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                if (parameters['endDate'] !== undefined) {
+                    queryParameters['endDate'] = parameters['endDate'];
+                }
+
+                path = path.replace('{lawfirmId}', parameters['lawfirmId']);
+
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
+                }
+
+                if (parameters['startDate'] !== undefined) {
+                    queryParameters['startDate'] = parameters['startDate'];
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * getLawfirmCaseStats
+             * @method
+             * @name OtrService#getLawfirmCaseStatsUsingGET
+             * @param {object} parameters - method options and parameters
+             * @param {boolean} parameters.includeExtendedCounts - includeExtendedCounts
+             * @param {integer} parameters.lawfirmId - lawfirmId
+             * @param {integer} parameters.userId - userId
+             */
+            OtrService.prototype.getLawfirmCaseStatsUsingGET = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/lawfirms/{lawfirmId}/cases/stats';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                if (parameters['includeExtendedCounts'] !== undefined) {
+                    queryParameters['includeExtendedCounts'] = parameters['includeExtendedCounts'];
+                }
+
+                path = path.replace('{lawfirmId}', parameters['lawfirmId']);
+
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
+                }
+
+                if (parameters['userId'] !== undefined) {
+                    queryParameters['userId'] = parameters['userId'];
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * listCounterOffers
+             * @method
+             * @name OtrService#listCounterOffersUsingGET
+             * @param {object} parameters - method options and parameters
+             * @param {integer} parameters.lawfirmId - lawfirmId
+             * @param {integer} parameters.limit - limit
+             * @param {integer} parameters.page - page
+             */
+            OtrService.prototype.listCounterOffersUsingGET = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/lawfirms/{lawfirmId}/counters';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                path = path.replace('{lawfirmId}', parameters['lawfirmId']);
+
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
+                }
+
+                /** set default value **/
+                queryParameters['limit'] = 10;
+
+                if (parameters['limit'] !== undefined) {
+                    queryParameters['limit'] = parameters['limit'];
+                }
+
+                if (parameters['page'] !== undefined) {
+                    queryParameters['page'] = parameters['page'];
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * removeCourts
+             * @method
+             * @name OtrService#removeCourtsUsingDELETE
+             * @param {object} parameters - method options and parameters
+             * @param {integer} parameters.courtsToRemove - courtsToRemove
+             * @param {string} parameters.lawfirmId - lawfirmId
+             */
+            OtrService.prototype.removeCourtsUsingDELETE = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/lawfirms/{lawfirmId}/courts';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                if (parameters['courtsToRemove'] !== undefined) {
+                    queryParameters['courtsToRemove'] = parameters['courtsToRemove'];
+                }
+
+                if (parameters['courtsToRemove'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: courtsToRemove'));
+                    return deferred.promise;
+                }
+
+                path = path.replace('{lawfirmId}', parameters['lawfirmId']);
+
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('DELETE', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * deleteLawfirmCoverPhoto
+             * @method
+             * @name OtrService#deleteLawfirmCoverPhotoUsingDELETE
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.lawfirmId - lawfirmId
+             */
+            OtrService.prototype.deleteLawfirmCoverPhotoUsingDELETE = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/lawfirms/{lawfirmId}/cover-photo';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                path = path.replace('{lawfirmId}', parameters['lawfirmId']);
 
-                if (parameters['nextPageToken'] !== undefined) {
-                    queryParameters['nextPageToken'] = parameters['nextPageToken'];
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
                 }
 
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('DELETE', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
             /**
-             * listLawfirmBankPayouts
+             * saveDefaultFeeRefundEligibility
              * @method
-             * @name OtrService#listLawfirmBankPayoutsUsingGET
+             * @name OtrService#saveDefaultFeeRefundEligibilityUsingPOST
              * @param {object} parameters - method options and parameters
-             * @param {boolean} parameters.includeTransactions - includeTransactions 
-             * @param {integer} parameters.index - index
              * @param {integer} parameters.lawfirmId - lawfirmId
-             * @param {integer} parameters.size - size
+             * @param {} parameters.request - request
              */
-            OtrService.prototype.listLawfirmBankPayoutsUsingGET = function(parameters) {
+            OtrService.prototype.saveDefaultFeeRefundEligibilityUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/lawfirms/{lawfirmId}/bank-payouts';
+                    path = '/api/v1/lawfirms/{lawfirmId}/coverage/refund-eligibility';
                 var body = {},
                     queryParameters = {},
                     headers = {},
                     form = {};
 
                 headers['Accept'] = ['*/*'];
-
-                if (parameters['includeTransactions'] !== undefined) {
-                    queryParameters['includeTransactions '] = parameters['includeTransactions'];
-                }
-
-                if (parameters['includeTransactions'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: includeTransactions'));
-                    return deferred.promise;
-                }
-
-                if (parameters['index'] !== undefined) {
-                    queryParameters['index'] = parameters['index'];
-                }
-
-                if (parameters['index'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: index'));
-                    return deferred.promise;
-                }
+                headers['Content-Type'] = ['application/json'];
 
                 path = path.replace('{lawfirmId}', parameters['lawfirmId']);
 
@@ -10325,33 +10997,35 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
-                /** set default value **/
-                queryParameters['size'] = 10;
+                if (parameters['request'] !== undefined) {
+                    body = parameters['request'];
+                }
 
-                if (parameters['size'] !== undefined) {
-                    queryParameters['size'] = parameters['size'];
+                if (parameters['request'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: request'));
+                    return deferred.promise;
                 }
 
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
             /**
-             * getLawfirmCaseStats
+             * getActiveCasesByAge
              * @method
-             * @name OtrService#getLawfirmCaseStatsUsingGET
+             * @name OtrService#getActiveCasesByAgeUsingGET
              * @param {object} parameters - method options and parameters
              * @param {integer} parameters.lawfirmId - lawfirmId
              */
-            OtrService.prototype.getLawfirmCaseStatsUsingGET = function(parameters) {
+            OtrService.prototype.getActiveCasesByAgeUsingGET = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/lawfirms/{lawfirmId}/cases/stats';
+                    path = '/api/v1/lawfirms/{lawfirmId}/dashboard/active-cases-by-age';
                 var body = {},
                     queryParameters = {},
                     headers = {},
@@ -10373,20 +11047,22 @@ angular.module('otrBackendService', [])
                 return deferred.promise;
             };
             /**
-             * removeCourts
+             * getTopCourtEarnings
              * @method
-             * @name OtrService#removeCourtsUsingDELETE
+             * @name OtrService#getTopCourtEarningsUsingGET
              * @param {object} parameters - method options and parameters
-             * @param {integer} parameters.courtsToRemove - courtsToRemove
-             * @param {string} parameters.lawfirmId - lawfirmId
+             * @param {string} parameters.endDate - endDate
+             * @param {integer} parameters.lawfirmId - lawfirmId
+             * @param {integer} parameters.limit - limit
+             * @param {string} parameters.startDate - startDate
              */
-            OtrService.prototype.removeCourtsUsingDELETE = function(parameters) {
+            OtrService.prototype.getTopCourtEarningsUsingGET = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/lawfirms/{lawfirmId}/courts';
+                    path = '/api/v1/lawfirms/{lawfirmId}/dashboard/earnings/top-courts';
                 var body = {},
                     queryParameters = {},
                     headers = {},
@@ -10394,13 +11070,8 @@ angular.module('otrBackendService', [])
 
                 headers['Accept'] = ['*/*'];
 
-                if (parameters['courtsToRemove'] !== undefined) {
-                    queryParameters['courtsToRemove'] = parameters['courtsToRemove'];
-                }
-
-                if (parameters['courtsToRemove'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: courtsToRemove'));
-                    return deferred.promise;
+                if (parameters['endDate'] !== undefined) {
+                    queryParameters['endDate'] = parameters['endDate'];
                 }
 
                 path = path.replace('{lawfirmId}', parameters['lawfirmId']);
@@ -10410,26 +11081,40 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
+                /** set default value **/
+                queryParameters['limit'] = 10;
+
+                if (parameters['limit'] !== undefined) {
+                    queryParameters['limit'] = parameters['limit'];
+                }
+
+                if (parameters['startDate'] !== undefined) {
+                    queryParameters['startDate'] = parameters['startDate'];
+                }
+
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('DELETE', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
             /**
-             * deleteLawfirmCoverPhoto
+             * getLawfirmGrossEarnings
              * @method
-             * @name OtrService#deleteLawfirmCoverPhotoUsingDELETE
+             * @name OtrService#getLawfirmGrossEarningsUsingGET
              * @param {object} parameters - method options and parameters
-             * @param {string} parameters.lawfirmId - lawfirmId
+             * @param {string} parameters.endDate - endDate
+             * @param {integer} parameters.lawfirmId - lawfirmId
+             * @param {string} parameters.period - period
+             * @param {string} parameters.startDate - startDate
              */
-            OtrService.prototype.deleteLawfirmCoverPhotoUsingDELETE = function(parameters) {
+            OtrService.prototype.getLawfirmGrossEarningsUsingGET = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/lawfirms/{lawfirmId}/cover-photo';
+                    path = '/api/v1/lawfirms/{lawfirmId}/dashboard/gross-earnings';
                 var body = {},
                     queryParameters = {},
                     headers = {},
@@ -10437,6 +11122,10 @@ angular.module('otrBackendService', [])
 
                 headers['Accept'] = ['*/*'];
 
+                if (parameters['endDate'] !== undefined) {
+                    queryParameters['endDate'] = parameters['endDate'];
+                }
+
                 path = path.replace('{lawfirmId}', parameters['lawfirmId']);
 
                 if (parameters['lawfirmId'] === undefined) {
@@ -10444,9 +11133,22 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
+                if (parameters['period'] !== undefined) {
+                    queryParameters['period'] = parameters['period'];
+                }
+
+                if (parameters['period'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: period'));
+                    return deferred.promise;
+                }
+
+                if (parameters['startDate'] !== undefined) {
+                    queryParameters['startDate'] = parameters['startDate'];
+                }
+
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
-                this.request('DELETE', domain + path, parameters, body, headers, queryParameters, form, deferred);
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
 
                 return deferred.promise;
             };
@@ -10694,15 +11396,23 @@ angular.module('otrBackendService', [])
              * @method
              * @name OtrService#getInboxMessagesUsingGET
              * @param {object} parameters - method options and parameters
+             * @param {string} parameters.caseCounterOfferStatuses - caseCounterOfferStatuses
              * @param {string} parameters.caseStatuses - caseStatuses
+             * @param {integer} parameters.countyIds - countyIds
              * @param {string} parameters.courtDateFilter - courtDateFilter
+             * @param {integer} parameters.courtIds - courtIds
              * @param {string} parameters.filter - filter
+             * @param {boolean} parameters.hasUnread - hasUnread
+             * @param {boolean} parameters.isOverdue - isOverdue
              * @param {string} parameters.latestMessageBy - latestMessageBy
+             * @param {string} parameters.lawfirmCaseDecisionStatus - lawfirmCaseDecisionStatus
              * @param {integer} parameters.lawfirmId - lawfirmId
              * @param {integer} parameters.length - length
              * @param {integer} parameters.page - page
              * @param {string} parameters.query - query
+             * @param {string} parameters.regionCodes - regionCodes
              * @param {string} parameters.statusCategories - statusCategories
+             * @param {integer} parameters.userId - userId
              */
             OtrService.prototype.getInboxMessagesUsingGET = function(parameters) {
                 if (parameters === undefined) {
@@ -10718,22 +11428,46 @@ angular.module('otrBackendService', [])
 
                 headers['Accept'] = ['*/*'];
 
+                if (parameters['caseCounterOfferStatuses'] !== undefined) {
+                    queryParameters['caseCounterOfferStatuses'] = parameters['caseCounterOfferStatuses'];
+                }
+
                 if (parameters['caseStatuses'] !== undefined) {
                     queryParameters['caseStatuses'] = parameters['caseStatuses'];
                 }
 
+                if (parameters['countyIds'] !== undefined) {
+                    queryParameters['countyIds'] = parameters['countyIds'];
+                }
+
                 if (parameters['courtDateFilter'] !== undefined) {
                     queryParameters['courtDateFilter'] = parameters['courtDateFilter'];
                 }
 
+                if (parameters['courtIds'] !== undefined) {
+                    queryParameters['courtIds'] = parameters['courtIds'];
+                }
+
                 if (parameters['filter'] !== undefined) {
                     queryParameters['filter'] = parameters['filter'];
                 }
 
+                if (parameters['hasUnread'] !== undefined) {
+                    queryParameters['hasUnread'] = parameters['hasUnread'];
+                }
+
+                if (parameters['isOverdue'] !== undefined) {
+                    queryParameters['isOverdue'] = parameters['isOverdue'];
+                }
+
                 if (parameters['latestMessageBy'] !== undefined) {
                     queryParameters['latestMessageBy'] = parameters['latestMessageBy'];
                 }
 
+                if (parameters['lawfirmCaseDecisionStatus'] !== undefined) {
+                    queryParameters['lawfirmCaseDecisionStatus'] = parameters['lawfirmCaseDecisionStatus'];
+                }
+
                 path = path.replace('{lawfirmId}', parameters['lawfirmId']);
 
                 if (parameters['lawfirmId'] === undefined) {
@@ -10756,10 +11490,18 @@ angular.module('otrBackendService', [])
                     queryParameters['query'] = parameters['query'];
                 }
 
+                if (parameters['regionCodes'] !== undefined) {
+                    queryParameters['regionCodes'] = parameters['regionCodes'];
+                }
+
                 if (parameters['statusCategories'] !== undefined) {
                     queryParameters['statusCategories'] = parameters['statusCategories'];
                 }
 
+                if (parameters['userId'] !== undefined) {
+                    queryParameters['userId'] = parameters['userId'];
+                }
+
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
                 this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
@@ -11390,6 +12132,51 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * saveLawfirmSupportedState
+             * @method
+             * @name OtrService#saveLawfirmSupportedStateUsingPOST
+             * @param {object} parameters - method options and parameters
+             * @param {integer} parameters.lawfirmId - lawfirmId
+             * @param {} parameters.request - request
+             */
+            OtrService.prototype.saveLawfirmSupportedStateUsingPOST = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/lawfirms/{lawfirmId}/supported-states';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                path = path.replace('{lawfirmId}', parameters['lawfirmId']);
+
+                if (parameters['lawfirmId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: lawfirmId'));
+                    return deferred.promise;
+                }
+
+                if (parameters['request'] !== undefined) {
+                    body = parameters['request'];
+                }
+
+                if (parameters['request'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: request'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * listLawfirmSurcharges
              * @method
@@ -12279,6 +13066,8 @@ angular.module('otrBackendService', [])
              * @name OtrService#getUnreadCountsUsingGET
              * @param {object} parameters - method options and parameters
              * @param {boolean} parameters.includeMessage - includeMessage
+             * @param {integer} parameters.limit - limit
+             * @param {integer} parameters.offset - offset
              */
             OtrService.prototype.getUnreadCountsUsingGET = function(parameters) {
                 if (parameters === undefined) {
@@ -12298,6 +13087,17 @@ angular.module('otrBackendService', [])
                     queryParameters['includeMessage'] = parameters['includeMessage'];
                 }
 
+                /** set default value **/
+                queryParameters['limit'] = 5000;
+
+                if (parameters['limit'] !== undefined) {
+                    queryParameters['limit'] = parameters['limit'];
+                }
+
+                if (parameters['offset'] !== undefined) {
+                    queryParameters['offset'] = parameters['offset'];
+                }
+
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
                 this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
@@ -13761,6 +14561,7 @@ angular.module('otrBackendService', [])
              * @method
              * @name OtrService#listCustomerReviewsUsingGET
              * @param {object} parameters - method options and parameters
+             * @param {string} parameters.endDate - endDate
              * @param {boolean} parameters.includeAnonymous - includeAnonymous
              * @param {boolean} parameters.includeDeleted - includeDeleted
              * @param {boolean} parameters.includeRatings - includeRatings
@@ -13769,6 +14570,7 @@ angular.module('otrBackendService', [])
              * @param {integer} parameters.limit - limit
              * @param {string} parameters.nextPageToken - nextPageToken
              * @param {string} parameters.previousPageToken - previousPageToken
+             * @param {string} parameters.startDate - startDate
              * @param {string} parameters.state - state
              * @param {string} parameters.tags - tags
              * @param {string} parameters.version - version
@@ -13787,6 +14589,10 @@ angular.module('otrBackendService', [])
 
                 headers['Accept'] = ['*/*'];
 
+                if (parameters['endDate'] !== undefined) {
+                    queryParameters['endDate'] = parameters['endDate'];
+                }
+
                 if (parameters['includeAnonymous'] !== undefined) {
                     queryParameters['includeAnonymous'] = parameters['includeAnonymous'];
                 }
@@ -13822,6 +14628,10 @@ angular.module('otrBackendService', [])
                     queryParameters['previousPageToken'] = parameters['previousPageToken'];
                 }
 
+                if (parameters['startDate'] !== undefined) {
+                    queryParameters['startDate'] = parameters['startDate'];
+                }
+
                 if (parameters['state'] !== undefined) {
                     queryParameters['state'] = parameters['state'];
                 }
@@ -13877,6 +14687,32 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * getCustomerReviewAggregates
+             * @method
+             * @name OtrService#getCustomerReviewAggregatesUsingGET
+             * @param {object} parameters - method options and parameters
+             */
+            OtrService.prototype.getCustomerReviewAggregatesUsingGET = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/reviews/aggregates';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * editCustomerReview
              * @method
@@ -14856,56 +15692,19 @@ angular.module('otrBackendService', [])
                 return deferred.promise;
             };
             /**
-             * syncStripeCharges
-             * @method
-             * @name OtrService#syncStripeChargesUsingPOST
-             * @param {object} parameters - method options and parameters
-             * @param {} parameters.request - request
-             */
-            OtrService.prototype.syncStripeChargesUsingPOST = function(parameters) {
-                if (parameters === undefined) {
-                    parameters = {};
-                }
-                var deferred = $q.defer();
-                var domain = this.domain,
-                    path = '/api/v1/stripe/sync-stripe-charges';
-                var body = {},
-                    queryParameters = {},
-                    headers = {},
-                    form = {};
-
-                headers['Accept'] = ['*/*'];
-                headers['Content-Type'] = ['application/json'];
-
-                if (parameters['request'] !== undefined) {
-                    body = parameters['request'];
-                }
-
-                if (parameters['request'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: request'));
-                    return deferred.promise;
-                }
-
-                queryParameters = mergeQueryParams(parameters, queryParameters);
-
-                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
-
-                return deferred.promise;
-            };
-            /**
-             * syncStripeRefunds
+             * syncStripeCharges
              * @method
-             * @name OtrService#syncStripeRefundsUsingPOST
+             * @name OtrService#syncStripeChargesUsingPOST
              * @param {object} parameters - method options and parameters
              * @param {} parameters.request - request
              */
-            OtrService.prototype.syncStripeRefundsUsingPOST = function(parameters) {
+            OtrService.prototype.syncStripeChargesUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/stripe/sync-stripe-refunds';
+                    path = '/api/v1/stripe/sync-stripe-charges';
                 var body = {},
                     queryParameters = {},
                     headers = {},
@@ -14930,19 +15729,19 @@ angular.module('otrBackendService', [])
                 return deferred.promise;
             };
             /**
-             * syncStripeTransfers
+             * syncStripeRefunds
              * @method
-             * @name OtrService#syncStripeTransfersUsingPOST
+             * @name OtrService#syncStripeRefundsUsingPOST
              * @param {object} parameters - method options and parameters
              * @param {} parameters.request - request
              */
-            OtrService.prototype.syncStripeTransfersUsingPOST = function(parameters) {
+            OtrService.prototype.syncStripeRefundsUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/stripe/transfers/sync';
+                    path = '/api/v1/stripe/sync-stripe-refunds';
                 var body = {},
                     queryParameters = {},
                     headers = {},
@@ -14967,19 +15766,19 @@ angular.module('otrBackendService', [])
                 return deferred.promise;
             };
             /**
-             * subscribe
+             * syncStripeTransfers
              * @method
-             * @name OtrService#subscribeUsingPOST
+             * @name OtrService#syncStripeTransfersUsingPOST
              * @param {object} parameters - method options and parameters
              * @param {} parameters.request - request
              */
-            OtrService.prototype.subscribeUsingPOST = function(parameters) {
+            OtrService.prototype.syncStripeTransfersUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/subscribe';
+                    path = '/api/v1/stripe/transfers/sync';
                 var body = {},
                     queryParameters = {},
                     headers = {},
@@ -16531,7 +17330,6 @@ angular.module('otrBackendService', [])
              * @name OtrService#listDashboardCaseUsersUsingGET
              * @param {object} parameters - method options and parameters
              * @param {boolean} parameters.isDefendant - isDefendant
-             * @param {integer} parameters.limit - limit
              * @param {integer} parameters.userId - userId
              */
             OtrService.prototype.listDashboardCaseUsersUsingGET = function(parameters) {
@@ -16552,47 +17350,6 @@ angular.module('otrBackendService', [])
                     queryParameters['isDefendant'] = parameters['isDefendant'];
                 }
 
-                /** set default value **/
-                queryParameters['limit'] = 5;
-
-                if (parameters['limit'] !== undefined) {
-                    queryParameters['limit'] = parameters['limit'];
-                }
-
-                path = path.replace('{userId}', parameters['userId']);
-
-                if (parameters['userId'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: userId'));
-                    return deferred.promise;
-                }
-
-                queryParameters = mergeQueryParams(parameters, queryParameters);
-
-                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
-
-                return deferred.promise;
-            };
-            /**
-             * getCasesForUser
-             * @method
-             * @name OtrService#getCasesForUserUsingGET
-             * @param {object} parameters - method options and parameters
-             * @param {string} parameters.userId - userId
-             */
-            OtrService.prototype.getCasesForUserUsingGET = function(parameters) {
-                if (parameters === undefined) {
-                    parameters = {};
-                }
-                var deferred = $q.defer();
-                var domain = this.domain,
-                    path = '/api/v1/users/{userId}/cases';
-                var body = {},
-                    queryParameters = {},
-                    headers = {},
-                    form = {};
-
-                headers['Accept'] = ['*/*'];
-
                 path = path.replace('{userId}', parameters['userId']);
 
                 if (parameters['userId'] === undefined) {
@@ -16763,6 +17520,7 @@ angular.module('otrBackendService', [])
              * @method
              * @name OtrService#saveDriverLicensePictureUsingPOST
              * @param {object} parameters - method options and parameters
+             * @param {boolean} parameters.performPrediction - performPrediction
              * @param {} parameters.request - request
              * @param {string} parameters.userId - userId
              */
@@ -16781,6 +17539,13 @@ angular.module('otrBackendService', [])
                 headers['Accept'] = ['*/*'];
                 headers['Content-Type'] = ['application/json'];
 
+                /** set default value **/
+                queryParameters['performPrediction'] = true;
+
+                if (parameters['performPrediction'] !== undefined) {
+                    queryParameters['performPrediction'] = parameters['performPrediction'];
+                }
+
                 if (parameters['request'] !== undefined) {
                     body = parameters['request'];
                 }
@@ -16803,6 +17568,41 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * predictDriverLicense
+             * @method
+             * @name OtrService#predictDriverLicenseUsingPOST
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.userId - userId
+             */
+            OtrService.prototype.predictDriverLicenseUsingPOST = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/users/{userId}/driver-license/predict-picture';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                path = path.replace('{userId}', parameters['userId']);
+
+                if (parameters['userId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: userId'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * logoutUser
              * @method
@@ -17181,6 +17981,40 @@ angular.module('otrBackendService', [])
 
                 return deferred.promise;
             };
+            /**
+             * issueShortLivedToken
+             * @method
+             * @name OtrService#issueShortLivedTokenUsingGET
+             * @param {object} parameters - method options and parameters
+             * @param {integer} parameters.userId - userId
+             */
+            OtrService.prototype.issueShortLivedTokenUsingGET = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/users/{userId}/short-lived-token';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+
+                path = path.replace('{userId}', parameters['userId']);
+
+                if (parameters['userId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: userId'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
             /**
              * saveUserSocialProfiles
              * @method
@@ -18253,19 +19087,113 @@ angular.module('otrBackendService', [])
                 return deferred.promise;
             };
             /**
-             * handleEvent
+             * connect
+             * @method
+             * @name OtrService#connectUsingPOST
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.connectionId - connectionId
+             * @param {string} parameters.token - token
+             * @param {integer} parameters.userId - userId
+             */
+            OtrService.prototype.connectUsingPOST = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/websocket/connect';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                if (parameters['connectionId'] !== undefined) {
+                    headers['connectionId'] = parameters['connectionId'];
+                }
+
+                if (parameters['connectionId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: connectionId'));
+                    return deferred.promise;
+                }
+
+                if (parameters['token'] !== undefined) {
+                    queryParameters['token'] = parameters['token'];
+                }
+
+                if (parameters['token'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: token'));
+                    return deferred.promise;
+                }
+
+                if (parameters['userId'] !== undefined) {
+                    queryParameters['userId'] = parameters['userId'];
+                }
+
+                if (parameters['userId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: userId'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * defaultHandler
+             * @method
+             * @name OtrService#defaultHandlerUsingPOST
+             * @param {object} parameters - method options and parameters
+             * @param {string} parameters.connectionId - connectionId
+             */
+            OtrService.prototype.defaultHandlerUsingPOST = function(parameters) {
+                if (parameters === undefined) {
+                    parameters = {};
+                }
+                var deferred = $q.defer();
+                var domain = this.domain,
+                    path = '/api/v1/websocket/default';
+                var body = {},
+                    queryParameters = {},
+                    headers = {},
+                    form = {};
+
+                headers['Accept'] = ['*/*'];
+                headers['Content-Type'] = ['application/json'];
+
+                if (parameters['connectionId'] !== undefined) {
+                    headers['connectionId'] = parameters['connectionId'];
+                }
+
+                if (parameters['connectionId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: connectionId'));
+                    return deferred.promise;
+                }
+
+                queryParameters = mergeQueryParams(parameters, queryParameters);
+
+                this.request('POST', domain + path, parameters, body, headers, queryParameters, form, deferred);
+
+                return deferred.promise;
+            };
+            /**
+             * disconnect
              * @method
-             * @name OtrService#handleEventUsingPOST
+             * @name OtrService#disconnectUsingPOST
              * @param {object} parameters - method options and parameters
-             * @param {} parameters.event - event
+             * @param {string} parameters.connectionId - connectionId
              */
-            OtrService.prototype.handleEventUsingPOST = function(parameters) {
+            OtrService.prototype.disconnectUsingPOST = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v1/webhooks/prismic';
+                    path = '/api/v1/websocket/disconnect';
                 var body = {},
                     queryParameters = {},
                     headers = {},
@@ -18274,12 +19202,12 @@ angular.module('otrBackendService', [])
                 headers['Accept'] = ['*/*'];
                 headers['Content-Type'] = ['application/json'];
 
-                if (parameters['event'] !== undefined) {
-                    body = parameters['event'];
+                if (parameters['connectionId'] !== undefined) {
+                    headers['connectionId'] = parameters['connectionId'];
                 }
 
-                if (parameters['event'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: event'));
+                if (parameters['connectionId'] === undefined) {
+                    deferred.reject(new Error('Missing required  parameter: connectionId'));
                     return deferred.promise;
                 }
 
@@ -19000,6 +19928,7 @@ angular.module('otrBackendService', [])
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseId - caseId
              * @param {} parameters.request - request
+             * @param {integer} parameters.userId - userId
              */
             OtrService.prototype.markPageTypesAsReadUsingDELETE = function(parameters) {
                 if (parameters === undefined) {
@@ -19031,6 +19960,10 @@ angular.module('otrBackendService', [])
                     return deferred.promise;
                 }
 
+                if (parameters['userId'] !== undefined) {
+                    queryParameters['userId'] = parameters['userId'];
+                }
+
                 queryParameters = mergeQueryParams(parameters, queryParameters);
 
                 this.request('DELETE', domain + path, parameters, body, headers, queryParameters, form, deferred);
@@ -19074,61 +20007,34 @@ angular.module('otrBackendService', [])
                 return deferred.promise;
             };
             /**
-             * getUserCases
-             * @method
-             * @name OtrService#getUserCasesUsingGET
-             * @param {object} parameters - method options and parameters
-             * @param {integer} parameters.userId - userId
-             */
-            OtrService.prototype.getUserCasesUsingGET = function(parameters) {
-                if (parameters === undefined) {
-                    parameters = {};
-                }
-                var deferred = $q.defer();
-                var domain = this.domain,
-                    path = '/api/v2/users/{userId}/cases';
-                var body = {},
-                    queryParameters = {},
-                    headers = {},
-                    form = {};
-
-                headers['Accept'] = ['*/*'];
-
-                path = path.replace('{userId}', parameters['userId']);
-
-                if (parameters['userId'] === undefined) {
-                    deferred.reject(new Error('Missing required  parameter: userId'));
-                    return deferred.promise;
-                }
-
-                queryParameters = mergeQueryParams(parameters, queryParameters);
-
-                this.request('GET', domain + path, parameters, body, headers, queryParameters, form, deferred);
-
-                return deferred.promise;
-            };
-            /**
-             * listDashboardCases
+             * listDashboardCasesByPage
              * @method
-             * @name OtrService#listDashboardCasesUsingGET
+             * @name OtrService#listDashboardCasesByPageUsingGET
              * @param {object} parameters - method options and parameters
              * @param {string} parameters.caseStatuses - caseStatuses
+             * @param {string} parameters.defendantFirstName - defendantFirstName
              * @param {integer} parameters.defendantId - defendantId
+             * @param {string} parameters.defendantLastName - defendantLastName
+             * @param {boolean} parameters.includeAbandoned - includeAbandoned
+             * @param {boolean} parameters.includeCitationsWithoutCase - includeCitationsWithoutCase
              * @param {boolean} parameters.includeDeleted - includeDeleted
+             * @param {integer} parameters.lastActivityAfterMillis - lastActivityAfterMillis
              * @param {integer} parameters.limit - limit
              * @param {boolean} parameters.needsAttention - needsAttention
-             * @param {string} parameters.previousPageToken - previousPageToken
+             * @param {integer} parameters.page - page
+             * @param {string} parameters.query - query
              * @param {string} parameters.sortBy - sortBy
              * @param {string} parameters.statusCategories - statusCategories
+             * @param {boolean} parameters.unreadMessagesOnly - unreadMessagesOnly
              * @param {integer} parameters.userId - userId
              */
-            OtrService.prototype.listDashboardCasesUsingGET = function(parameters) {
+            OtrService.prototype.listDashboardCasesByPageUsingGET = function(parameters) {
                 if (parameters === undefined) {
                     parameters = {};
                 }
                 var deferred = $q.defer();
                 var domain = this.domain,
-                    path = '/api/v3/users/{userId}/cases';
+                    path = '/api/v4/users/{userId}/cases';
                 var body = {},
                     queryParameters = {},
                     headers = {},
@@ -19140,14 +20046,34 @@ angular.module('otrBackendService', [])
                     queryParameters['caseStatuses'] = parameters['caseStatuses'];
                 }
 
+                if (parameters['defendantFirstName'] !== undefined) {
+                    queryParameters['defendantFirstName'] = parameters['defendantFirstName'];
+                }
+
                 if (parameters['defendantId'] !== undefined) {
                     queryParameters['defendantId'] = parameters['defendantId'];
                 }
 
+                if (parameters['defendantLastName'] !== undefined) {
+                    queryParameters['defendantLastName'] = parameters['defendantLastName'];
+                }
+
+                if (parameters['includeAbandoned'] !== undefined) {
+                    queryParameters['includeAbandoned'] = parameters['includeAbandoned'];
+                }
+
+                if (parameters['includeCitationsWithoutCase'] !== undefined) {
+                    queryParameters['includeCitationsWithoutCase'] = parameters['includeCitationsWithoutCase'];
+                }
+
                 if (parameters['includeDeleted'] !== undefined) {
                     queryParameters['includeDeleted'] = parameters['includeDeleted'];
                 }
 
+                if (parameters['lastActivityAfterMillis'] !== undefined) {
+                    queryParameters['lastActivityAfterMillis'] = parameters['lastActivityAfterMillis'];
+                }
+
                 /** set default value **/
                 queryParameters['limit'] = 50;
 
@@ -19159,8 +20085,12 @@ angular.module('otrBackendService', [])
                     queryParameters['needsAttention'] = parameters['needsAttention'];
                 }
 
-                if (parameters['previousPageToken'] !== undefined) {
-                    queryParameters['previousPageToken'] = parameters['previousPageToken'];
+                if (parameters['page'] !== undefined) {
+                    queryParameters['page'] = parameters['page'];
+                }
+
+                if (parameters['query'] !== undefined) {
+                    queryParameters['query'] = parameters['query'];
                 }
 
                 if (parameters['sortBy'] !== undefined) {
@@ -19171,6 +20101,10 @@ angular.module('otrBackendService', [])
                     queryParameters['statusCategories'] = parameters['statusCategories'];
                 }
 
+                if (parameters['unreadMessagesOnly'] !== undefined) {
+                    queryParameters['unreadMessagesOnly'] = parameters['unreadMessagesOnly'];
+                }
+
                 path = path.replace('{userId}', parameters['userId']);
 
                 if (parameters['userId'] === undefined) {