From ce9752bf78f53f8697c088292f77055dd7da92b0 Mon Sep 17 00:00:00 2001
From: Yazeed Loonat <YazeedLoonat@gmail.com>
Date: Thu, 22 Feb 2024 16:19:42 -0700
Subject: [PATCH] feat: creating external listing "stub" for doorway usage
 (#666)

---
 .../core/src/listings/listings.controller.ts  |   23 +
 backend/core/types/src/backend-swagger.ts     | 2423 +++++++++--------
 2 files changed, 1260 insertions(+), 1186 deletions(-)

diff --git a/backend/core/src/listings/listings.controller.ts b/backend/core/src/listings/listings.controller.ts
index 7ff7a43443..95d5ad40b5 100644
--- a/backend/core/src/listings/listings.controller.ts
+++ b/backend/core/src/listings/listings.controller.ts
@@ -91,6 +91,29 @@ export class ListingsController {
     return { listingCsv, unitCsv }
   }
 
+  @Get(`external/:id`)
+  @ApiOperation({
+    summary: "Get listing for external consumption by id",
+    operationId: "externalRetrieve",
+  })
+  @UseInterceptors(ClassSerializerInterceptor)
+  @UsePipes(new ValidationPipe(defaultValidationPipeOptions))
+  async retrieveForExternalConsumption(
+    @Headers("language") language: Language,
+    @Param("id", new ParseUUIDPipe({ version: "4" })) listingId: string,
+    @Query() queryParams: ListingsRetrieveQueryParams
+  ) {
+    if (listingId === undefined || listingId === "undefined") {
+      return mapTo(ListingDto, {})
+    }
+    const listing = mapTo(
+      ListingDto,
+      await this.listingsService.findOne(listingId, language, queryParams.view)
+    )
+
+    return JSON.stringify(listing)
+  }
+
   @Get(`:id`)
   @ApiOperation({ summary: "Get listing by id", operationId: "retrieve" })
   @UseInterceptors(ClassSerializerInterceptor)
diff --git a/backend/core/types/src/backend-swagger.ts b/backend/core/types/src/backend-swagger.ts
index 499a2ec7bb..c3aa099c11 100644
--- a/backend/core/types/src/backend-swagger.ts
+++ b/backend/core/types/src/backend-swagger.ts
@@ -89,68 +89,57 @@ export class PagedResult<T> implements IPagedResult<T> {
 // customer definition
 // empty
 
-export class AmiChartsService {
+export class AuthService {
   /**
-   * List amiCharts
+   * Login
    */
-  list(
+  login(
     params: {
-      /**  */
-      jurisdictionName?: string
-      /**  */
-      jurisdictionId?: string
+      /** requestBody */
+      body?: Login
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<AmiChart[]> {
+  ): Promise<Status> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/amiCharts"
+      let url = basePath + "/auth/login"
 
-      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
-      configs.params = {
-        jurisdictionName: params["jurisdictionName"],
-        jurisdictionId: params["jurisdictionId"],
-      }
-      let data = null
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+
+      let data = params.body
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Create amiChart
+   * Logout
    */
-  create(
-    params: {
-      /** requestBody */
-      body?: AmiChartCreate
-    } = {} as any,
-    options: IRequestOptions = {}
-  ): Promise<AmiChart> {
+  logout(options: IRequestOptions = {}): Promise<LogoutResponse> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/amiCharts"
+      let url = basePath + "/auth/logout"
 
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
 
-      let data = params.body
+      let data = null
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Delete amiChart by id
+   * Request mfa code
    */
-  delete(
+  requestMfaCode(
     params: {
       /** requestBody */
-      body?: Id
+      body?: RequestMfaCode
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<any> {
+  ): Promise<RequestMfaCodeResponse> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/amiCharts"
+      let url = basePath + "/auth/request-mfa-code"
 
-      const configs: IRequestConfig = getConfigs("delete", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
       let data = params.body
 
@@ -159,19 +148,19 @@ export class AmiChartsService {
     })
   }
   /**
-   * Update amiChart
+   * Get mfa info
    */
-  update(
+  getMfaInfo(
     params: {
       /** requestBody */
-      body?: AmiChartUpdate
+      body?: GetMfaInfo
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<AmiChart> {
+  ): Promise<GetMfaInfoResponse> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/amiCharts/{amiChartId}"
+      let url = basePath + "/auth/mfa-info"
 
-      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
       let data = params.body
 
@@ -180,18 +169,11 @@ export class AmiChartsService {
     })
   }
   /**
-   * Get amiChart by id
+   * Requests a new token given a refresh token
    */
-  retrieve(
-    params: {
-      /**  */
-      amiChartId: string
-    } = {} as any,
-    options: IRequestOptions = {}
-  ): Promise<AmiChart> {
+  requestNewToken(options: IRequestOptions = {}): Promise<Status> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/amiCharts/{amiChartId}"
-      url = url.replace("{amiChartId}", params["amiChartId"] + "")
+      let url = basePath + "/auth/requestNewToken"
 
       const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
 
@@ -203,33 +185,16 @@ export class AmiChartsService {
   }
 }
 
-export class ApplicationFlaggedSetsService {
+export class UserService {
   /**
-   * Meta information for application flagged sets
+   *
    */
-  meta(
-    params: {
-      /**  */
-      page?: number
-      /**  */
-      limit?: number
-      /**  */
-      listingId: string
-      /**  */
-      view?: string
-    } = {} as any,
-    options: IRequestOptions = {}
-  ): Promise<ApplicationFlaggedSetMeta> {
+  userControllerProfile(options: IRequestOptions = {}): Promise<User> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationFlaggedSets/meta"
+      let url = basePath + "/user"
 
       const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
-      configs.params = {
-        page: params["page"],
-        limit: params["limit"],
-        listingId: params["listingId"],
-        view: params["view"],
-      }
+
       let data = null
 
       configs.data = data
@@ -237,71 +202,61 @@ export class ApplicationFlaggedSetsService {
     })
   }
   /**
-   * List application flagged sets
+   * Create user
    */
-  list(
+  create(
     params: {
       /**  */
-      page?: number
-      /**  */
-      limit?: number
-      /**  */
-      listingId: string
-      /**  */
-      view?: string
+      noWelcomeEmail?: boolean
+      /** requestBody */
+      body?: UserCreate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<PaginatedApplicationFlaggedSet> {
+  ): Promise<UserBasic> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationFlaggedSets"
+      let url = basePath + "/user"
 
-      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
-      configs.params = {
-        page: params["page"],
-        limit: params["limit"],
-        listingId: params["listingId"],
-        view: params["view"],
-      }
-      let data = null
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      configs.params = { noWelcomeEmail: params["noWelcomeEmail"] }
+      let data = params.body
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Retrieve application flagged set by id
+   * Delete user by id
    */
-  retrieve(
+  delete(
     params: {
-      /**  */
-      afsId: string
+      /** requestBody */
+      body?: Id
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<ApplicationFlaggedSet> {
+  ): Promise<any> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationFlaggedSets/{afsId}"
-      url = url.replace("{afsId}", params["afsId"] + "")
+      let url = basePath + "/user"
 
-      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("delete", "application/json", url, options)
 
-      let data = null
+      let data = params.body
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Resolve application flagged set
+   * Resend confirmation
    */
-  resolve(
+  resendPartnerConfirmation(
     params: {
       /** requestBody */
-      body?: ApplicationFlaggedSetResolve
+      body?: Email
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<ApplicationFlaggedSet> {
+  ): Promise<Status> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationFlaggedSets/resolve"
+      let url = basePath + "/user/resend-partner-confirmation"
 
       const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
@@ -312,19 +267,19 @@ export class ApplicationFlaggedSetsService {
     })
   }
   /**
-   * Reset flagged set confirmation alert
+   * Verifies token is valid
    */
-  resetConfirmationAlert(
+  isUserConfirmationTokenValid(
     params: {
       /** requestBody */
-      body?: Id
+      body?: Confirm
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Status> {
+  ): Promise<boolean> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationFlaggedSets/{id}"
+      let url = basePath + "/user/is-confirmation-token-valid"
 
-      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
       let data = params.body
 
@@ -333,52 +288,61 @@ export class ApplicationFlaggedSetsService {
     })
   }
   /**
-   * Trigger the duplicate check process
+   * Resend confirmation
    */
-  process(options: IRequestOptions = {}): Promise<string> {
+  resendConfirmation(
+    params: {
+      /** requestBody */
+      body?: Email
+    } = {} as any,
+    options: IRequestOptions = {}
+  ): Promise<Status> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationFlaggedSets/process"
+      let url = basePath + "/user/resend-confirmation"
 
       const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
-      let data = null
+      let data = params.body
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
-}
-
-export class ApplicationMethodsService {
   /**
-   * List applicationMethods
+   * Confirm email
    */
-  list(options: IRequestOptions = {}): Promise<ApplicationMethod[]> {
+  confirm(
+    params: {
+      /** requestBody */
+      body?: Confirm
+    } = {} as any,
+    options: IRequestOptions = {}
+  ): Promise<Status> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationMethods"
+      let url = basePath + "/user/confirm"
 
-      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
 
-      let data = null
+      let data = params.body
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Create applicationMethod
+   * Forgot Password
    */
-  create(
+  forgotPassword(
     params: {
       /** requestBody */
-      body?: ApplicationMethodCreate
+      body?: ForgotPassword
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<ApplicationMethod> {
+  ): Promise<ForgotPasswordResponse> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationMethods"
+      let url = basePath + "/user/forgot-password"
 
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
 
       let data = params.body
 
@@ -387,19 +351,19 @@ export class ApplicationMethodsService {
     })
   }
   /**
-   * Delete applicationMethod by id
+   * Update Password
    */
-  delete(
+  updatePassword(
     params: {
       /** requestBody */
-      body?: Id
+      body?: UpdatePassword
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<any> {
+  ): Promise<Status> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationMethods"
+      let url = basePath + "/user/update-password"
 
-      const configs: IRequestConfig = getConfigs("delete", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
 
       let data = params.body
 
@@ -408,17 +372,17 @@ export class ApplicationMethodsService {
     })
   }
   /**
-   * Update applicationMethod
+   * Update user
    */
   update(
     params: {
       /** requestBody */
-      body?: ApplicationMethodUpdate
+      body?: UserUpdate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<ApplicationMethod> {
+  ): Promise<User> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationMethods/{applicationMethodId}"
+      let url = basePath + "/user/{id}"
 
       const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
 
@@ -429,18 +393,18 @@ export class ApplicationMethodsService {
     })
   }
   /**
-   * Get applicationMethod by id
+   * Get user by id
    */
   retrieve(
     params: {
       /**  */
-      applicationMethodId: string
+      id: string
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<ApplicationMethod> {
+  ): Promise<User> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applicationMethods/{applicationMethodId}"
-      url = url.replace("{applicationMethodId}", params["applicationMethodId"] + "")
+      let url = basePath + "/user/{id}"
+      url = url.replace("{id}", params["id"] + "")
 
       const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
 
@@ -450,46 +414,31 @@ export class ApplicationMethodsService {
       axios(configs, resolve, reject)
     })
   }
-}
-
-export class ApplicationsService {
   /**
-   * List applications
+   * List users
    */
   list(
     params: {
       /**  */
       page?: number
       /**  */
-      limit?: number
+      limit?: number | "all"
       /**  */
-      listingId?: string
+      filter?: UserFilterParams[]
       /**  */
       search?: string
-      /**  */
-      userId?: string
-      /**  */
-      orderBy?: string
-      /**  */
-      order?: string
-      /**  */
-      markedAsDuplicate?: boolean
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<PaginatedApplication> {
+  ): Promise<PaginatedUserList> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applications"
+      let url = basePath + "/user/list"
 
       const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
       configs.params = {
         page: params["page"],
         limit: params["limit"],
-        listingId: params["listingId"],
+        filter: params["filter"],
         search: params["search"],
-        userId: params["userId"],
-        orderBy: params["orderBy"],
-        order: params["order"],
-        markedAsDuplicate: params["markedAsDuplicate"],
       }
       let data = null
 
@@ -498,40 +447,34 @@ export class ApplicationsService {
     })
   }
   /**
-   * Create application
+   * List users in CSV
    */
-  create(
-    params: {
-      /** requestBody */
-      body?: ApplicationCreate
-    } = {} as any,
-    options: IRequestOptions = {}
-  ): Promise<Application> {
+  listAsCsv(options: IRequestOptions = {}): Promise<string> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applications"
+      let url = basePath + "/user/csv"
 
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
 
-      let data = params.body
+      let data = null
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Delete application by id
+   * Invite user
    */
-  delete(
+  invite(
     params: {
       /** requestBody */
-      body?: Id
+      body?: UserInvite
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<any> {
+  ): Promise<UserBasic> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applications"
+      let url = basePath + "/user/invite"
 
-      const configs: IRequestConfig = getConfigs("delete", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
       let data = params.body
 
@@ -539,72 +482,53 @@ export class ApplicationsService {
       axios(configs, resolve, reject)
     })
   }
+}
+
+export class UserProfileService {
   /**
-   * List applications as csv
+   * Update profile user
    */
-  listAsCsv(
+  update(
     params: {
-      /**  */
-      page?: number
-      /**  */
-      limit?: number
-      /**  */
-      search?: string
-      /**  */
-      userId?: string
-      /**  */
-      orderBy?: string
-      /**  */
-      order?: string
-      /**  */
-      markedAsDuplicate?: boolean
-      /**  */
-      listingId: string
-      /**  */
-      timeZone?: string
-      /**  */
-      includeDemographics?: boolean
+      /** requestBody */
+      body?: UserProfileUpdate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Status> {
+  ): Promise<User> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applications/csv"
+      let url = basePath + "/userProfile/{id}"
 
-      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
-      configs.params = {
-        page: params["page"],
-        limit: params["limit"],
-        search: params["search"],
-        userId: params["userId"],
-        orderBy: params["orderBy"],
-        order: params["order"],
-        markedAsDuplicate: params["markedAsDuplicate"],
-        listingId: params["listingId"],
-        timeZone: params["timeZone"],
-        includeDemographics: params["includeDemographics"],
-      }
-      let data = null
+      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
+
+      let data = params.body
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
+}
+
+export class AmiChartsService {
   /**
-   * Get application by id
+   * List amiCharts
    */
-  retrieve(
+  list(
     params: {
       /**  */
-      id: string
+      jurisdictionName?: string
+      /**  */
+      jurisdictionId?: string
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Application> {
+  ): Promise<AmiChart[]> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applications/{id}"
-      url = url.replace("{id}", params["id"] + "")
+      let url = basePath + "/amiCharts"
 
       const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
-
+      configs.params = {
+        jurisdictionName: params["jurisdictionName"],
+        jurisdictionId: params["jurisdictionId"],
+      }
       let data = null
 
       configs.data = data
@@ -612,22 +536,19 @@ export class ApplicationsService {
     })
   }
   /**
-   * Update application by id
+   * Create amiChart
    */
-  update(
+  create(
     params: {
-      /**  */
-      id: string
       /** requestBody */
-      body?: ApplicationUpdate
+      body?: AmiChartCreate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Application> {
+  ): Promise<AmiChart> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applications/{id}"
-      url = url.replace("{id}", params["id"] + "")
+      let url = basePath + "/amiCharts"
 
-      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
       let data = params.body
 
@@ -636,19 +557,19 @@ export class ApplicationsService {
     })
   }
   /**
-   * Submit application
+   * Delete amiChart by id
    */
-  submit(
+  delete(
     params: {
       /** requestBody */
-      body?: ApplicationCreate
+      body?: Id
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Application> {
+  ): Promise<any> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applications/submit"
+      let url = basePath + "/amiCharts"
 
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("delete", "application/json", url, options)
 
       let data = params.body
 
@@ -657,19 +578,19 @@ export class ApplicationsService {
     })
   }
   /**
-   * Verify application can be saved
+   * Update amiChart
    */
-  submissionValidation(
+  update(
     params: {
       /** requestBody */
-      body?: ApplicationCreate
+      body?: AmiChartUpdate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<boolean> {
+  ): Promise<AmiChart> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/applications/verify"
+      let url = basePath + "/amiCharts/{amiChartId}"
 
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
 
       let data = params.body
 
@@ -677,47 +598,57 @@ export class ApplicationsService {
       axios(configs, resolve, reject)
     })
   }
-}
-
-export class AssetsService {
   /**
-   * Create asset
+   * Get amiChart by id
    */
-  create(
+  retrieve(
     params: {
-      /** requestBody */
-      body?: AssetCreate
+      /**  */
+      amiChartId: string
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Asset> {
+  ): Promise<AmiChart> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/assets"
+      let url = basePath + "/amiCharts/{amiChartId}"
+      url = url.replace("{amiChartId}", params["amiChartId"] + "")
 
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
 
-      let data = params.body
+      let data = null
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
+}
+
+export class ApplicationFlaggedSetsService {
   /**
-   * List assets
+   * Meta information for application flagged sets
    */
-  list(
+  meta(
     params: {
       /**  */
       page?: number
       /**  */
       limit?: number
+      /**  */
+      listingId: string
+      /**  */
+      view?: string
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<PaginatedAssets> {
+  ): Promise<ApplicationFlaggedSetMeta> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/assets"
+      let url = basePath + "/applicationFlaggedSets/meta"
 
       const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
-      configs.params = { page: params["page"], limit: params["limit"] }
+      configs.params = {
+        page: params["page"],
+        limit: params["limit"],
+        listingId: params["listingId"],
+        view: params["view"],
+      }
       let data = null
 
       configs.data = data
@@ -725,39 +656,50 @@ export class AssetsService {
     })
   }
   /**
-   * Create presigned upload metadata
+   * List application flagged sets
    */
-  createPresignedUploadMetadata(
+  list(
     params: {
-      /** requestBody */
-      body?: CreatePresignedUploadMetadata
+      /**  */
+      page?: number
+      /**  */
+      limit?: number
+      /**  */
+      listingId: string
+      /**  */
+      view?: string
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<CreatePresignedUploadMetadataResponse> {
+  ): Promise<PaginatedApplicationFlaggedSet> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/assets/presigned-upload-metadata"
-
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      let url = basePath + "/applicationFlaggedSets"
 
-      let data = params.body
+      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
+      configs.params = {
+        page: params["page"],
+        limit: params["limit"],
+        listingId: params["listingId"],
+        view: params["view"],
+      }
+      let data = null
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Get asset by id
+   * Retrieve application flagged set by id
    */
   retrieve(
     params: {
       /**  */
-      assetId: string
+      afsId: string
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Asset> {
+  ): Promise<ApplicationFlaggedSet> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/assets/{assetId}"
-      url = url.replace("{assetId}", params["assetId"] + "")
+      let url = basePath + "/applicationFlaggedSets/{afsId}"
+      url = url.replace("{afsId}", params["afsId"] + "")
 
       const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
 
@@ -767,21 +709,18 @@ export class AssetsService {
       axios(configs, resolve, reject)
     })
   }
-}
-
-export class AuthService {
   /**
-   * Login
+   * Resolve application flagged set
    */
-  login(
+  resolve(
     params: {
       /** requestBody */
-      body?: Login
+      body?: ApplicationFlaggedSetResolve
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Status> {
+  ): Promise<ApplicationFlaggedSet> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/auth/login"
+      let url = basePath + "/applicationFlaggedSets/resolve"
 
       const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
@@ -792,11 +731,50 @@ export class AuthService {
     })
   }
   /**
-   * Logout
+   * Reset flagged set confirmation alert
    */
-  logout(options: IRequestOptions = {}): Promise<LogoutResponse> {
-    return new Promise((resolve, reject) => {
-      let url = basePath + "/auth/logout"
+  resetConfirmationAlert(
+    params: {
+      /** requestBody */
+      body?: Id
+    } = {} as any,
+    options: IRequestOptions = {}
+  ): Promise<Status> {
+    return new Promise((resolve, reject) => {
+      let url = basePath + "/applicationFlaggedSets/{id}"
+
+      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
+
+      let data = params.body
+
+      configs.data = data
+      axios(configs, resolve, reject)
+    })
+  }
+  /**
+   * Trigger the duplicate check process
+   */
+  process(options: IRequestOptions = {}): Promise<string> {
+    return new Promise((resolve, reject) => {
+      let url = basePath + "/applicationFlaggedSets/process"
+
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+
+      let data = null
+
+      configs.data = data
+      axios(configs, resolve, reject)
+    })
+  }
+}
+
+export class ApplicationMethodsService {
+  /**
+   * List applicationMethods
+   */
+  list(options: IRequestOptions = {}): Promise<ApplicationMethod[]> {
+    return new Promise((resolve, reject) => {
+      let url = basePath + "/applicationMethods"
 
       const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
 
@@ -807,17 +785,17 @@ export class AuthService {
     })
   }
   /**
-   * Request mfa code
+   * Create applicationMethod
    */
-  requestMfaCode(
+  create(
     params: {
       /** requestBody */
-      body?: RequestMfaCode
+      body?: ApplicationMethodCreate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<RequestMfaCodeResponse> {
+  ): Promise<ApplicationMethod> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/auth/request-mfa-code"
+      let url = basePath + "/applicationMethods"
 
       const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
@@ -828,19 +806,19 @@ export class AuthService {
     })
   }
   /**
-   * Get mfa info
+   * Delete applicationMethod by id
    */
-  getMfaInfo(
+  delete(
     params: {
       /** requestBody */
-      body?: GetMfaInfo
+      body?: Id
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<GetMfaInfoResponse> {
+  ): Promise<any> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/auth/mfa-info"
+      let url = basePath + "/applicationMethods"
 
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("delete", "application/json", url, options)
 
       let data = params.body
 
@@ -849,29 +827,39 @@ export class AuthService {
     })
   }
   /**
-   * Requests a new token given a refresh token
+   * Update applicationMethod
    */
-  requestNewToken(options: IRequestOptions = {}): Promise<Status> {
+  update(
+    params: {
+      /** requestBody */
+      body?: ApplicationMethodUpdate
+    } = {} as any,
+    options: IRequestOptions = {}
+  ): Promise<ApplicationMethod> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/auth/requestNewToken"
+      let url = basePath + "/applicationMethods/{applicationMethodId}"
 
-      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
 
-      let data = null
+      let data = params.body
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
-}
-
-export class UserService {
   /**
-   *
+   * Get applicationMethod by id
    */
-  userControllerProfile(options: IRequestOptions = {}): Promise<User> {
+  retrieve(
+    params: {
+      /**  */
+      applicationMethodId: string
+    } = {} as any,
+    options: IRequestOptions = {}
+  ): Promise<ApplicationMethod> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user"
+      let url = basePath + "/applicationMethods/{applicationMethodId}"
+      url = url.replace("{applicationMethodId}", params["applicationMethodId"] + "")
 
       const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
 
@@ -881,43 +869,67 @@ export class UserService {
       axios(configs, resolve, reject)
     })
   }
+}
+
+export class ApplicationsService {
   /**
-   * Create user
+   * List applications
    */
-  create(
+  list(
     params: {
       /**  */
-      noWelcomeEmail?: boolean
-      /** requestBody */
-      body?: UserCreate
+      page?: number
+      /**  */
+      limit?: number
+      /**  */
+      listingId?: string
+      /**  */
+      search?: string
+      /**  */
+      userId?: string
+      /**  */
+      orderBy?: string
+      /**  */
+      order?: string
+      /**  */
+      markedAsDuplicate?: boolean
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<UserBasic> {
+  ): Promise<PaginatedApplication> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user"
+      let url = basePath + "/applications"
 
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
-      configs.params = { noWelcomeEmail: params["noWelcomeEmail"] }
-      let data = params.body
+      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
+      configs.params = {
+        page: params["page"],
+        limit: params["limit"],
+        listingId: params["listingId"],
+        search: params["search"],
+        userId: params["userId"],
+        orderBy: params["orderBy"],
+        order: params["order"],
+        markedAsDuplicate: params["markedAsDuplicate"],
+      }
+      let data = null
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Delete user by id
+   * Create application
    */
-  delete(
+  create(
     params: {
       /** requestBody */
-      body?: Id
+      body?: ApplicationCreate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<any> {
+  ): Promise<Application> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user"
+      let url = basePath + "/applications"
 
-      const configs: IRequestConfig = getConfigs("delete", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
       let data = params.body
 
@@ -926,19 +938,19 @@ export class UserService {
     })
   }
   /**
-   * Resend confirmation
+   * Delete application by id
    */
-  resendPartnerConfirmation(
+  delete(
     params: {
       /** requestBody */
-      body?: Email
+      body?: Id
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Status> {
+  ): Promise<any> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user/resend-partner-confirmation"
+      let url = basePath + "/applications"
 
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("delete", "application/json", url, options)
 
       let data = params.body
 
@@ -947,80 +959,121 @@ export class UserService {
     })
   }
   /**
-   * Verifies token is valid
+   * List applications as csv
    */
-  isUserConfirmationTokenValid(
+  listAsCsv(
     params: {
-      /** requestBody */
-      body?: Confirm
+      /**  */
+      page?: number
+      /**  */
+      limit?: number
+      /**  */
+      search?: string
+      /**  */
+      userId?: string
+      /**  */
+      orderBy?: string
+      /**  */
+      order?: string
+      /**  */
+      markedAsDuplicate?: boolean
+      /**  */
+      listingId: string
+      /**  */
+      timeZone?: string
+      /**  */
+      includeDemographics?: boolean
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<boolean> {
+  ): Promise<Status> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user/is-confirmation-token-valid"
-
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      let url = basePath + "/applications/csv"
 
-      let data = params.body
+      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
+      configs.params = {
+        page: params["page"],
+        limit: params["limit"],
+        search: params["search"],
+        userId: params["userId"],
+        orderBy: params["orderBy"],
+        order: params["order"],
+        markedAsDuplicate: params["markedAsDuplicate"],
+        listingId: params["listingId"],
+        timeZone: params["timeZone"],
+        includeDemographics: params["includeDemographics"],
+      }
+      let data = null
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Resend confirmation
+   * Raw list of applications
    */
-  resendConfirmation(
+  rawApplicationsList(
     params: {
-      /** requestBody */
-      body?: Email
+      /**  */
+      listingId: string
+      /**  */
+      timeZone?: string
+      /**  */
+      includeDemographics?: boolean
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Status> {
+  ): Promise<object[]> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user/resend-confirmation"
-
-      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
+      let url = basePath + "/applications/rawApplicationsList"
 
-      let data = params.body
+      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
+      configs.params = {
+        listingId: params["listingId"],
+        timeZone: params["timeZone"],
+        includeDemographics: params["includeDemographics"],
+      }
+      let data = null
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Confirm email
+   * Get application by id
    */
-  confirm(
+  retrieve(
     params: {
-      /** requestBody */
-      body?: Confirm
+      /**  */
+      id: string
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Status> {
+  ): Promise<Application> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user/confirm"
+      let url = basePath + "/applications/{id}"
+      url = url.replace("{id}", params["id"] + "")
 
-      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
 
-      let data = params.body
+      let data = null
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * Forgot Password
+   * Update application by id
    */
-  forgotPassword(
+  update(
     params: {
+      /**  */
+      id: string
       /** requestBody */
-      body?: ForgotPassword
+      body?: ApplicationUpdate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<ForgotPasswordResponse> {
+  ): Promise<Application> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user/forgot-password"
+      let url = basePath + "/applications/{id}"
+      url = url.replace("{id}", params["id"] + "")
 
       const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
 
@@ -1031,19 +1084,19 @@ export class UserService {
     })
   }
   /**
-   * Update Password
+   * Submit application
    */
-  updatePassword(
+  submit(
     params: {
       /** requestBody */
-      body?: UpdatePassword
+      body?: ApplicationCreate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<Status> {
+  ): Promise<Application> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user/update-password"
+      let url = basePath + "/applications/submit"
 
-      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
       let data = params.body
 
@@ -1052,19 +1105,19 @@ export class UserService {
     })
   }
   /**
-   * Update user
+   * Verify application can be saved
    */
-  update(
+  submissionValidation(
     params: {
       /** requestBody */
-      body?: UserUpdate
+      body?: ApplicationCreate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<User> {
+  ): Promise<boolean> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user/{id}"
+      let url = basePath + "/applications/verify"
 
-      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
       let data = params.body
 
@@ -1072,69 +1125,47 @@ export class UserService {
       axios(configs, resolve, reject)
     })
   }
+}
+
+export class AssetsService {
   /**
-   * Get user by id
+   * Create asset
    */
-  retrieve(
+  create(
     params: {
-      /**  */
-      id: string
+      /** requestBody */
+      body?: AssetCreate
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<User> {
+  ): Promise<Asset> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user/{id}"
-      url = url.replace("{id}", params["id"] + "")
+      let url = basePath + "/assets"
 
-      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
-      let data = null
+      let data = params.body
 
       configs.data = data
       axios(configs, resolve, reject)
     })
   }
   /**
-   * List users
+   * List assets
    */
   list(
     params: {
       /**  */
       page?: number
       /**  */
-      limit?: number | "all"
-      /**  */
-      filter?: UserFilterParams[]
-      /**  */
-      search?: string
+      limit?: number
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<PaginatedUserList> {
-    return new Promise((resolve, reject) => {
-      let url = basePath + "/user/list"
-
-      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
-      configs.params = {
-        page: params["page"],
-        limit: params["limit"],
-        filter: params["filter"],
-        search: params["search"],
-      }
-      let data = null
-
-      configs.data = data
-      axios(configs, resolve, reject)
-    })
-  }
-  /**
-   * List users in CSV
-   */
-  listAsCsv(options: IRequestOptions = {}): Promise<string> {
+  ): Promise<PaginatedAssets> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user/csv"
+      let url = basePath + "/assets"
 
       const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
-
+      configs.params = { page: params["page"], limit: params["limit"] }
       let data = null
 
       configs.data = data
@@ -1142,17 +1173,17 @@ export class UserService {
     })
   }
   /**
-   * Invite user
+   * Create presigned upload metadata
    */
-  invite(
+  createPresignedUploadMetadata(
     params: {
       /** requestBody */
-      body?: UserInvite
+      body?: CreatePresignedUploadMetadata
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<UserBasic> {
+  ): Promise<CreatePresignedUploadMetadataResponse> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/user/invite"
+      let url = basePath + "/assets/presigned-upload-metadata"
 
       const configs: IRequestConfig = getConfigs("post", "application/json", url, options)
 
@@ -1162,25 +1193,23 @@ export class UserService {
       axios(configs, resolve, reject)
     })
   }
-}
-
-export class UserProfileService {
   /**
-   * Update profile user
+   * Get asset by id
    */
-  update(
+  retrieve(
     params: {
-      /** requestBody */
-      body?: UserProfileUpdate
+      /**  */
+      assetId: string
     } = {} as any,
     options: IRequestOptions = {}
-  ): Promise<User> {
+  ): Promise<Asset> {
     return new Promise((resolve, reject) => {
-      let url = basePath + "/userProfile/{id}"
+      let url = basePath + "/assets/{assetId}"
+      url = url.replace("{assetId}", params["assetId"] + "")
 
-      const configs: IRequestConfig = getConfigs("put", "application/json", url, options)
+      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
 
-      let data = params.body
+      let data = null
 
       configs.data = data
       axios(configs, resolve, reject)
@@ -1418,6 +1447,30 @@ export class ListingsService {
       axios(configs, resolve, reject)
     })
   }
+  /**
+   * Get listing for external consumption by id
+   */
+  externalRetrieve(
+    params: {
+      /**  */
+      id: string
+      /**  */
+      view?: string
+    } = {} as any,
+    options: IRequestOptions = {}
+  ): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let url = basePath + "/listings/external/{id}"
+      url = url.replace("{id}", params["id"] + "")
+
+      const configs: IRequestConfig = getConfigs("get", "application/json", url, options)
+      configs.params = { view: params["view"] }
+      let data = null
+
+      configs.data = data
+      axios(configs, resolve, reject)
+    })
+  }
   /**
    * Get listing by id
    */
@@ -2353,178 +2406,115 @@ export class MapLayersService {
   }
 }
 
-export interface AmiChartItem {
-  /**  */
-  percentOfAmi: number
-
-  /**  */
-  householdSize: number
-
-  /**  */
-  income: number
-}
-
-export interface Id {
+export interface UserErrorExtraModel {
   /**  */
-  id: string
+  userErrorMessages: EnumUserErrorExtraModelUserErrorMessages
 }
 
-export interface AmiChart {
-  /**  */
-  id: string
-
-  /**  */
-  createdAt: Date
-
+export interface Login {
   /**  */
-  updatedAt: Date
+  email: string
 
   /**  */
-  items: AmiChartItem[]
+  password: string
 
   /**  */
-  name: string
+  mfaCode?: string
 
   /**  */
-  jurisdiction: Id
+  mfaType?: EnumLoginMfaType
 }
 
-export interface AmiChartCreate {
-  /**  */
-  items: AmiChartItem[]
-
-  /**  */
-  name: string
-
+export interface Status {
   /**  */
-  jurisdiction: Id
+  status: string
 }
 
-export interface AmiChartUpdate {
-  /**  */
-  items: AmiChartItem[]
-
-  /**  */
-  name: string
-
-  /**  */
-  jurisdiction: Id
-
+export interface LogoutResponse {
   /**  */
-  id?: string
+  success: boolean
 }
 
-export interface ApplicationFlaggedSetMeta {
-  /**  */
-  totalCount?: number
-
+export interface RequestMfaCode {
   /**  */
-  totalResolvedCount?: number
+  email: string
 
   /**  */
-  totalPendingCount?: number
+  password: string
 
   /**  */
-  totalNamePendingCount?: number
+  mfaType: EnumRequestMfaCodeMfaType
 
   /**  */
-  totalEmailPendingCount?: number
+  phoneNumber?: string
 }
 
-export interface Address {
-  /**  */
-  id: string
-
-  /**  */
-  createdAt: Date
-
-  /**  */
-  updatedAt: Date
-
+export interface RequestMfaCodeResponse {
   /**  */
-  placeName?: string
+  phoneNumber?: string
 
   /**  */
-  city: string
+  email?: string
 
   /**  */
-  county?: string
+  phoneNumberVerified?: boolean
+}
 
+export interface GetMfaInfo {
   /**  */
-  state: string
+  email: string
 
   /**  */
-  street: string
+  password: string
+}
 
+export interface GetMfaInfoResponse {
   /**  */
-  street2?: string
+  phoneNumber?: string
 
   /**  */
-  zipCode: string
+  email?: string
 
   /**  */
-  latitude?: number
+  isMfaEnabled: boolean
 
   /**  */
-  longitude?: number
+  mfaUsedInThePast: boolean
 }
 
-export interface Applicant {
-  /**  */
-  address: Address
-
-  /**  */
-  workAddress: Address
-
+export interface IdName {
   /**  */
   id: string
 
   /**  */
-  createdAt: Date
-
-  /**  */
-  updatedAt: Date
-
-  /**  */
-  firstName?: string
-
-  /**  */
-  middleName?: string
-
-  /**  */
-  lastName?: string
-
-  /**  */
-  birthMonth?: string
-
-  /**  */
-  birthDay?: string
-
-  /**  */
-  birthYear?: string
+  name: string
+}
 
+export interface Id {
   /**  */
-  emailAddress?: string
+  id: string
+}
 
+export interface UserRoles {
   /**  */
-  noEmail?: boolean
+  user: Id
 
   /**  */
-  phoneNumber?: string
+  userId: string
 
   /**  */
-  phoneNumberType?: string
+  isAdmin?: boolean
 
   /**  */
-  noPhone?: boolean
+  isJurisdictionalAdmin?: boolean
 
   /**  */
-  workInRegion?: string
+  isPartner?: boolean
 }
 
-export interface AlternateContact {
+export interface Jurisdiction {
   /**  */
-  mailingAddress: Address
+  multiselectQuestions: Id[]
 
   /**  */
   id: string
@@ -2536,123 +2526,84 @@ export interface AlternateContact {
   updatedAt: Date
 
   /**  */
-  type?: string
-
-  /**  */
-  otherType?: string
+  name: string
 
   /**  */
-  firstName?: string
+  notificationsSignUpURL?: string
 
   /**  */
-  lastName?: string
+  languages: EnumJurisdictionLanguages[]
 
   /**  */
-  agency?: string
+  listingApprovalPermissions?: EnumJurisdictionListingApprovalPermissions[]
 
   /**  */
-  phoneNumber?: string
+  partnerTerms?: string
 
   /**  */
-  emailAddress?: string
-}
+  publicUrl: string
 
-export interface Accessibility {
   /**  */
-  mobility?: boolean
+  emailFromAddress: string
 
   /**  */
-  vision?: boolean
+  rentalAssistanceDefault: string
 
   /**  */
-  hearing?: boolean
+  enablePartnerSettings?: boolean
 
   /**  */
-  id: string
+  enableAccessibilityFeatures: boolean
 
   /**  */
-  createdAt: Date
+  enableUtilitiesIncluded: boolean
 
   /**  */
-  updatedAt: Date
+  enableGeocodingPreferences: boolean
 }
 
-export interface Demographics {
-  /**  */
-  id: string
-
-  /**  */
-  createdAt: Date
-
-  /**  */
-  updatedAt: Date
-
-  /**  */
-  ethnicity?: string
-
-  /**  */
-  gender?: string
-
-  /**  */
-  sexualOrientation?: string
-
+export interface User {
   /**  */
-  howDidYouHear: string[]
+  language?: Language
 
   /**  */
-  race?: string[]
-}
+  leasingAgentInListings?: IdName[]
 
-export interface HouseholdMember {
   /**  */
-  address: Address
+  roles?: CombinedRolesTypes
 
   /**  */
-  workAddress: Address
+  jurisdictions: Jurisdiction[]
 
   /**  */
   id: string
 
   /**  */
-  createdAt: Date
-
-  /**  */
-  updatedAt: Date
-
-  /**  */
-  orderId?: number
-
-  /**  */
-  firstName?: string
-
-  /**  */
-  middleName?: string
+  passwordUpdatedAt: Date
 
   /**  */
-  lastName?: string
+  passwordValidForDays: number
 
   /**  */
-  birthMonth?: string
+  confirmedAt?: Date
 
   /**  */
-  birthDay?: string
+  email: string
 
   /**  */
-  birthYear?: string
+  firstName: string
 
   /**  */
-  sameAddress?: string
+  middleName?: string
 
   /**  */
-  relationship?: string
+  lastName: string
 
   /**  */
-  workInRegion?: string
-}
+  dob?: Date
 
-export interface UnitType {
   /**  */
-  id: string
+  phoneNumber?: string
 
   /**  */
   createdAt: Date
@@ -2661,489 +2612,498 @@ export interface UnitType {
   updatedAt: Date
 
   /**  */
-  name: string
+  mfaEnabled?: boolean
 
   /**  */
-  numBedrooms: number
-}
+  lastLoginAt?: Date
 
-export interface ApplicationMultiselectQuestionOption {
   /**  */
-  key: string
+  failedLoginAttemptsCount?: number
 
   /**  */
-  checked: boolean
+  phoneNumberVerified?: boolean
 
   /**  */
-  mapPinPosition?: string
+  agreedToTermsOfService: boolean
 
   /**  */
-  extraData?: AllExtraDataTypes[]
-}
+  hitConfirmationURL?: Date
 
-export interface ApplicationMultiselectQuestion {
   /**  */
-  key: string
+  activeAccessToken?: string
 
   /**  */
-  claimed: boolean
+  activeRefreshToken?: string
+}
 
+export interface UserCreate {
   /**  */
-  options: ApplicationMultiselectQuestionOption[]
-}
+  language?: Language
 
-export interface Application {
   /**  */
-  incomePeriod?: IncomePeriod
+  password: string
 
   /**  */
-  status: ApplicationStatus
+  passwordConfirmation: string
 
   /**  */
-  language?: Language
+  emailConfirmation: string
 
   /**  */
-  submissionType: ApplicationSubmissionType
+  appUrl?: string
 
   /**  */
-  reviewStatus?: ApplicationReviewStatus
+  jurisdictions?: Id[]
 
   /**  */
-  applicant: Applicant
+  email: string
 
   /**  */
-  listing: Id
+  confirmedAt?: Date
 
   /**  */
-  user?: Id
+  firstName: string
 
   /**  */
-  mailingAddress: Address
+  middleName?: string
 
   /**  */
-  alternateAddress: Address
+  lastName: string
 
   /**  */
-  alternateContact: AlternateContact
+  dob?: Date
 
   /**  */
-  accessibility: Accessibility
+  phoneNumber?: string
 
   /**  */
-  demographics: Demographics
+  phoneNumberVerified?: boolean
 
   /**  */
-  householdMembers: HouseholdMember[]
+  hitConfirmationURL?: Date
 
   /**  */
-  preferredUnit: UnitType[]
+  activeAccessToken?: string
 
   /**  */
-  id: string
+  activeRefreshToken?: string
+}
 
+export interface UserBasic {
   /**  */
-  createdAt: Date
+  language?: Language
 
   /**  */
-  updatedAt: Date
+  roles: UserRoles
 
   /**  */
-  deletedAt?: Date
+  jurisdictions: Jurisdiction[]
 
   /**  */
-  appUrl?: string
+  leasingAgentInListings?: Id[]
 
   /**  */
-  additionalPhone?: boolean
+  id: string
 
   /**  */
-  additionalPhoneNumber?: string
+  email: string
 
   /**  */
-  additionalPhoneNumberType?: string
+  firstName: string
 
   /**  */
-  contactPreferences: string[]
+  middleName?: string
 
   /**  */
-  householdSize?: number
+  lastName: string
 
   /**  */
-  housingStatus?: string
+  phoneNumber?: string
+}
 
+export interface Email {
   /**  */
-  sendMailToMailingAddress?: boolean
+  email: string
 
   /**  */
-  householdExpectingChanges?: boolean
+  appUrl?: string
+}
 
+export interface Confirm {
   /**  */
-  householdStudent?: boolean
+  token: string
 
   /**  */
-  incomeVouchers?: boolean
+  password?: string
+}
 
+export interface ForgotPassword {
   /**  */
-  income?: string
+  email: string
 
   /**  */
-  preferences: ApplicationMultiselectQuestion[]
+  appUrl?: string
+}
 
+export interface ForgotPasswordResponse {
   /**  */
-  programs?: ApplicationMultiselectQuestion[]
+  message: string
+}
 
+export interface UpdatePassword {
   /**  */
-  acceptedTerms?: boolean
+  password: string
 
   /**  */
-  submissionDate?: Date
+  passwordConfirmation: string
 
   /**  */
-  markedAsDuplicate: boolean
+  token: string
+}
 
+export interface UserRolesOnly {
   /**  */
-  flagged?: boolean
+  isAdmin?: boolean
 
   /**  */
-  confirmationCode: string
+  isJurisdictionalAdmin?: boolean
+
+  /**  */
+  isPartner?: boolean
 }
 
-export interface ApplicationFlaggedSet {
+export interface UserUpdate {
   /**  */
-  resolvingUser: Id
+  language?: Language
 
   /**  */
-  applications: Application[]
+  id?: string
 
   /**  */
-  listing: Id
+  email?: string
 
   /**  */
-  id: string
+  password?: string
 
   /**  */
-  createdAt: Date
+  currentPassword?: string
 
   /**  */
-  updatedAt: Date
+  leasingAgentInListings?: Id[]
 
   /**  */
-  rule: EnumApplicationFlaggedSetRule
+  newEmail?: string
 
   /**  */
-  ruleKey: string
+  appUrl?: string
 
   /**  */
-  resolvedTime?: Date
+  jurisdictions: Id[]
 
   /**  */
-  listingId: string
+  roles?: UserRolesOnly
 
   /**  */
-  showConfirmationAlert: boolean
+  confirmedAt?: Date
 
   /**  */
-  status: EnumApplicationFlaggedSetStatus
-}
+  firstName: string
 
-export interface ApplicationFlaggedSetPaginationMeta {
   /**  */
-  totalFlagged: number
+  middleName?: string
 
   /**  */
-  currentPage: number
+  lastName: string
 
   /**  */
-  itemCount: number
+  dob?: Date
 
   /**  */
-  itemsPerPage: number
+  phoneNumber?: string
 
   /**  */
-  totalItems: number
+  phoneNumberVerified?: boolean
 
   /**  */
-  totalPages: number
-}
+  agreedToTermsOfService: boolean
 
-export interface PaginatedApplicationFlaggedSet {
   /**  */
-  items: ApplicationFlaggedSet[]
+  hitConfirmationURL?: Date
 
   /**  */
-  meta: ApplicationFlaggedSetPaginationMeta
-}
+  activeAccessToken?: string
 
-export interface ApplicationFlaggedSetResolve {
   /**  */
-  afsId: string
+  activeRefreshToken?: string
+}
 
+export interface UserFilterParams {
   /**  */
-  applications: Id[]
+  $comparison: EnumUserFilterParamsComparison
 
   /**  */
-  status: EnumApplicationFlaggedSetResolveStatus
-}
+  isPartner?: boolean
 
-export interface Status {
   /**  */
-  status: string
+  isPortalUser?: boolean
 }
 
-export interface Asset {
+export interface PaginationMeta {
   /**  */
-  id: string
+  currentPage: number
 
   /**  */
-  createdAt: Date
+  itemCount: number
 
   /**  */
-  updatedAt: Date
+  itemsPerPage: number
 
   /**  */
-  fileId: string
+  totalItems: number
 
   /**  */
-  label: string
+  totalPages: number
 }
 
-export interface PaperApplication {
+export interface PaginatedUserList {
   /**  */
-  language: Language
+  items: User[]
 
   /**  */
-  file?: CombinedFileTypes
+  meta: PaginationMeta
+}
 
+export interface UserRolesCreate {
   /**  */
-  id: string
+  isAdmin?: boolean
 
   /**  */
-  createdAt: Date
+  isJurisdictionalAdmin?: boolean
 
   /**  */
-  updatedAt: Date
+  isPartner?: boolean
 }
 
-export interface ApplicationMethod {
+export interface UserInvite {
   /**  */
-  type: ApplicationMethodType
+  language?: Language
 
   /**  */
-  paperApplications?: PaperApplication[]
+  jurisdictions: Id[]
 
   /**  */
-  listing: Id
+  leasingAgentInListings?: Id[]
 
   /**  */
-  id: string
+  roles?: UserRolesCreate
 
   /**  */
-  createdAt: Date
+  confirmedAt?: Date
 
   /**  */
-  updatedAt: Date
+  email: string
 
   /**  */
-  label?: string
+  firstName: string
 
   /**  */
-  externalReference?: string
+  middleName?: string
 
   /**  */
-  acceptsPostmarkedApplications?: boolean
+  lastName: string
+
+  /**  */
+  dob?: Date
 
   /**  */
   phoneNumber?: string
-}
 
-export interface AssetCreate {
   /**  */
-  fileId: string
+  phoneNumberVerified?: boolean
 
   /**  */
-  label: string
-}
+  hitConfirmationURL?: Date
 
-export interface PaperApplicationCreate {
   /**  */
-  language: Language
+  activeAccessToken?: string
 
   /**  */
-  file?: CombinedFileTypes
+  activeRefreshToken?: string
 }
 
-export interface ApplicationMethodCreate {
+export interface UserProfileUpdate {
+  /**  */
+  language?: Language
+
+  /**  */
+  password?: string
+
   /**  */
-  type: ApplicationMethodType
+  currentPassword?: string
 
   /**  */
-  paperApplications?: PaperApplicationCreate[]
+  jurisdictions: Id[]
 
   /**  */
-  label?: string
+  newEmail?: string
 
   /**  */
-  externalReference?: string
+  appUrl?: string
 
   /**  */
-  acceptsPostmarkedApplications?: boolean
+  id: string
 
   /**  */
-  phoneNumber?: string
+  firstName: string
 
   /**  */
-  listing: Id
-}
+  middleName?: string
 
-export interface AssetUpdate {
   /**  */
-  id?: string
+  lastName: string
 
   /**  */
-  fileId: string
+  dob?: Date
 
   /**  */
-  label: string
-}
+  createdAt: Date
 
-export interface PaperApplicationUpdate {
   /**  */
-  language: Language
+  updatedAt: Date
 
   /**  */
-  id?: string
+  phoneNumber?: string
 
   /**  */
-  file?: CombinedFileTypes
+  agreedToTermsOfService: boolean
 }
 
-export interface ApplicationMethodUpdate {
+export interface AmiChartItem {
   /**  */
-  type: ApplicationMethodType
+  percentOfAmi: number
 
   /**  */
-  id?: string
+  householdSize: number
 
   /**  */
-  paperApplications?: PaperApplicationUpdate[]
+  income: number
+}
 
+export interface AmiChart {
   /**  */
-  label?: string
+  id: string
 
   /**  */
-  externalReference?: string
+  createdAt: Date
 
   /**  */
-  acceptsPostmarkedApplications?: boolean
+  updatedAt: Date
 
   /**  */
-  phoneNumber?: string
+  items: AmiChartItem[]
 
   /**  */
-  listing: Id
+  name: string
+
+  /**  */
+  jurisdiction: Id
 }
 
-export interface BooleanInput {
+export interface AmiChartCreate {
   /**  */
-  type: InputType
+  items: AmiChartItem[]
 
   /**  */
-  key: string
+  name: string
 
   /**  */
-  value: boolean
+  jurisdiction: Id
 }
 
-export interface TextInput {
+export interface AmiChartUpdate {
   /**  */
-  type: InputType
+  items: AmiChartItem[]
 
   /**  */
-  key: string
+  name: string
 
   /**  */
-  value: string
-}
+  jurisdiction: Id
 
-export interface AddressCreate {
   /**  */
-  placeName?: string
+  id?: string
+}
 
+export interface ApplicationFlaggedSetMeta {
   /**  */
-  city: string
+  totalCount?: number
 
   /**  */
-  county?: string
+  totalResolvedCount?: number
 
   /**  */
-  state: string
+  totalPendingCount?: number
 
   /**  */
-  street: string
+  totalNamePendingCount?: number
 
   /**  */
-  street2?: string
+  totalEmailPendingCount?: number
+}
 
+export interface Address {
   /**  */
-  zipCode: string
+  id: string
 
   /**  */
-  latitude?: number
+  createdAt: Date
 
   /**  */
-  longitude?: number
-}
+  updatedAt: Date
 
-export interface AddressInput {
   /**  */
-  type: InputType
+  placeName?: string
 
   /**  */
-  key: string
+  city: string
 
   /**  */
-  value: AddressCreate
-}
+  county?: string
 
-export interface ApplicationsApiExtraModel {
   /**  */
-  orderBy?: EnumApplicationsApiExtraModelOrderBy
+  state: string
 
   /**  */
-  order?: EnumApplicationsApiExtraModelOrder
-}
+  street: string
 
-export interface PaginationMeta {
   /**  */
-  currentPage: number
+  street2?: string
 
   /**  */
-  itemCount: number
+  zipCode: string
 
   /**  */
-  itemsPerPage: number
+  latitude?: number
 
   /**  */
-  totalItems: number
+  longitude?: number
+}
 
+export interface Applicant {
   /**  */
-  totalPages: number
-}
+  address: Address
 
-export interface PaginatedApplication {
   /**  */
-  items: Application[]
+  workAddress: Address
 
   /**  */
-  meta: PaginationMeta
-}
+  id: string
 
-export interface ApplicantCreate {
   /**  */
-  address: AddressCreate
+  createdAt: Date
 
   /**  */
-  workAddress: AddressCreate
+  updatedAt: Date
 
   /**  */
   firstName?: string
@@ -3182,9 +3142,18 @@ export interface ApplicantCreate {
   workInRegion?: string
 }
 
-export interface AlternateContactCreate {
+export interface AlternateContact {
   /**  */
-  mailingAddress: AddressCreate
+  mailingAddress: Address
+
+  /**  */
+  id: string
+
+  /**  */
+  createdAt: Date
+
+  /**  */
+  updatedAt: Date
 
   /**  */
   type?: string
@@ -3208,7 +3177,7 @@ export interface AlternateContactCreate {
   emailAddress?: string
 }
 
-export interface AccessibilityCreate {
+export interface Accessibility {
   /**  */
   mobility?: boolean
 
@@ -3217,9 +3186,27 @@ export interface AccessibilityCreate {
 
   /**  */
   hearing?: boolean
+
+  /**  */
+  id: string
+
+  /**  */
+  createdAt: Date
+
+  /**  */
+  updatedAt: Date
 }
 
-export interface DemographicsCreate {
+export interface Demographics {
+  /**  */
+  id: string
+
+  /**  */
+  createdAt: Date
+
+  /**  */
+  updatedAt: Date
+
   /**  */
   ethnicity?: string
 
@@ -3236,12 +3223,21 @@ export interface DemographicsCreate {
   race?: string[]
 }
 
-export interface HouseholdMemberCreate {
+export interface HouseholdMember {
   /**  */
-  address: AddressCreate
+  address: Address
 
   /**  */
-  workAddress: AddressCreate
+  workAddress: Address
+
+  /**  */
+  id: string
+
+  /**  */
+  createdAt: Date
+
+  /**  */
+  updatedAt: Date
 
   /**  */
   orderId?: number
@@ -3274,7 +3270,49 @@ export interface HouseholdMemberCreate {
   workInRegion?: string
 }
 
-export interface ApplicationCreate {
+export interface UnitType {
+  /**  */
+  id: string
+
+  /**  */
+  createdAt: Date
+
+  /**  */
+  updatedAt: Date
+
+  /**  */
+  name: string
+
+  /**  */
+  numBedrooms: number
+}
+
+export interface ApplicationMultiselectQuestionOption {
+  /**  */
+  key: string
+
+  /**  */
+  checked: boolean
+
+  /**  */
+  mapPinPosition?: string
+
+  /**  */
+  extraData?: AllExtraDataTypes[]
+}
+
+export interface ApplicationMultiselectQuestion {
+  /**  */
+  key: string
+
+  /**  */
+  claimed: boolean
+
+  /**  */
+  options: ApplicationMultiselectQuestionOption[]
+}
+
+export interface Application {
   /**  */
   incomePeriod?: IncomePeriod
 
@@ -3290,32 +3328,47 @@ export interface ApplicationCreate {
   /**  */
   reviewStatus?: ApplicationReviewStatus
 
+  /**  */
+  applicant: Applicant
+
   /**  */
   listing: Id
 
   /**  */
-  applicant: ApplicantCreate
+  user?: Id
 
   /**  */
-  mailingAddress: AddressCreate
+  mailingAddress: Address
 
   /**  */
-  alternateAddress: AddressCreate
+  alternateAddress: Address
 
   /**  */
-  alternateContact: AlternateContactCreate
+  alternateContact: AlternateContact
 
   /**  */
-  accessibility: AccessibilityCreate
+  accessibility: Accessibility
 
   /**  */
-  demographics: DemographicsCreate
+  demographics: Demographics
+
+  /**  */
+  householdMembers: HouseholdMember[]
+
+  /**  */
+  preferredUnit: UnitType[]
+
+  /**  */
+  id: string
+
+  /**  */
+  createdAt: Date
 
   /**  */
-  householdMembers: HouseholdMemberCreate[]
+  updatedAt: Date
 
   /**  */
-  preferredUnit: Id[]
+  deletedAt?: Date
 
   /**  */
   appUrl?: string
@@ -3364,886 +3417,886 @@ export interface ApplicationCreate {
 
   /**  */
   submissionDate?: Date
-}
 
-export interface AddressUpdate {
   /**  */
-  id?: string
+  markedAsDuplicate: boolean
 
   /**  */
-  createdAt?: Date
+  flagged?: boolean
 
   /**  */
-  updatedAt?: Date
+  confirmationCode: string
+}
 
+export interface ApplicationFlaggedSet {
   /**  */
-  placeName?: string
+  resolvingUser: Id
 
   /**  */
-  city: string
+  applications: Application[]
 
   /**  */
-  county?: string
+  listing: Id
 
   /**  */
-  state: string
+  id: string
 
   /**  */
-  street: string
+  createdAt: Date
 
   /**  */
-  street2?: string
+  updatedAt: Date
 
   /**  */
-  zipCode: string
+  rule: EnumApplicationFlaggedSetRule
 
   /**  */
-  latitude?: number
+  ruleKey: string
 
   /**  */
-  longitude?: number
-}
+  resolvedTime?: Date
 
-export interface ApplicantUpdate {
   /**  */
-  id?: string
+  listingId: string
 
   /**  */
-  createdAt?: Date
+  showConfirmationAlert: boolean
 
   /**  */
-  updatedAt?: Date
+  status: EnumApplicationFlaggedSetStatus
+}
 
+export interface ApplicationFlaggedSetPaginationMeta {
   /**  */
-  address: AddressUpdate
+  totalFlagged: number
 
   /**  */
-  workAddress: AddressUpdate
+  currentPage: number
 
   /**  */
-  firstName?: string
+  itemCount: number
 
   /**  */
-  middleName?: string
+  itemsPerPage: number
 
   /**  */
-  lastName?: string
+  totalItems: number
 
   /**  */
-  birthMonth?: string
+  totalPages: number
+}
 
+export interface PaginatedApplicationFlaggedSet {
   /**  */
-  birthDay?: string
+  items: ApplicationFlaggedSet[]
 
   /**  */
-  birthYear?: string
+  meta: ApplicationFlaggedSetPaginationMeta
+}
 
+export interface ApplicationFlaggedSetResolve {
   /**  */
-  emailAddress?: string
+  afsId: string
 
   /**  */
-  noEmail?: boolean
+  applications: Id[]
 
   /**  */
-  phoneNumber?: string
+  status: EnumApplicationFlaggedSetResolveStatus
+}
 
+export interface Asset {
   /**  */
-  phoneNumberType?: string
+  id: string
 
   /**  */
-  noPhone?: boolean
+  createdAt: Date
 
   /**  */
-  workInRegion?: string
-}
+  updatedAt: Date
 
-export interface AlternateContactUpdate {
   /**  */
-  id?: string
+  fileId: string
 
   /**  */
-  createdAt?: Date
+  label: string
+}
 
+export interface PaperApplication {
   /**  */
-  updatedAt?: Date
+  language: Language
 
   /**  */
-  mailingAddress: AddressUpdate
+  file?: CombinedFileTypes
 
   /**  */
-  type?: string
+  id: string
 
   /**  */
-  otherType?: string
+  createdAt: Date
 
   /**  */
-  firstName?: string
+  updatedAt: Date
+}
 
+export interface ApplicationMethod {
   /**  */
-  lastName?: string
+  type: ApplicationMethodType
 
   /**  */
-  agency?: string
+  paperApplications?: PaperApplication[]
 
   /**  */
-  phoneNumber?: string
+  listing: Id
 
   /**  */
-  emailAddress?: string
-}
+  id: string
 
-export interface AccessibilityUpdate {
   /**  */
-  id?: string
+  createdAt: Date
 
   /**  */
-  createdAt?: Date
+  updatedAt: Date
 
   /**  */
-  updatedAt?: Date
+  label?: string
 
   /**  */
-  mobility?: boolean
+  externalReference?: string
 
   /**  */
-  vision?: boolean
+  acceptsPostmarkedApplications?: boolean
 
   /**  */
-  hearing?: boolean
+  phoneNumber?: string
 }
 
-export interface DemographicsUpdate {
+export interface AssetCreate {
   /**  */
-  id?: string
+  fileId: string
 
   /**  */
-  createdAt?: Date
+  label: string
+}
 
+export interface PaperApplicationCreate {
   /**  */
-  updatedAt?: Date
+  language: Language
 
   /**  */
-  ethnicity?: string
+  file?: CombinedFileTypes
+}
 
+export interface ApplicationMethodCreate {
   /**  */
-  gender?: string
+  type: ApplicationMethodType
 
   /**  */
-  sexualOrientation?: string
+  paperApplications?: PaperApplicationCreate[]
 
   /**  */
-  howDidYouHear: string[]
+  label?: string
 
   /**  */
-  race?: string[]
-}
+  externalReference?: string
 
-export interface HouseholdMemberUpdate {
   /**  */
-  id?: string
+  acceptsPostmarkedApplications?: boolean
 
   /**  */
-  createdAt?: Date
+  phoneNumber?: string
 
   /**  */
-  updatedAt?: Date
+  listing: Id
+}
 
+export interface AssetUpdate {
   /**  */
-  address: AddressUpdate
+  id?: string
 
   /**  */
-  workAddress: AddressUpdate
+  fileId: string
 
   /**  */
-  orderId?: number
+  label: string
+}
 
+export interface PaperApplicationUpdate {
   /**  */
-  firstName?: string
+  language: Language
 
   /**  */
-  middleName?: string
+  id?: string
 
   /**  */
-  lastName?: string
+  file?: CombinedFileTypes
+}
 
+export interface ApplicationMethodUpdate {
   /**  */
-  birthMonth?: string
+  type: ApplicationMethodType
 
   /**  */
-  birthDay?: string
+  id?: string
 
   /**  */
-  birthYear?: string
+  paperApplications?: PaperApplicationUpdate[]
 
   /**  */
-  sameAddress?: string
+  label?: string
 
   /**  */
-  relationship?: string
+  externalReference?: string
 
   /**  */
-  workInRegion?: string
-}
+  acceptsPostmarkedApplications?: boolean
 
-export interface ApplicationUpdate {
   /**  */
-  incomePeriod?: IncomePeriod
+  phoneNumber?: string
 
   /**  */
-  status: ApplicationStatus
+  listing: Id
+}
 
+export interface BooleanInput {
   /**  */
-  language?: Language
+  type: InputType
 
   /**  */
-  submissionType: ApplicationSubmissionType
+  key: string
 
   /**  */
-  reviewStatus?: ApplicationReviewStatus
+  value: boolean
+}
 
+export interface TextInput {
   /**  */
-  id?: string
+  type: InputType
 
   /**  */
-  deletedAt?: Date
+  key: string
 
   /**  */
-  listing: Id
+  value: string
+}
 
+export interface AddressCreate {
   /**  */
-  applicant: ApplicantUpdate
+  placeName?: string
 
   /**  */
-  mailingAddress: AddressUpdate
+  city: string
 
   /**  */
-  alternateAddress: AddressUpdate
+  county?: string
 
   /**  */
-  alternateContact: AlternateContactUpdate
+  state: string
 
   /**  */
-  accessibility: AccessibilityUpdate
+  street: string
 
   /**  */
-  demographics: DemographicsUpdate
+  street2?: string
 
   /**  */
-  householdMembers: HouseholdMemberUpdate[]
+  zipCode: string
 
   /**  */
-  preferredUnit: Id[]
+  latitude?: number
 
   /**  */
-  appUrl?: string
+  longitude?: number
+}
 
+export interface AddressInput {
   /**  */
-  additionalPhone?: boolean
+  type: InputType
 
   /**  */
-  additionalPhoneNumber?: string
+  key: string
 
   /**  */
-  additionalPhoneNumberType?: string
+  value: AddressCreate
+}
 
+export interface ApplicationsApiExtraModel {
   /**  */
-  contactPreferences: string[]
+  orderBy?: EnumApplicationsApiExtraModelOrderBy
 
   /**  */
-  householdSize?: number
+  order?: EnumApplicationsApiExtraModelOrder
+}
 
+export interface PaginatedApplication {
   /**  */
-  housingStatus?: string
+  items: Application[]
 
   /**  */
-  sendMailToMailingAddress?: boolean
+  meta: PaginationMeta
+}
 
+export interface ApplicantCreate {
   /**  */
-  householdExpectingChanges?: boolean
+  address: AddressCreate
 
   /**  */
-  householdStudent?: boolean
+  workAddress: AddressCreate
 
   /**  */
-  incomeVouchers?: boolean
+  firstName?: string
 
   /**  */
-  income?: string
+  middleName?: string
 
   /**  */
-  preferences: ApplicationMultiselectQuestion[]
+  lastName?: string
 
   /**  */
-  programs?: ApplicationMultiselectQuestion[]
+  birthMonth?: string
 
   /**  */
-  acceptedTerms?: boolean
+  birthDay?: string
 
   /**  */
-  submissionDate?: Date
-}
+  birthYear?: string
 
-export interface CreatePresignedUploadMetadata {
   /**  */
-  parametersToSign: object
-}
+  emailAddress?: string
 
-export interface CreatePresignedUploadMetadataResponse {
   /**  */
-  signature: string
-}
+  noEmail?: boolean
 
-export interface PaginatedAssets {
   /**  */
-  items: Asset[]
+  phoneNumber?: string
 
   /**  */
-  meta: PaginationMeta
-}
+  phoneNumberType?: string
 
-export interface UserErrorExtraModel {
   /**  */
-  userErrorMessages: EnumUserErrorExtraModelUserErrorMessages
-}
+  noPhone?: boolean
 
-export interface Login {
   /**  */
-  email: string
+  workInRegion?: string
+}
 
+export interface AlternateContactCreate {
   /**  */
-  password: string
+  mailingAddress: AddressCreate
 
   /**  */
-  mfaCode?: string
+  type?: string
 
   /**  */
-  mfaType?: EnumLoginMfaType
-}
+  otherType?: string
 
-export interface LogoutResponse {
   /**  */
-  success: boolean
-}
+  firstName?: string
 
-export interface RequestMfaCode {
   /**  */
-  email: string
+  lastName?: string
 
   /**  */
-  password: string
+  agency?: string
 
   /**  */
-  mfaType: EnumRequestMfaCodeMfaType
+  phoneNumber?: string
 
   /**  */
-  phoneNumber?: string
+  emailAddress?: string
 }
 
-export interface RequestMfaCodeResponse {
+export interface AccessibilityCreate {
   /**  */
-  phoneNumber?: string
+  mobility?: boolean
 
   /**  */
-  email?: string
+  vision?: boolean
 
   /**  */
-  phoneNumberVerified?: boolean
+  hearing?: boolean
 }
 
-export interface GetMfaInfo {
+export interface DemographicsCreate {
   /**  */
-  email: string
+  ethnicity?: string
 
   /**  */
-  password: string
-}
+  gender?: string
 
-export interface GetMfaInfoResponse {
   /**  */
-  phoneNumber?: string
+  sexualOrientation?: string
 
   /**  */
-  email?: string
+  howDidYouHear: string[]
 
   /**  */
-  isMfaEnabled: boolean
+  race?: string[]
+}
 
+export interface HouseholdMemberCreate {
   /**  */
-  mfaUsedInThePast: boolean
-}
+  address: AddressCreate
 
-export interface IdName {
   /**  */
-  id: string
+  workAddress: AddressCreate
 
   /**  */
-  name: string
-}
+  orderId?: number
 
-export interface UserRoles {
   /**  */
-  user: Id
+  firstName?: string
 
   /**  */
-  userId: string
+  middleName?: string
 
   /**  */
-  isAdmin?: boolean
+  lastName?: string
 
   /**  */
-  isJurisdictionalAdmin?: boolean
+  birthMonth?: string
 
   /**  */
-  isPartner?: boolean
-}
+  birthDay?: string
 
-export interface Jurisdiction {
   /**  */
-  multiselectQuestions: Id[]
+  birthYear?: string
 
   /**  */
-  id: string
+  sameAddress?: string
 
   /**  */
-  createdAt: Date
+  relationship?: string
 
   /**  */
-  updatedAt: Date
+  workInRegion?: string
+}
 
+export interface ApplicationCreate {
   /**  */
-  name: string
+  incomePeriod?: IncomePeriod
 
   /**  */
-  notificationsSignUpURL?: string
+  status: ApplicationStatus
 
   /**  */
-  languages: EnumJurisdictionLanguages[]
+  language?: Language
 
   /**  */
-  listingApprovalPermissions?: EnumJurisdictionListingApprovalPermissions[]
+  submissionType: ApplicationSubmissionType
 
   /**  */
-  partnerTerms?: string
+  reviewStatus?: ApplicationReviewStatus
 
   /**  */
-  publicUrl: string
+  listing: Id
 
   /**  */
-  emailFromAddress: string
+  applicant: ApplicantCreate
 
   /**  */
-  rentalAssistanceDefault: string
+  mailingAddress: AddressCreate
 
   /**  */
-  enablePartnerSettings?: boolean
+  alternateAddress: AddressCreate
 
   /**  */
-  enableAccessibilityFeatures: boolean
+  alternateContact: AlternateContactCreate
 
   /**  */
-  enableUtilitiesIncluded: boolean
+  accessibility: AccessibilityCreate
 
   /**  */
-  enableGeocodingPreferences: boolean
-}
+  demographics: DemographicsCreate
 
-export interface User {
   /**  */
-  language?: Language
+  householdMembers: HouseholdMemberCreate[]
 
   /**  */
-  leasingAgentInListings?: IdName[]
+  preferredUnit: Id[]
 
   /**  */
-  roles?: CombinedRolesTypes
+  appUrl?: string
 
   /**  */
-  jurisdictions: Jurisdiction[]
+  additionalPhone?: boolean
 
   /**  */
-  id: string
+  additionalPhoneNumber?: string
 
   /**  */
-  passwordUpdatedAt: Date
+  additionalPhoneNumberType?: string
 
   /**  */
-  passwordValidForDays: number
+  contactPreferences: string[]
 
   /**  */
-  confirmedAt?: Date
+  householdSize?: number
 
   /**  */
-  email: string
+  housingStatus?: string
 
   /**  */
-  firstName: string
+  sendMailToMailingAddress?: boolean
 
   /**  */
-  middleName?: string
+  householdExpectingChanges?: boolean
 
   /**  */
-  lastName: string
+  householdStudent?: boolean
 
   /**  */
-  dob?: Date
+  incomeVouchers?: boolean
 
   /**  */
-  phoneNumber?: string
+  income?: string
 
   /**  */
-  createdAt: Date
+  preferences: ApplicationMultiselectQuestion[]
 
   /**  */
-  updatedAt: Date
+  programs?: ApplicationMultiselectQuestion[]
 
   /**  */
-  mfaEnabled?: boolean
+  acceptedTerms?: boolean
 
   /**  */
-  lastLoginAt?: Date
+  submissionDate?: Date
+}
 
+export interface AddressUpdate {
   /**  */
-  failedLoginAttemptsCount?: number
+  id?: string
 
   /**  */
-  phoneNumberVerified?: boolean
+  createdAt?: Date
 
   /**  */
-  agreedToTermsOfService: boolean
+  updatedAt?: Date
 
   /**  */
-  hitConfirmationURL?: Date
+  placeName?: string
 
   /**  */
-  activeAccessToken?: string
+  city: string
 
   /**  */
-  activeRefreshToken?: string
-}
+  county?: string
 
-export interface UserCreate {
   /**  */
-  language?: Language
+  state: string
 
   /**  */
-  password: string
+  street: string
 
   /**  */
-  passwordConfirmation: string
+  street2?: string
 
   /**  */
-  emailConfirmation: string
+  zipCode: string
 
   /**  */
-  appUrl?: string
+  latitude?: number
 
   /**  */
-  jurisdictions?: Id[]
+  longitude?: number
+}
 
+export interface ApplicantUpdate {
   /**  */
-  email: string
+  id?: string
 
   /**  */
-  confirmedAt?: Date
+  createdAt?: Date
 
   /**  */
-  firstName: string
+  updatedAt?: Date
 
   /**  */
-  middleName?: string
+  address: AddressUpdate
 
   /**  */
-  lastName: string
+  workAddress: AddressUpdate
 
   /**  */
-  dob?: Date
+  firstName?: string
 
   /**  */
-  phoneNumber?: string
+  middleName?: string
 
   /**  */
-  phoneNumberVerified?: boolean
+  lastName?: string
 
   /**  */
-  hitConfirmationURL?: Date
+  birthMonth?: string
 
   /**  */
-  activeAccessToken?: string
+  birthDay?: string
 
   /**  */
-  activeRefreshToken?: string
-}
+  birthYear?: string
 
-export interface UserBasic {
   /**  */
-  language?: Language
+  emailAddress?: string
 
   /**  */
-  roles: UserRoles
+  noEmail?: boolean
 
   /**  */
-  jurisdictions: Jurisdiction[]
+  phoneNumber?: string
 
   /**  */
-  leasingAgentInListings?: Id[]
+  phoneNumberType?: string
 
   /**  */
-  id: string
+  noPhone?: boolean
 
   /**  */
-  email: string
+  workInRegion?: string
+}
 
+export interface AlternateContactUpdate {
   /**  */
-  firstName: string
+  id?: string
 
   /**  */
-  middleName?: string
+  createdAt?: Date
 
   /**  */
-  lastName: string
+  updatedAt?: Date
 
   /**  */
-  phoneNumber?: string
-}
+  mailingAddress: AddressUpdate
 
-export interface Email {
   /**  */
-  email: string
+  type?: string
 
   /**  */
-  appUrl?: string
-}
+  otherType?: string
 
-export interface Confirm {
   /**  */
-  token: string
+  firstName?: string
 
   /**  */
-  password?: string
-}
+  lastName?: string
 
-export interface ForgotPassword {
   /**  */
-  email: string
+  agency?: string
 
   /**  */
-  appUrl?: string
-}
+  phoneNumber?: string
 
-export interface ForgotPasswordResponse {
   /**  */
-  message: string
+  emailAddress?: string
 }
 
-export interface UpdatePassword {
+export interface AccessibilityUpdate {
   /**  */
-  password: string
+  id?: string
 
   /**  */
-  passwordConfirmation: string
+  createdAt?: Date
 
   /**  */
-  token: string
-}
+  updatedAt?: Date
 
-export interface UserRolesOnly {
   /**  */
-  isAdmin?: boolean
+  mobility?: boolean
 
   /**  */
-  isJurisdictionalAdmin?: boolean
+  vision?: boolean
 
   /**  */
-  isPartner?: boolean
+  hearing?: boolean
 }
 
-export interface UserUpdate {
-  /**  */
-  language?: Language
-
+export interface DemographicsUpdate {
   /**  */
   id?: string
 
   /**  */
-  email?: string
+  createdAt?: Date
 
   /**  */
-  password?: string
+  updatedAt?: Date
 
   /**  */
-  currentPassword?: string
+  ethnicity?: string
 
   /**  */
-  leasingAgentInListings?: Id[]
+  gender?: string
 
   /**  */
-  newEmail?: string
+  sexualOrientation?: string
 
   /**  */
-  appUrl?: string
+  howDidYouHear: string[]
 
   /**  */
-  jurisdictions: Id[]
+  race?: string[]
+}
 
+export interface HouseholdMemberUpdate {
   /**  */
-  roles?: UserRolesOnly
+  id?: string
 
   /**  */
-  confirmedAt?: Date
+  createdAt?: Date
 
   /**  */
-  firstName: string
+  updatedAt?: Date
 
   /**  */
-  middleName?: string
+  address: AddressUpdate
 
   /**  */
-  lastName: string
+  workAddress: AddressUpdate
 
   /**  */
-  dob?: Date
+  orderId?: number
 
   /**  */
-  phoneNumber?: string
+  firstName?: string
 
   /**  */
-  phoneNumberVerified?: boolean
+  middleName?: string
 
   /**  */
-  agreedToTermsOfService: boolean
+  lastName?: string
 
   /**  */
-  hitConfirmationURL?: Date
+  birthMonth?: string
 
   /**  */
-  activeAccessToken?: string
+  birthDay?: string
 
   /**  */
-  activeRefreshToken?: string
-}
+  birthYear?: string
 
-export interface UserFilterParams {
   /**  */
-  $comparison: EnumUserFilterParamsComparison
+  sameAddress?: string
 
   /**  */
-  isPartner?: boolean
+  relationship?: string
 
   /**  */
-  isPortalUser?: boolean
+  workInRegion?: string
 }
 
-export interface PaginatedUserList {
+export interface ApplicationUpdate {
   /**  */
-  items: User[]
+  incomePeriod?: IncomePeriod
 
   /**  */
-  meta: PaginationMeta
-}
+  status: ApplicationStatus
 
-export interface UserRolesCreate {
   /**  */
-  isAdmin?: boolean
+  language?: Language
 
   /**  */
-  isJurisdictionalAdmin?: boolean
+  submissionType: ApplicationSubmissionType
 
   /**  */
-  isPartner?: boolean
-}
+  reviewStatus?: ApplicationReviewStatus
 
-export interface UserInvite {
   /**  */
-  language?: Language
+  id?: string
 
   /**  */
-  jurisdictions: Id[]
+  deletedAt?: Date
 
   /**  */
-  leasingAgentInListings?: Id[]
+  listing: Id
 
   /**  */
-  roles?: UserRolesCreate
+  applicant: ApplicantUpdate
 
   /**  */
-  confirmedAt?: Date
+  mailingAddress: AddressUpdate
 
   /**  */
-  email: string
+  alternateAddress: AddressUpdate
 
   /**  */
-  firstName: string
+  alternateContact: AlternateContactUpdate
 
   /**  */
-  middleName?: string
+  accessibility: AccessibilityUpdate
 
   /**  */
-  lastName: string
+  demographics: DemographicsUpdate
 
   /**  */
-  dob?: Date
+  householdMembers: HouseholdMemberUpdate[]
 
   /**  */
-  phoneNumber?: string
+  preferredUnit: Id[]
 
   /**  */
-  phoneNumberVerified?: boolean
+  appUrl?: string
 
   /**  */
-  hitConfirmationURL?: Date
+  additionalPhone?: boolean
 
   /**  */
-  activeAccessToken?: string
+  additionalPhoneNumber?: string
 
   /**  */
-  activeRefreshToken?: string
-}
+  additionalPhoneNumberType?: string
 
-export interface UserProfileUpdate {
   /**  */
-  language?: Language
+  contactPreferences: string[]
 
   /**  */
-  password?: string
+  householdSize?: number
 
   /**  */
-  currentPassword?: string
+  housingStatus?: string
 
   /**  */
-  jurisdictions: Id[]
+  sendMailToMailingAddress?: boolean
 
   /**  */
-  newEmail?: string
+  householdExpectingChanges?: boolean
 
   /**  */
-  appUrl?: string
+  householdStudent?: boolean
 
   /**  */
-  id: string
+  incomeVouchers?: boolean
 
   /**  */
-  firstName: string
+  income?: string
 
   /**  */
-  middleName?: string
+  preferences: ApplicationMultiselectQuestion[]
 
   /**  */
-  lastName: string
+  programs?: ApplicationMultiselectQuestion[]
 
   /**  */
-  dob?: Date
+  acceptedTerms?: boolean
 
   /**  */
-  createdAt: Date
+  submissionDate?: Date
+}
 
+export interface CreatePresignedUploadMetadata {
   /**  */
-  updatedAt: Date
+  parametersToSign: object
+}
 
+export interface CreatePresignedUploadMetadataResponse {
   /**  */
-  phoneNumber?: string
+  signature: string
+}
 
+export interface PaginatedAssets {
   /**  */
-  agreedToTermsOfService: boolean
+  items: Asset[]
+
+  /**  */
+  meta: PaginationMeta
 }
 
 export interface JurisdictionCreate {
@@ -6229,7 +6282,52 @@ export interface MapLayer {
   /**  */
   jurisdictionId: string
 }
-
+export enum EnumUserErrorExtraModelUserErrorMessages {
+  "accountConfirmed" = "accountConfirmed",
+  "accountNotConfirmed" = "accountNotConfirmed",
+  "errorSaving" = "errorSaving",
+  "emailNotFound" = "emailNotFound",
+  "tokenExpired" = "tokenExpired",
+  "tokenMissing" = "tokenMissing",
+  "emailInUse" = "emailInUse",
+  "passwordOutdated" = "passwordOutdated",
+}
+export enum EnumLoginMfaType {
+  "sms" = "sms",
+  "email" = "email",
+}
+export enum EnumRequestMfaCodeMfaType {
+  "sms" = "sms",
+  "email" = "email",
+}
+export enum Language {
+  "en" = "en",
+  "es" = "es",
+  "vi" = "vi",
+  "zh" = "zh",
+  "tl" = "tl",
+}
+export enum EnumJurisdictionLanguages {
+  "en" = "en",
+  "es" = "es",
+  "vi" = "vi",
+  "zh" = "zh",
+  "tl" = "tl",
+}
+export enum EnumJurisdictionListingApprovalPermissions {
+  "user" = "user",
+  "partner" = "partner",
+  "admin" = "admin",
+  "jurisdictionAdmin" = "jurisdictionAdmin",
+}
+export type CombinedRolesTypes = UserRoles
+export enum EnumUserFilterParamsComparison {
+  "=" = "=",
+  "<>" = "<>",
+  "IN" = "IN",
+  ">=" = ">=",
+  "NA" = "NA",
+}
 export enum IncomePeriod {
   "perMonth" = "perMonth",
   "perYear" = "perYear",
@@ -6241,14 +6339,6 @@ export enum ApplicationStatus {
   "removed" = "removed",
 }
 
-export enum Language {
-  "en" = "en",
-  "es" = "es",
-  "vi" = "vi",
-  "zh" = "zh",
-  "tl" = "tl",
-}
-
 export enum ApplicationSubmissionType {
   "paper" = "paper",
   "electronical" = "electronical",
@@ -6301,45 +6391,6 @@ export enum EnumApplicationsApiExtraModelOrder {
   "ASC" = "ASC",
   "DESC" = "DESC",
 }
-export enum EnumUserErrorExtraModelUserErrorMessages {
-  "accountConfirmed" = "accountConfirmed",
-  "accountNotConfirmed" = "accountNotConfirmed",
-  "errorSaving" = "errorSaving",
-  "emailNotFound" = "emailNotFound",
-  "tokenExpired" = "tokenExpired",
-  "tokenMissing" = "tokenMissing",
-  "emailInUse" = "emailInUse",
-  "passwordOutdated" = "passwordOutdated",
-}
-export enum EnumLoginMfaType {
-  "sms" = "sms",
-  "email" = "email",
-}
-export enum EnumRequestMfaCodeMfaType {
-  "sms" = "sms",
-  "email" = "email",
-}
-export enum EnumJurisdictionLanguages {
-  "en" = "en",
-  "es" = "es",
-  "vi" = "vi",
-  "zh" = "zh",
-  "tl" = "tl",
-}
-export enum EnumJurisdictionListingApprovalPermissions {
-  "user" = "user",
-  "partner" = "partner",
-  "admin" = "admin",
-  "jurisdictionAdmin" = "jurisdictionAdmin",
-}
-export type CombinedRolesTypes = UserRoles
-export enum EnumUserFilterParamsComparison {
-  "=" = "=",
-  "<>" = "<>",
-  "IN" = "IN",
-  ">=" = ">=",
-  "NA" = "NA",
-}
 export enum EnumJurisdictionCreateLanguages {
   "en" = "en",
   "es" = "es",