Refactor frontend data models

src-ui/src/app/services/rest/consumption-template.service.spec.ts

@@ -6,13 +6,13 @@ import { commonAbstractPaperlessServiceTests } from './abstract-paperless-servic
 import { ConsumptionTemplateService } from './consumption-template.service'
 import {
   DocumentSource,
-  PaperlessConsumptionTemplate,
-} from 'src/app/data/paperless-consumption-template'
+  ConsumptionTemplate,
+} from 'src/app/data/consumption-template'
 
 let httpTestingController: HttpTestingController
 let service: ConsumptionTemplateService
 const endpoint = 'consumption_templates'
-const templates: PaperlessConsumptionTemplate[] = [
+const templates: ConsumptionTemplate[] = [
   {
     name: 'Template 1',
     id: 1,

src-ui/src/app/services/rest/consumption-template.service.ts

@@ -1,13 +1,13 @@
 import { HttpClient } from '@angular/common/http'
 import { Injectable } from '@angular/core'
 import { tap } from 'rxjs'
-import { PaperlessConsumptionTemplate } from 'src/app/data/paperless-consumption-template'
+import { ConsumptionTemplate } from 'src/app/data/consumption-template'
 import { AbstractPaperlessService } from './abstract-paperless-service'
 
 @Injectable({
   providedIn: 'root',
 })
-export class ConsumptionTemplateService extends AbstractPaperlessService<PaperlessConsumptionTemplate> {
+export class ConsumptionTemplateService extends AbstractPaperlessService<ConsumptionTemplate> {
   loading: boolean
 
   constructor(http: HttpClient) {
@@ -22,21 +22,21 @@ export class ConsumptionTemplateService extends AbstractPaperlessService<Paperle
     })
   }
 
-  private templates: PaperlessConsumptionTemplate[] = []
+  private templates: ConsumptionTemplate[] = []
 
-  public get allTemplates(): PaperlessConsumptionTemplate[] {
+  public get allTemplates(): ConsumptionTemplate[] {
     return this.templates
   }
 
-  create(o: PaperlessConsumptionTemplate) {
+  create(o: ConsumptionTemplate) {
     return super.create(o).pipe(tap(() => this.reload()))
   }
 
-  update(o: PaperlessConsumptionTemplate) {
+  update(o: ConsumptionTemplate) {
     return super.update(o).pipe(tap(() => this.reload()))
   }
 
-  delete(o: PaperlessConsumptionTemplate) {
+  delete(o: ConsumptionTemplate) {
     return super.delete(o).pipe(tap(() => this.reload()))
   }
 }

src-ui/src/app/services/rest/correspondent.service.ts

@@ -1,12 +1,12 @@
 import { HttpClient } from '@angular/common/http'
 import { Injectable } from '@angular/core'
-import { PaperlessCorrespondent } from 'src/app/data/paperless-correspondent'
+import { Correspondent } from 'src/app/data/correspondent'
 import { AbstractNameFilterService } from './abstract-name-filter-service'
 
 @Injectable({
   providedIn: 'root',
 })
-export class CorrespondentService extends AbstractNameFilterService<PaperlessCorrespondent> {
+export class CorrespondentService extends AbstractNameFilterService<Correspondent> {
   constructor(http: HttpClient) {
     super(http, 'correspondents')
   }

src-ui/src/app/services/rest/custom-fields.service.ts

@@ -2,13 +2,13 @@ import { Injectable } from '@angular/core'
 import { HttpClient, HttpParams } from '@angular/common/http'
 import { AbstractPaperlessService } from './abstract-paperless-service'
 import { Observable } from 'rxjs'
-import { PaperlessCustomField } from 'src/app/data/paperless-custom-field'
-import { PaperlessCustomFieldInstance } from 'src/app/data/paperless-custom-field-instance'
+import { CustomField } from 'src/app/data/custom-field'
+import { CustomFieldInstance } from 'src/app/data/custom-field-instance'
 
 @Injectable({
   providedIn: 'root',
 })
-export class CustomFieldsService extends AbstractPaperlessService<PaperlessCustomField> {
+export class CustomFieldsService extends AbstractPaperlessService<CustomField> {
   constructor(http: HttpClient) {
     super(http, 'custom_fields')
   }

src-ui/src/app/services/rest/document-notes.service.spec.ts

@@ -3,9 +3,6 @@ import { Subscription } from 'rxjs'
 import { TestBed } from '@angular/core/testing'
 import { environment } from 'src/environments/environment'
 import { commonAbstractPaperlessServiceTests } from './abstract-paperless-service.spec'
-import { MailFilterAttachmentType } from 'src/app/data/paperless-mail-rule'
-import { MailMetadataTitleOption } from 'src/app/data/paperless-mail-rule'
-import { MailAction } from 'src/app/data/paperless-mail-rule'
 import { DocumentNotesService } from './document-notes.service'
 
 let httpTestingController: HttpTestingController

src-ui/src/app/services/rest/document-notes.service.ts

@@ -1,35 +1,31 @@
 import { Injectable } from '@angular/core'
 import { HttpClient, HttpParams } from '@angular/common/http'
-import { PaperlessDocumentNote } from 'src/app/data/paperless-document-note'
+import { DocumentNote } from 'src/app/data/document-note'
 import { AbstractPaperlessService } from './abstract-paperless-service'
 import { Observable } from 'rxjs'
 
 @Injectable({
   providedIn: 'root',
 })
-export class DocumentNotesService extends AbstractPaperlessService<PaperlessDocumentNote> {
+export class DocumentNotesService extends AbstractPaperlessService<DocumentNote> {
   constructor(http: HttpClient) {
     super(http, 'documents')
   }
 
-  getNotes(documentId: number): Observable<PaperlessDocumentNote[]> {
-    return this.http.get<PaperlessDocumentNote[]>(
+  getNotes(documentId: number): Observable<DocumentNote[]> {
+    return this.http.get<DocumentNote[]>(
       this.getResourceUrl(documentId, 'notes')
     )
   }
 
-  addNote(id: number, note: string): Observable<PaperlessDocumentNote[]> {
-    return this.http.post<PaperlessDocumentNote[]>(
-      this.getResourceUrl(id, 'notes'),
-      { note: note }
-    )
+  addNote(id: number, note: string): Observable<DocumentNote[]> {
+    return this.http.post<DocumentNote[]>(this.getResourceUrl(id, 'notes'), {
+      note: note,
+    })
   }
 
-  deleteNote(
-    documentId: number,
-    noteId: number
-  ): Observable<PaperlessDocumentNote[]> {
-    return this.http.delete<PaperlessDocumentNote[]>(
+  deleteNote(documentId: number, noteId: number): Observable<DocumentNote[]> {
+    return this.http.delete<DocumentNote[]>(
       this.getResourceUrl(documentId, 'notes'),
       { params: new HttpParams({ fromString: `id=${noteId}` }) }
     )

src-ui/src/app/services/rest/document-type.service.ts

@@ -1,12 +1,12 @@
 import { HttpClient } from '@angular/common/http'
 import { Injectable } from '@angular/core'
-import { PaperlessDocumentType } from 'src/app/data/paperless-document-type'
+import { DocumentType } from 'src/app/data/document-type'
 import { AbstractNameFilterService } from './abstract-name-filter-service'
 
 @Injectable({
   providedIn: 'root',
 })
-export class DocumentTypeService extends AbstractNameFilterService<PaperlessDocumentType> {
+export class DocumentTypeService extends AbstractNameFilterService<DocumentType> {
   constructor(http: HttpClient) {
     super(http, 'document_types')
   }

src-ui/src/app/services/rest/document.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@angular/core'
-import { PaperlessDocument } from 'src/app/data/paperless-document'
-import { PaperlessDocumentMetadata } from 'src/app/data/paperless-document-metadata'
+import { Document } from 'src/app/data/document'
+import { DocumentMetadata } from 'src/app/data/document-metadata'
 import { AbstractPaperlessService } from './abstract-paperless-service'
 import { HttpClient, HttpParams } from '@angular/common/http'
 import { Observable } from 'rxjs'
@@ -10,7 +10,7 @@ import { map, tap } from 'rxjs/operators'
 import { CorrespondentService } from './correspondent.service'
 import { DocumentTypeService } from './document-type.service'
 import { TagService } from './tag.service'
-import { PaperlessDocumentSuggestions } from 'src/app/data/paperless-document-suggestions'
+import { DocumentSuggestions } from 'src/app/data/document-suggestions'
 import { queryParamsFromFilterRules } from '../../utils/query-params'
 import { StoragePathService } from './storage-path.service'
 
@@ -49,7 +49,7 @@ export interface SelectionData {
 @Injectable({
   providedIn: 'root',
 })
-export class DocumentService extends AbstractPaperlessService<PaperlessDocument> {
+export class DocumentService extends AbstractPaperlessService<Document> {
   private _searchQuery: string
 
   constructor(
@@ -62,7 +62,7 @@ export class DocumentService extends AbstractPaperlessService<PaperlessDocument>
     super(http, 'documents')
   }
 
-  addObservablesToDocument(doc: PaperlessDocument) {
+  addObservablesToDocument(doc: Document) {
     if (doc.correspondent) {
       doc.correspondent$ = this.correspondentService.getCached(
         doc.correspondent
@@ -93,7 +93,7 @@ export class DocumentService extends AbstractPaperlessService<PaperlessDocument>
     sortReverse?: boolean,
     filterRules?: FilterRule[],
     extraParams = {}
-  ): Observable<Results<PaperlessDocument>> {
+  ): Observable<Results<Document>> {
     return this.list(
       page,
       pageSize,
@@ -114,8 +114,8 @@ export class DocumentService extends AbstractPaperlessService<PaperlessDocument>
     }).pipe(map((response) => response.results.map((doc) => doc.id)))
   }
 
-  get(id: number): Observable<PaperlessDocument> {
-    return this.http.get<PaperlessDocument>(this.getResourceUrl(id), {
+  get(id: number): Observable<Document> {
+    return this.http.get<Document>(this.getResourceUrl(id), {
       params: {
         full_perms: true,
       },
@@ -147,7 +147,7 @@ export class DocumentService extends AbstractPaperlessService<PaperlessDocument>
     return this.http.get<number>(this.getResourceUrl(null, 'next_asn'))
   }
 
-  update(o: PaperlessDocument): Observable<PaperlessDocument> {
+  update(o: Document): Observable<Document> {
     // we want to only set created_date
     o.created = undefined
     return super.update(o)
@@ -161,10 +161,8 @@ export class DocumentService extends AbstractPaperlessService<PaperlessDocument>
     )
   }
 
-  getMetadata(id: number): Observable<PaperlessDocumentMetadata> {
-    return this.http.get<PaperlessDocumentMetadata>(
-      this.getResourceUrl(id, 'metadata')
-    )
+  getMetadata(id: number): Observable<DocumentMetadata> {
+    return this.http.get<DocumentMetadata>(this.getResourceUrl(id, 'metadata'))
   }
 
   bulkEdit(ids: number[], method: string, args: any) {
@@ -182,8 +180,8 @@ export class DocumentService extends AbstractPaperlessService<PaperlessDocument>
     )
   }
 
-  getSuggestions(id: number): Observable<PaperlessDocumentSuggestions> {
-    return this.http.get<PaperlessDocumentSuggestions>(
+  getSuggestions(id: number): Observable<DocumentSuggestions> {
+    return this.http.get<DocumentSuggestions>(
       this.getResourceUrl(id, 'suggestions')
     )
   }

src-ui/src/app/services/rest/group.service.ts

@@ -1,14 +1,14 @@
 import { HttpClient } from '@angular/common/http'
 import { Injectable } from '@angular/core'
 import { Observable, switchMap } from 'rxjs'
-import { PaperlessGroup } from 'src/app/data/paperless-group'
+import { Group } from 'src/app/data/group'
 import { PermissionsService } from '../permissions.service'
 import { AbstractNameFilterService } from './abstract-name-filter-service'
 
 @Injectable({
   providedIn: 'root',
 })
-export class GroupService extends AbstractNameFilterService<PaperlessGroup> {
+export class GroupService extends AbstractNameFilterService<Group> {
   constructor(
     http: HttpClient,
     private permissionService: PermissionsService
@@ -16,7 +16,7 @@ export class GroupService extends AbstractNameFilterService<PaperlessGroup> {
     super(http, 'groups')
   }
 
-  update(o: PaperlessGroup): Observable<PaperlessGroup> {
+  update(o: Group): Observable<Group> {
     return this.getCached(o.id).pipe(
       switchMap((initialGroup) => {
         initialGroup.permissions?.forEach((perm) => {

src-ui/src/app/services/rest/mail-account.service.spec.ts

@@ -4,7 +4,7 @@ import { TestBed } from '@angular/core/testing'
 import { environment } from 'src/environments/environment'
 import { commonAbstractPaperlessServiceTests } from './abstract-paperless-service.spec'
 import { MailAccountService } from './mail-account.service'
-import { IMAPSecurity } from 'src/app/data/paperless-mail-account'
+import { IMAPSecurity } from 'src/app/data/mail-account'
 
 let httpTestingController: HttpTestingController
 let service: MailAccountService

src-ui/src/app/services/rest/mail-account.service.ts

@@ -2,13 +2,13 @@ import { HttpClient } from '@angular/common/http'
 import { Injectable } from '@angular/core'
 import { combineLatest, Observable } from 'rxjs'
 import { tap } from 'rxjs/operators'
-import { PaperlessMailAccount } from 'src/app/data/paperless-mail-account'
+import { MailAccount } from 'src/app/data/mail-account'
 import { AbstractPaperlessService } from './abstract-paperless-service'
 
 @Injectable({
   providedIn: 'root',
 })
-export class MailAccountService extends AbstractPaperlessService<PaperlessMailAccount> {
+export class MailAccountService extends AbstractPaperlessService<MailAccount> {
   loading: boolean
 
   constructor(http: HttpClient) {
@@ -23,33 +23,31 @@ export class MailAccountService extends AbstractPaperlessService<PaperlessMailAc
     })
   }
 
-  private mailAccounts: PaperlessMailAccount[] = []
+  private mailAccounts: MailAccount[] = []
 
   get allAccounts() {
     return this.mailAccounts
   }
 
-  create(o: PaperlessMailAccount) {
+  create(o: MailAccount) {
     return super.create(o).pipe(tap(() => this.reload()))
   }
 
-  update(o: PaperlessMailAccount) {
+  update(o: MailAccount) {
     return super.update(o).pipe(tap(() => this.reload()))
   }
 
-  patchMany(
-    objects: PaperlessMailAccount[]
-  ): Observable<PaperlessMailAccount[]> {
+  patchMany(objects: MailAccount[]): Observable<MailAccount[]> {
     return combineLatest(objects.map((o) => super.patch(o))).pipe(
       tap(() => this.reload())
     )
   }
 
-  delete(o: PaperlessMailAccount) {
+  delete(o: MailAccount) {
     return super.delete(o).pipe(tap(() => this.reload()))
   }
 
-  test(o: PaperlessMailAccount) {
+  test(o: MailAccount) {
     const account = Object.assign({}, o)
     delete account['set_permissions']
     return this.http.post(this.getResourceUrl() + 'test/', account)

src-ui/src/app/services/rest/mail-rule.service.spec.ts

@@ -4,9 +4,9 @@ import { TestBed } from '@angular/core/testing'
 import { environment } from 'src/environments/environment'
 import { commonAbstractPaperlessServiceTests } from './abstract-paperless-service.spec'
 import { MailRuleService } from './mail-rule.service'
-import { MailFilterAttachmentType } from 'src/app/data/paperless-mail-rule'
-import { MailMetadataTitleOption } from 'src/app/data/paperless-mail-rule'
-import { MailAction } from 'src/app/data/paperless-mail-rule'
+import { MailFilterAttachmentType } from 'src/app/data/mail-rule'
+import { MailMetadataTitleOption } from 'src/app/data/mail-rule'
+import { MailAction } from 'src/app/data/mail-rule'
 
 let httpTestingController: HttpTestingController
 let service: MailRuleService

src-ui/src/app/services/rest/mail-rule.service.ts

@@ -2,13 +2,13 @@ import { HttpClient } from '@angular/common/http'
 import { Injectable } from '@angular/core'
 import { combineLatest, Observable } from 'rxjs'
 import { tap } from 'rxjs/operators'
-import { PaperlessMailRule } from 'src/app/data/paperless-mail-rule'
+import { MailRule } from 'src/app/data/mail-rule'
 import { AbstractPaperlessService } from './abstract-paperless-service'
 
 @Injectable({
   providedIn: 'root',
 })
-export class MailRuleService extends AbstractPaperlessService<PaperlessMailRule> {
+export class MailRuleService extends AbstractPaperlessService<MailRule> {
   loading: boolean
 
   constructor(http: HttpClient) {
@@ -23,27 +23,27 @@ export class MailRuleService extends AbstractPaperlessService<PaperlessMailRule>
     })
   }
 
-  private mailRules: PaperlessMailRule[] = []
+  private mailRules: MailRule[] = []
 
   get allRules() {
     return this.mailRules
   }
 
-  create(o: PaperlessMailRule) {
+  create(o: MailRule) {
     return super.create(o).pipe(tap(() => this.reload()))
   }
 
-  update(o: PaperlessMailRule) {
+  update(o: MailRule) {
     return super.update(o).pipe(tap(() => this.reload()))
   }
 
-  patchMany(objects: PaperlessMailRule[]): Observable<PaperlessMailRule[]> {
+  patchMany(objects: MailRule[]): Observable<MailRule[]> {
     return combineLatest(objects.map((o) => super.patch(o))).pipe(
       tap(() => this.reload())
     )
   }
 
-  delete(o: PaperlessMailRule) {
+  delete(o: MailRule) {
     return super.delete(o).pipe(tap(() => this.reload()))
   }
 }

src-ui/src/app/services/rest/saved-view.service.spec.ts

@@ -5,7 +5,7 @@ import { environment } from 'src/environments/environment'
 import { commonAbstractPaperlessServiceTests } from './abstract-paperless-service.spec'
 import { SavedViewService } from './saved-view.service'
 import { SettingsService } from '../settings.service'
-import { SETTINGS_KEYS } from 'src/app/data/paperless-uisettings'
+import { SETTINGS_KEYS } from 'src/app/data/ui-settings'
 
 let httpTestingController: HttpTestingController
 let service: SavedViewService

src-ui/src/app/services/rest/saved-view.service.ts

@@ -2,16 +2,16 @@ import { HttpClient } from '@angular/common/http'
 import { Injectable } from '@angular/core'
 import { combineLatest, Observable } from 'rxjs'
 import { tap } from 'rxjs/operators'
-import { PaperlessSavedView } from 'src/app/data/paperless-saved-view'
+import { SavedView } from 'src/app/data/saved-view'
 import { PermissionsService } from '../permissions.service'
 import { AbstractPaperlessService } from './abstract-paperless-service'
 import { SettingsService } from '../settings.service'
-import { SETTINGS_KEYS } from 'src/app/data/paperless-uisettings'
+import { SETTINGS_KEYS } from 'src/app/data/ui-settings'
 
 @Injectable({
   providedIn: 'root',
 })
-export class SavedViewService extends AbstractPaperlessService<PaperlessSavedView> {
+export class SavedViewService extends AbstractPaperlessService<SavedView> {
   loading: boolean
 
   constructor(
@@ -35,13 +35,13 @@ export class SavedViewService extends AbstractPaperlessService<PaperlessSavedVie
     })
   }
 
-  private savedViews: PaperlessSavedView[] = []
+  private savedViews: SavedView[] = []
 
   get allViews() {
     return this.savedViews
   }
 
-  get sidebarViews(): PaperlessSavedView[] {
+  get sidebarViews(): SavedView[] {
     const sidebarViews = this.savedViews.filter((v) => v.show_in_sidebar)
 
     const sorted: number[] = this.settingsService.get(
@@ -56,7 +56,7 @@ export class SavedViewService extends AbstractPaperlessService<PaperlessSavedVie
       : [...sidebarViews]
   }
 
-  get dashboardViews(): PaperlessSavedView[] {
+  get dashboardViews(): SavedView[] {
     const dashboardViews = this.savedViews.filter((v) => v.show_on_dashboard)
 
     const sorted: number[] = this.settingsService.get(
@@ -71,21 +71,21 @@ export class SavedViewService extends AbstractPaperlessService<PaperlessSavedVie
       : [...dashboardViews]
   }
 
-  create(o: PaperlessSavedView) {
+  create(o: SavedView) {
     return super.create(o).pipe(tap(() => this.reload()))
   }
 
-  update(o: PaperlessSavedView) {
+  update(o: SavedView) {
     return super.update(o).pipe(tap(() => this.reload()))
   }
 
-  patchMany(objects: PaperlessSavedView[]): Observable<PaperlessSavedView[]> {
+  patchMany(objects: SavedView[]): Observable<SavedView[]> {
     return combineLatest(objects.map((o) => super.patch(o))).pipe(
       tap(() => this.reload())
     )
   }
 
-  delete(o: PaperlessSavedView) {
+  delete(o: SavedView) {
     return super.delete(o).pipe(tap(() => this.reload()))
   }
 }

src-ui/src/app/services/rest/share-link.service.ts

@@ -1,8 +1,5 @@
 import { Injectable } from '@angular/core'
-import {
-  PaperlessShareLink,
-  PaperlessFileVersion,
-} from 'src/app/data/paperless-share-link'
+import { ShareLink, FileVersion } from 'src/app/data/share-link'
 import { AbstractNameFilterService } from './abstract-name-filter-service'
 import { HttpClient } from '@angular/common/http'
 import { Observable } from 'rxjs'
@@ -10,24 +7,24 @@ import { Observable } from 'rxjs'
 @Injectable({
   providedIn: 'root',
 })
-export class ShareLinkService extends AbstractNameFilterService<PaperlessShareLink> {
+export class ShareLinkService extends AbstractNameFilterService<ShareLink> {
   constructor(http: HttpClient) {
     super(http, 'share_links')
   }
 
-  getLinksForDocument(documentId: number): Observable<PaperlessShareLink[]> {
-    return this.http.get<PaperlessShareLink[]>(
+  getLinksForDocument(documentId: number): Observable<ShareLink[]> {
+    return this.http.get<ShareLink[]>(
       `${this.baseUrl}documents/${documentId}/${this.resourceName}/`
     )
   }
 
   createLinkForDocument(
     documentId: number,
-    file_version: PaperlessFileVersion = PaperlessFileVersion.Archive,
+    file_version: FileVersion = FileVersion.Archive,
     expiration: Date = null
   ) {
     this.clearCache()
-    return this.http.post<PaperlessShareLink>(this.getResourceUrl(), {
+    return this.http.post<ShareLink>(this.getResourceUrl(), {
       document: documentId,
       file_version,
       expiration: expiration?.toISOString(),

src-ui/src/app/services/rest/storage-path.service.ts

@@ -1,12 +1,12 @@
 import { HttpClient } from '@angular/common/http'
 import { Injectable } from '@angular/core'
-import { PaperlessStoragePath } from 'src/app/data/paperless-storage-path'
+import { StoragePath } from 'src/app/data/storage-path'
 import { AbstractNameFilterService } from './abstract-name-filter-service'
 
 @Injectable({
   providedIn: 'root',
 })
-export class StoragePathService extends AbstractNameFilterService<PaperlessStoragePath> {
+export class StoragePathService extends AbstractNameFilterService<StoragePath> {
   constructor(http: HttpClient) {
     super(http, 'storage_paths')
   }

src-ui/src/app/services/rest/tag.service.ts

@@ -1,12 +1,12 @@
 import { HttpClient } from '@angular/common/http'
 import { Injectable } from '@angular/core'
-import { PaperlessTag } from 'src/app/data/paperless-tag'
+import { Tag } from 'src/app/data/tag'
 import { AbstractNameFilterService } from './abstract-name-filter-service'
 
 @Injectable({
   providedIn: 'root',
 })
-export class TagService extends AbstractNameFilterService<PaperlessTag> {
+export class TagService extends AbstractNameFilterService<Tag> {
   constructor(http: HttpClient) {
     super(http, 'tags')
   }

src-ui/src/app/services/rest/user.service.ts

@@ -1,14 +1,14 @@
 import { HttpClient } from '@angular/common/http'
 import { Injectable } from '@angular/core'
 import { Observable, switchMap } from 'rxjs'
-import { PaperlessUser } from 'src/app/data/paperless-user'
+import { User } from 'src/app/data/user'
 import { PermissionsService } from '../permissions.service'
 import { AbstractNameFilterService } from './abstract-name-filter-service'
 
 @Injectable({
   providedIn: 'root',
 })
-export class UserService extends AbstractNameFilterService<PaperlessUser> {
+export class UserService extends AbstractNameFilterService<User> {
   constructor(
     http: HttpClient,
     private permissionService: PermissionsService
@@ -16,7 +16,7 @@ export class UserService extends AbstractNameFilterService<PaperlessUser> {
     super(http, 'users')
   }
 
-  update(o: PaperlessUser): Observable<PaperlessUser> {
+  update(o: User): Observable<User> {
     return this.getCached(o.id).pipe(
       switchMap((initialUser) => {
         initialUser.user_permissions?.forEach((perm) => {