@nauticana/sail 1.1.25 → 1.1.26

package/README.md

@@ -24,11 +24,12 @@ A shared Angular component library for building CRUD-based admin frontends. Prov
 | **Payout** | `PayoutProviderOnboardingComponent`, `PayoutBankInfoFormComponent` |
 | **Agency** | `AgencyClientsComponent`, `AgencyStatusBannerComponent`, `AgencyAcceptComponent`, `AgencyEarningsSummaryComponent`, `CommissionLedgerComponent`, `AgencyPayoutHistoryComponent`, `AgencyPayoutProfileComponent` |
 | **Notifications** | `NotificationCenterComponent`, `NotificationInboxService` |
+| **Documents** | `DocumentUploadComponent`, `PartnerDocumentsComponent`, `DocumentReviewQueueComponent`, `PartnerDocumentService` |
 | **Payments / SCA** | `UserPaymentMethodsComponent`, `ScaConfirmComponent`, `ScaConfirmer` (port), `SCA_CONFIRMER` (token) |
-| **Services** | `BaseAuthService` (OTP / social / push / deleteAccount / logoutEverywhere / profile: `getProfile`, `updateProfile`, `request`+`confirmEmailChange`, `request`+`confirmPhoneChange`), `BillingService`, `AgencyService`, `BackendService`, `PayoutService`, `UserPaymentMethodService`, `NotificationInboxService`, `loadScript()`, `authInterceptor`, `apiResponseInterceptor` |
+| **Services** | `BaseAuthService` (OTP / social / push / deleteAccount / logoutEverywhere / profile: `getProfile`, `updateProfile`, `request`+`confirmEmailChange`, `request`+`confirmPhoneChange`), `BillingService`, `AgencyService`, `BackendService`, `PayoutService`, `UserPaymentMethodService`, `PartnerDocumentService`, `NotificationInboxService`, `loadScript()`, `authInterceptor`, `apiResponseInterceptor` |
 | **Abstracts** | `BaseTable`, `BaseForm`, `BaseView`, `AbstractEditableView`, `BaseAsync`, `BaseRestService` |
 | **Config** | `SAIL_GUI_CONFIG`, `SailGuiConfig`, `configureRestUrls()` |
-| **Models** | `ApplicationData`, `TableDefinition`, `SiudAction`, `ApplicationMenu`, `ConstantValue`, `UserAccount`, `RestReport`, `ReportParam`, `TrustedDevice`, `PublicPlan`, `PlanPrice`, `PaymentMethod`, `Subscription`, `Invoice`, `CheckoutRequest`/`CheckoutResponse`, `PortalResponse`, `UsageMeter`, `ChargeResult`, `UserPaymentMethod`, `TableAction`, `TableActionParameter`, `ReusableAccount`, `PayoutOnboardingSession`, `BankInfoFormValue`, `CountryProfile`, `OtpRequest`/`OtpResponse`, `SignupConsent`, `ConsentState`, `ConsentOption`, `SocialProvider`, `PushPlatform`, `InboxMessage`/`InboxPage`, 2FA types, etc. |
+| **Models** | `ApplicationData`, `TableDefinition`, `SiudAction`, `ApplicationMenu`, `ConstantValue`, `UserAccount`, `RestReport`, `ReportParam`, `TrustedDevice`, `PublicPlan`, `PlanPrice`, `PaymentMethod`, `Subscription`, `Invoice`, `CheckoutRequest`/`CheckoutResponse`, `PortalResponse`, `UsageMeter`, `ChargeResult`, `UserPaymentMethod`, `TableAction`, `TableActionParameter`, `ReusableAccount`, `PayoutOnboardingSession`, `BankInfoFormValue`, `CountryProfile`, `OtpRequest`/`OtpResponse`, `SignupConsent`, `ConsentState`, `ConsentOption`, `SocialProvider`, `PushPlatform`, `InboxMessage`/`InboxPage`, `PartnerDocument`/`DocumentUploadRequest`, 2FA types, etc. |
 | **Decorators** | `@IsSailString()`, `@IsSailNumeric()` (class-validator based) |
 | **Utils** | `titleCase()`, `fromPriceLabel()`, `formatMinorCurrency()` |
 
@@ -269,7 +270,7 @@ this.labels.loadLabels('ride_type').subscribe(() => {
 });
 ```
 
-Concurrent loads share one application-data subscription, completed domains stay cached, and application-data failures can be retried. Missing values fall back to the raw key.
+Concurrent loads share one application-data subscription, completed domains stay cached, and application-data failures can be retried. `getLabel` falls back to the raw key; `requireLabel` throws instead, for values that must not render as a raw code. `options(domain)` returns every `{code, caption}` of a loaded domain, sorted by caption, for picklists.
 
 ## Status-filtered API errors
 
@@ -400,7 +401,7 @@ Every keel login response (keel v1.2.57+) carries `refreshToken` beside `token`;
 
 ### Realtime
 
-`RealtimeService` (root-provided) is the client for keel's `realtime.Hub`. `connect()` opens `RestURL.realtimeURL` (`/public/ws`) on the configured backend host with the stored JWT, reconnects with backoff, and re-subscribes every channel after a reconnect. `channel<T>(name)` returns the payloads keel broadcasts on that channel; `userFrames<T>()` returns payloads addressed to the user; `send(frame)` forwards an application frame to the hub's `OnMessage`. A subscription keel's `CanSubscribe` rejects is logged and exposed on `lastError`. Channel names and payload shapes are app-owned.
+`RealtimeService` (root-provided) is the client for keel's `realtime.Hub`. `connect()` opens `RestURL.realtimeURL` (`/public/ws`) on the configured backend host with the stored JWT, reconnects with backoff, and re-subscribes every channel after a reconnect. `channel<T>(name)` returns the payloads keel broadcasts on that channel; `userFrames<T>()` returns payloads addressed to the user, including keel's `{op: "notification"}` frames; `send(frame)` forwards an application frame to the hub's `OnMessage`. A subscription keel's `CanSubscribe` rejects is logged and exposed on `lastError`. Channel names and payload shapes are app-owned.
 
 ## Billing
 
@@ -570,7 +571,7 @@ A `TableAction` with `kind: 'R'` (redirect — the `constant_value` code) makes
 
 ### Action parameters (v1.1.25)
 
-An action with `parameters` (keel v1.2.75 `table_action_parameter`) opens a dialog before posting: one field per parameter, typed by `dataType` (`boolean` checkbox, numeric, `date`, `timestamp`, otherwise text), or a dropdown when `lookupTable` names a table in the client cache (a `foreign_key_lookup` dropdown table); a numeric `dataType` still posts the chosen key as a number. The dialog shows `confirmMessage` in place of the native prompt and posts `{...primaryKeyValues(record), ...values}`; empty optional values are left out. An action without parameters behaves as before.
+An action with `parameters` (keel v1.2.75 `table_action_parameter`) opens a dialog before posting: one field per parameter, typed by `dataType` (`boolean` checkbox, numeric, `date`, `timestamp`, `file`, otherwise text), or a dropdown when `lookupTable` names a table in the client cache (a `foreign_key_lookup` dropdown table); a numeric `dataType` still posts the chosen key as a number. The dialog shows `confirmMessage` in place of the native prompt and posts `{...primaryKeyValues(record), ...values}`; empty optional values are left out. A `file` parameter turns the post into `multipart/form-data`, so a table-level `upload` action whose parameters are `file`, `document_type` (lookup `document_type`), `title`, … posts straight to keel's `DocumentHandler.Upload`. An action without parameters behaves as before.
 
 ### Status chip (v1.0.1)
 
@@ -1080,8 +1081,10 @@ readonly unread = inject(NotificationInboxService).unreadCount;   // Signal<numb
 | `load(limit)` / `loadMore(limit)` | Default 20; keel caps a page at 100 and the client clamps to match. |
 
 Message ids are server-side `BIGINT`s serialized as strings. Both mark-read routes
-return `204`, so the service updates its cache locally. Call `load()` to pick up new
-messages and `reset()` on logout.
+return `204`, so the service updates its cache locally. After the first successful `load()`, each
+`{op: "notification"}` frame from keel's `realtime.UserDispatcher` (v1.2.79+) on a
+connected `RealtimeService` re-fetches the newest page into the cache. Call `reset()`
+on logout.
 
 ```html
 <sail-notification-center
@@ -1105,6 +1108,31 @@ Ships no CSS — style
 `.notification-item`, `.notification-item--unread` and
 `.notification-item__{select,static,title,body,time,read}`.
 
+## Partner documents (v1.1.26)
+
+`PartnerDocumentService` covers generic `partner_document` reads plus keel's
+`handler.DocumentHandler` (keel **v1.2.79+**): `list(userId?)`, `pending()`,
+`upload(file, request)` (progress events), `previewUrl(id)` and `review(id, approve,
+notes)`. The defaults assume the handler is mounted at
+`/api/v1/partner_document/{upload,preview,review}`; override the three
+`partnerDocument*URL` values otherwise. Authorization stays in keel's hooks.
+
+```html
+<sail-document-upload documentType="driver_license" [maxBytes]="10485760"
+    [canUpload]="attested()" (uploaded)="onUploaded($event)" (failed)="onFailed($event)">
+  <!-- app-specific attestations -->
+</sail-document-upload>
+```
+
+Images preview inline, PDFs open in a new tab. `(failed)` hands over the raw error;
+branch on `errorCode(err)` for keel's `document_*` codes. Status captions come from
+the `partner_document_status` domain through `LabelService`.
+
+`<sail-partner-documents>` shows the latest version per type and offers replacement
+uploads for rejected or expiring documents. `<sail-document-review-queue>` lists
+pending rows with an inline preview and approve/reject controls. Both rely on the
+app's generic `partner_document` read grants and the handler authorization hooks.
+
 ## Grouped review actions and diffs (v1.1.19)
 
 `GroupedBulkActionComponent` (`sail-grouped-bulk-action`) groups eligible rows
@@ -1481,8 +1509,8 @@ The v0.6 / v0.7 line introduced three additive feature groups against keel v0.7.
 | `@nauticana/sail` | `PayoutService` | keel/payout API client — onboarding, reuse, status, bank-version replacement, beneficiary registration |
 | `@nauticana/sail` | `PayoutProviderOnboardingComponent` (`<sail-payout-provider-onboarding>`) | Drop-in onboarding step with reuse picker, hosted-KYC handoff, and asynchronous-confirmation output |
 | `@nauticana/sail` | `PayoutBankInfoFormComponent` (`<sail-payout-bank-info-form>`) | Tax + payout details form (country / currency / tax ID / billing address / agreement) |
-| `@nauticana/sail` | `UserPaymentMethodService` | Saved-card list / delete / set-default API client |
-| `@nauticana/sail` | `UserPaymentMethodsComponent` (`<sail-user-payment-methods>`) | List of saved cards/wallets with set-default + delete |
+| `@nauticana/sail` | `UserPaymentMethodService` | Saved-card list / remove / set-default API client |
+| `@nauticana/sail` | `UserPaymentMethodsComponent` (`<sail-user-payment-methods>`) | List of saved cards/wallets with set-default + remove |
 | `@nauticana/sail` | `TableAction`, `ReusableAccount`, `PayoutOnboardingSession`, `BankInfoFormValue`, `CountryProfile`, `UserPaymentMethod`, `DEFAULT_COUNTRY_PROFILES` | Model types / defaults |
 
 ### 2. New keel endpoints
@@ -1497,10 +1525,11 @@ Make sure your keel deployment exposes these — they're all under `/api/v1/`:
 | `/api/v1/payout/status` | POST | `{ complete: true }` once the active partner's row has a `providerAccountId` |
 | `/api/v1/payout/bank/replace` | POST | Supersede the active bank-info version and insert its replacement atomically; the app must wire the handler's `SealTaxID` hook |
 | `/api/v1/payout/beneficiary/register` | POST | Create and link a provider beneficiary from provider-collected details |
-| `/api/v1/payment-methods/set-default` | POST | Atomic multi-row UPDATE — sets one row as default, clears the rest |
+| `/api/v1/user_payment_method/set_default` | POST | `{id}` — sets one row as default, clears the rest |
+| `/api/v1/user_payment_method/remove` | POST | `{id}` — detaches the method at the provider, then deletes the row (keel v1.2.79) |
 | `/api/v1/{table}/{action_name}` | POST | Per-table custom actions resolved from `basis.table_action` |
 
-`list` / `delete` for the `user_payment_method` table go through keel's generic REST CRUD (`/api/v1/user_payment_method/list|delete`) — `user_payment_method` is a UserSpecific basis table, so keel auto-scopes reads to the caller and owner-locks DELETE. No custom endpoint needed for those two.
+`list` for `user_payment_method` is keel's generic REST CRUD, auto-scoped to the caller. keel grants no generic DELETE on the table, so removal goes through `remove`.
 
 ### 3. Payout onboarding wiring
 
@@ -1539,7 +1568,7 @@ For apps that operate on a single keel partner, the reuse picker stays empty and
     [title]="'Payment Methods'"
     (addClicked)="goToSetupIntent()"
     (defaultChanged)="onDefaultChanged($event)"
-    (deleted)="onDeleted($event)">
+    (removed)="onRemoved($event)">
 </sail-user-payment-methods>
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nauticana/sail",
-  "version": "1.1.25",
+  "version": "1.1.26",
   "description": "Metadata-driven Angular component library for CRUD admin frontends backed by the keel Go backend. Tables, forms, navigation, OTP/2FA/social auth, billing, payout onboarding.",
   "main": "src/index.ts",
   "exports": {
@@ -52,6 +52,7 @@
     "@angular/core": "^21.0.0",
     "@angular/forms": "^21.0.0",
     "@angular/material": "^21.0.0",
+    "@angular/platform-browser": "^21.0.0",
     "@angular/router": "^21.0.0",
     "class-validator": "^0.15.1",
     "rxjs": "~7.8.0"

package/src/component/document/document_review_queue.html

@@ -0,0 +1,24 @@
+<section class="document-review-queue" [attr.aria-busy]="loading()">
+  @if (errorMessage()) { <p class="document-review-queue__error" role="alert">{{ errorMessage() }}</p> }
+  @if (!loading() && !documents().length) {
+    <p class="document-review-queue__empty">No documents are awaiting review.</p>
+  }
+  @for (doc of documents(); track doc.Id) {
+    <article class="document-review">
+      <h3>{{ doc.Title || doc.DocumentType }}</h3>
+      <p>{{ doc.FileName }} · version {{ doc.VersionNo }}</p>
+      <button matButton type="button" (click)="showPreview(doc)">Preview</button>
+      @if (preview()?.id === doc.Id) {
+        <iframe class="document-review__preview" [src]="preview()!.url" [title]="'Preview of ' + (doc.Title || doc.FileName)"></iframe>
+      }
+      <mat-form-field appearance="outline">
+        <mat-label>Review notes</mat-label>
+        <textarea matInput [value]="notes()[doc.Id]" (input)="setNotes(doc.Id, $event)"></textarea>
+      </mat-form-field>
+      <div class="document-review__actions">
+        <button matButton="filled" type="button" [disabled]="reviewing() === doc.Id" (click)="review(doc, true)">Approve</button>
+        <button matButton type="button" [disabled]="reviewing() === doc.Id" (click)="review(doc, false)">Reject</button>
+      </div>
+    </article>
+  }
+</section>

package/src/component/document/document_review_queue.ts

@@ -0,0 +1,67 @@
+import { ChangeDetectionStrategy, Component, OnInit, SecurityContext, ViewEncapsulation, inject, signal } from '@angular/core';
+import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
+import { MatButtonModule } from '@angular/material/button';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { BaseAsync } from '../abstract/base_async';
+import { PartnerDocument } from '../../model/document';
+import { PartnerDocumentService } from '../../service/partner_document.service';
+
+@Component({
+  selector: 'sail-document-review-queue',
+  templateUrl: './document_review_queue.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  encapsulation: ViewEncapsulation.None,
+  imports: [MatButtonModule, MatFormFieldModule, MatInputModule],
+})
+export class DocumentReviewQueueComponent extends BaseAsync implements OnInit {
+  private readonly service = inject(PartnerDocumentService);
+  private readonly sanitizer = inject(DomSanitizer);
+
+  readonly documents = signal<PartnerDocument[]>([]);
+  readonly preview = signal<{ id: number; url: SafeResourceUrl } | null>(null);
+  readonly reviewing = signal<number | null>(null);
+  readonly notes = signal<Record<number, string>>({});
+
+  ngOnInit(): void {
+    this.reload();
+  }
+
+  reload(): void {
+    this.run(this.service.pending(), (rows) => this.documents.set(rows), 'Could not load pending documents.');
+  }
+
+  showPreview(doc: PartnerDocument): void {
+    this.service.previewUrl(doc.Id).subscribe({
+      next: (url) => {
+        const safe = this.sanitizer.sanitize(SecurityContext.URL, url);
+        if (!safe) {
+          this.errorMessage.set('The document preview URL is invalid.');
+          return;
+        }
+        this.preview.set({ id: doc.Id, url: this.sanitizer.bypassSecurityTrustResourceUrl(safe) });
+      },
+      error: (err) => this.setError(err, 'Could not preview the document.'),
+    });
+  }
+
+  setNotes(id: number, event: Event): void {
+    const value = (event.target as HTMLTextAreaElement).value;
+    this.notes.update((notes) => ({ ...notes, [id]: value }));
+  }
+
+  review(doc: PartnerDocument, approve: boolean): void {
+    this.reviewing.set(doc.Id);
+    this.service.review(doc.Id, approve, this.notes()[doc.Id] ?? '').subscribe({
+      next: () => {
+        this.documents.update((rows) => rows.filter((row) => row.Id !== doc.Id));
+        if (this.preview()?.id === doc.Id) this.preview.set(null);
+        this.reviewing.set(null);
+      },
+      error: (err) => {
+        this.reviewing.set(null);
+        this.setError(err, 'Could not review the document.');
+      },
+    });
+  }
+}

package/src/component/document/document_upload.html

@@ -0,0 +1,31 @@
+<div class="document-upload">
+  @if (!file()) {
+    <button matButton="outlined" type="button" class="document-upload__pick" (click)="picker.click()">
+      <mat-icon>upload_file</mat-icon> {{ label() }}
+    </button>
+  } @else {
+    <div class="document-upload__preview">
+      @if (imageUrl(); as src) {
+        <img [src]="src" [alt]="file()!.name" class="document-upload__image">
+      } @else if (pdfUrl(); as src) {
+        <a [href]="src" target="_blank" rel="noopener" class="document-upload__pdf">Open preview</a>
+      }
+      <span class="document-upload__name">{{ file()!.name }}</span>
+    </div>
+
+    <ng-content />
+
+    <div class="document-upload__actions">
+      <button matButton="filled" type="button" (click)="upload()" [disabled]="!canUpload() || uploading()">Upload</button>
+      <button matButton="outlined" type="button" (click)="picker.click()" [disabled]="uploading()">Choose another</button>
+    </div>
+  }
+  <input #picker type="file" hidden [accept]="accept()" (change)="pick($event)" [attr.aria-label]="label()">
+
+  @if (progress() !== null) {
+    <mat-progress-bar mode="determinate" [value]="progress()" aria-label="Upload progress" />
+  }
+  @if (errorMessage()) {
+    <p class="document-upload__error" role="alert">{{ errorMessage() }}</p>
+  }
+</div>

package/src/component/document/document_upload.ts

@@ -0,0 +1,113 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ViewEncapsulation, computed, inject, input, output, signal } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { HttpEventType } from '@angular/common/http';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { PartnerDocumentService } from '../../service/partner_document.service';
+import { PartnerDocument } from '../../model/document';
+import { errorDetail } from '../../util/errors';
+
+/**
+ * Picks, previews and uploads one keel partner document. App-specific
+ * attestations are projected content; bind `[canUpload]` to their state.
+ * Ships no CSS — style the `.document-upload*` classes globally.
+ */
+@Component({
+  selector: 'sail-document-upload',
+  templateUrl: './document_upload.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  encapsulation: ViewEncapsulation.None,
+  imports: [MatButtonModule, MatIconModule, MatProgressBarModule],
+})
+export class DocumentUploadComponent {
+  private readonly documents = inject(PartnerDocumentService);
+  private readonly destroyRef = inject(DestroyRef);
+
+  readonly documentType = input.required<string>();
+  readonly title = input('');
+  readonly documentNumber = input('');
+  /** YYYY-MM-DD. */
+  readonly expiresOn = input('');
+  readonly userId = input<number | undefined>(undefined);
+  readonly accept = input('image/*,application/pdf');
+  /** Client-side size cap; 0 leaves the limit to keel's document type. */
+  readonly maxBytes = input(0);
+  readonly label = input('Choose file');
+  readonly canUpload = input(true);
+
+  readonly uploaded = output<PartnerDocument>();
+  /** The raw error; branch on `errorCode(err)` (keel's `document_*` codes). */
+  readonly failed = output<unknown>();
+
+  readonly file = signal<File | null>(null);
+  readonly progress = signal<number | null>(null);
+  readonly errorMessage = signal('');
+  private readonly objectUrl = signal<string | null>(null);
+
+  readonly isImage = computed(() => this.file()?.type.startsWith('image/') ?? false);
+  readonly imageUrl = computed(() => (this.isImage() ? this.objectUrl() : null));
+  readonly pdfUrl = computed(() => (this.file()?.type === 'application/pdf' ? this.objectUrl() : null));
+  readonly uploading = computed(() => this.progress() !== null);
+
+  constructor() {
+    this.destroyRef.onDestroy(() => this.revokePreview());
+  }
+
+  pick(event: Event): void {
+    const input = event.target as HTMLInputElement;
+    const file = input.files?.[0] ?? null;
+    input.value = '';
+    this.errorMessage.set('');
+    this.revokePreview();
+    this.file.set(null);
+    if (!file) return;
+    const max = this.maxBytes();
+    if (max > 0 && file.size > max) {
+      this.errorMessage.set(`The file exceeds the ${(max / 1048576).toFixed(1)} MB limit.`);
+      return;
+    }
+    this.file.set(file);
+    this.objectUrl.set(URL.createObjectURL(file));
+  }
+
+  upload(): void {
+    const file = this.file();
+    if (!file || !this.canUpload() || this.uploading()) return;
+    this.errorMessage.set('');
+    this.progress.set(0);
+    this.documents.upload(file, {
+      documentType: this.documentType(),
+      title: this.title() || undefined,
+      documentNumber: this.documentNumber() || undefined,
+      expiresOn: this.expiresOn() || undefined,
+      userId: this.userId(),
+    }).pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
+      next: (event) => {
+        if (event.type === HttpEventType.UploadProgress && event.total) {
+          this.progress.set(Math.round((100 * event.loaded) / event.total));
+        } else if (event.type === HttpEventType.Response && event.body) {
+          this.progress.set(null);
+          this.clear();
+          this.uploaded.emit(event.body);
+        }
+      },
+      error: (err) => {
+        this.progress.set(null);
+        this.errorMessage.set(errorDetail(err, 'Upload failed.'));
+        this.failed.emit(err);
+      },
+    });
+  }
+
+  clear(): void {
+    this.revokePreview();
+    this.file.set(null);
+  }
+
+  private revokePreview(): void {
+    const url = this.objectUrl();
+    if (url) URL.revokeObjectURL(url);
+    this.objectUrl.set(null);
+  }
+}

package/src/component/document/partner_documents.html

@@ -0,0 +1,33 @@
+<section class="partner-documents" [attr.aria-busy]="loading()">
+  @if (heading()) { <h2 class="partner-documents__title">{{ heading() }}</h2> }
+  @if (errorMessage()) { <p class="partner-documents__error" role="alert">{{ errorMessage() }}</p> }
+
+  @if (!loading() && !latest().length) {
+    <p class="partner-documents__empty">{{ emptyMessage() }}</p>
+  } @else {
+    <ul class="partner-documents__list">
+      @for (doc of latest(); track doc.Id) {
+        <li class="partner-document" [class.partner-document--rejected]="doc.Status === 'N'">
+          <div class="partner-document__details">
+            <strong>{{ doc.Title || doc.DocumentType }}</strong>
+            <span>{{ status(doc.Status) }} · version {{ doc.VersionNo }}</span>
+            @if (doc.ExpiresOn) { <span>Expires {{ doc.ExpiresOn | date }}</span> }
+            @if (doc.ReviewerNotes) { <span>{{ doc.ReviewerNotes }}</span> }
+          </div>
+          <div class="partner-document__actions">
+            <button matButton type="button" (click)="preview(doc)">
+              <mat-icon>visibility</mat-icon> Preview
+            </button>
+            @if (canReupload(doc)) {
+              <button matButton type="button" (click)="reuploading.set(doc)">Upload replacement</button>
+            }
+          </div>
+          @if (reuploading()?.Id === doc.Id) {
+            <sail-document-upload [documentType]="doc.DocumentType" [title]="doc.Title"
+                [documentNumber]="doc.DocumentNumber ?? ''" [userId]="doc.UserId ?? undefined" (uploaded)="uploaded()" />
+          }
+        </li>
+      }
+    </ul>
+  }
+</section>

package/src/component/document/partner_documents.ts

@@ -0,0 +1,92 @@
+import { ChangeDetectionStrategy, Component, OnInit, ViewEncapsulation, computed, inject, input, signal } from '@angular/core';
+import { DatePipe } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { forkJoin } from 'rxjs';
+import { BaseAsync } from '../abstract/base_async';
+import { PartnerDocument } from '../../model/document';
+import { LabelService } from '../../service/label.service';
+import { PartnerDocumentService } from '../../service/partner_document.service';
+import { DocumentUploadComponent } from './document_upload';
+
+@Component({
+  selector: 'sail-partner-documents',
+  templateUrl: './partner_documents.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  encapsulation: ViewEncapsulation.None,
+  imports: [DatePipe, MatButtonModule, MatIconModule, DocumentUploadComponent],
+})
+export class PartnerDocumentsComponent extends BaseAsync implements OnInit {
+  private readonly service = inject(PartnerDocumentService);
+  private readonly labels = inject(LabelService);
+
+  readonly userId = input<number | undefined>(undefined);
+  readonly heading = input('Documents');
+  readonly emptyMessage = input('No documents uploaded.');
+  readonly expiringWithinDays = input(30);
+
+  readonly documents = signal<PartnerDocument[]>([]);
+  readonly reuploading = signal<PartnerDocument | null>(null);
+  readonly statusesReady = signal(false);
+  readonly latest = computed(() => latestByType(this.documents()));
+
+  ngOnInit(): void {
+    this.run(forkJoin({
+      labels: this.labels.loadLabels('partner_document_status'),
+      documents: this.service.list(this.userId()),
+    }), ({ documents }) => {
+      this.statusesReady.set(true);
+      this.documents.set(documents);
+    }, 'Could not load documents.');
+  }
+
+  reload(): void {
+    this.run(this.service.list(this.userId()), (rows) => this.documents.set(rows), 'Could not load documents.');
+  }
+
+  status(status: string): string {
+    return this.statusesReady() ? this.labels.requireLabel('partner_document_status', status) : '';
+  }
+
+  canReupload(doc: PartnerDocument): boolean {
+    return doc.Status === 'N' || isExpiring(doc.ExpiresOn, this.expiringWithinDays());
+  }
+
+  preview(doc: PartnerDocument): void {
+    // Opened synchronously so the popup blocker allows it; 'noopener' would return null.
+    const tab = window.open('', '_blank');
+    if (tab) tab.opener = null;
+    this.service.previewUrl(doc.Id).subscribe({
+      next: (url) => {
+        if (tab) tab.location.href = url;
+        else window.open(url, '_blank', 'noopener');
+      },
+      error: (err) => {
+        tab?.close();
+        this.setError(err, 'Could not open the document.');
+      },
+    });
+  }
+
+  uploaded(): void {
+    this.reuploading.set(null);
+    this.reload();
+  }
+}
+
+function latestByType(rows: PartnerDocument[]): PartnerDocument[] {
+  const latest = new Map<string, PartnerDocument>();
+  for (const row of rows) {
+    const key = `${row.UserId ?? ''}:${row.DocumentType}`;
+    const current = latest.get(key);
+    if (!current || row.VersionNo > current.VersionNo) latest.set(key, row);
+  }
+  return [...latest.values()].sort((a, b) => a.DocumentType.localeCompare(b.DocumentType));
+}
+
+function isExpiring(value: string | null, withinDays: number): boolean {
+  if (!value || withinDays < 0) return false;
+  const expires = new Date(`${value.slice(0, 10)}T00:00:00`);
+  if (Number.isNaN(expires.getTime())) return false;
+  return expires.getTime() <= Date.now() + withinDays * 86400000;
+}

package/src/component/payment/user_payment_methods.html

@@ -31,7 +31,7 @@
             @if (!m.IsDefault) {
               <button matButton (click)="setDefault(m)">Set default</button>
             }
-            <button matIconButton (click)="remove(m)" aria-label="Delete payment method">
+            <button matIconButton (click)="remove(m)" aria-label="Remove payment method">
               <mat-icon>delete</mat-icon>
             </button>
           </div>

package/src/component/payment/user_payment_methods.ts

@@ -10,7 +10,7 @@ import { UserPaymentMethod } from '../../model/appdata';
  * End-user saved payment methods.
  *
  * Drop-in screen that lists the caller's cards/wallets, with set-default
- * + delete actions. Inherits loading/error state from BaseAsync.
+ * + remove actions. Inherits loading/error state from BaseAsync.
  *
  * Customise the heading and "add" CTA via inputs; emit (addClicked) so
  * the consumer routes to its own SetupIntent flow: BillingService.createSetupIntent()
@@ -37,8 +37,8 @@ export class UserPaymentMethodsComponent extends BaseAsync implements OnInit {
   readonly addClicked = output<void>();
   /** Emitted after a successful set-default flip. */
   readonly defaultChanged = output<UserPaymentMethod>();
-  /** Emitted after a successful delete. */
-  readonly deleted = output<UserPaymentMethod>();
+  /** Emitted after a method is detached and removed. */
+  readonly removed = output<UserPaymentMethod>();
 
   private readonly service = inject(UserPaymentMethodService);
 
@@ -78,12 +78,12 @@ export class UserPaymentMethodsComponent extends BaseAsync implements OnInit {
 
   remove(m: UserPaymentMethod): void {
     this.run(
-      this.service.delete(m.Id),
+      this.service.remove(m.Id),
       () => {
         this.methods.update((list) => list.filter((row) => row.Id !== m.Id));
-        this.deleted.emit(m);
+        this.removed.emit(m);
       },
-      'Failed to delete.',
+      'Failed to remove.',
     );
   }
 

package/src/component/table/action_params_dialog.html

@@ -9,6 +9,16 @@
                 @case ('checkbox') {
                     <mat-checkbox [formControlName]="f.param.name">{{ f.param.caption }}</mat-checkbox>
                 }
+                @case ('file') {
+                    <div class="action-param-file">
+                        <label [for]="'action-param-' + f.param.name">{{ f.param.caption }}@if (f.param.required) { * }</label>
+                        <input type="file" [id]="'action-param-' + f.param.name" [required]="f.param.required"
+                               (change)="pickFile(f.param.name, $event)">
+                        @if (form.controls[f.param.name].touched && form.controls[f.param.name].invalid) {
+                            <p class="action-param-error" role="alert">{{ f.param.caption }} is required</p>
+                        }
+                    </div>
+                }
                 @case ('select') {
                     <mat-form-field appearance="outline">
                         <mat-label>{{ f.param.caption }}</mat-label>

package/src/component/table/action_params_dialog.ts

@@ -10,7 +10,7 @@ import { TableAction, TableActionParameter } from "../../model/appdata";
 import { ConstantValue } from "../../model/common";
 import { BaseAuthService } from "../../service/auth.service";
 
-type ParamKind = 'checkbox' | 'number' | 'date' | 'datetime-local' | 'text';
+type ParamKind = 'checkbox' | 'number' | 'date' | 'datetime-local' | 'file' | 'text';
 
 interface ParamField {
     param:    TableActionParameter;
@@ -65,6 +65,12 @@ export class ActionParamsDialog {
         }
         this.dialogRef.close(values);
     }
+
+    pickFile(name: string, event: Event): void {
+        const control = this.form.controls[name];
+        control.setValue((event.target as HTMLInputElement).files?.[0] ?? '');
+        control.markAsTouched();
+    }
 }
 
 function kindOf(dataType: string): ParamKind {
@@ -83,6 +89,8 @@ function kindOf(dataType: string): ParamKind {
         case 'datetime':
         case 'timestamp':
             return 'datetime-local';
+        case 'file':
+            return 'file';
         default:
             return 'text';
     }

package/src/index.ts

@@ -5,6 +5,7 @@ export * from './model/common';
 export * from './model/dashboard';
 export * from './model/oauth_connection';
 export * from './model/notification';
+export * from './model/document';
 export * from './model/agency';
 export * from './model/decorator';
 export * from './component/abstract/base_table';
@@ -70,6 +71,9 @@ export * from './component/agency/agency_payout_history';
 export * from './component/agency/agency_payout_profile';
 export * from './component/payment/user_payment_methods';
 export * from './component/payment/sca_confirm';
+export * from './component/document/document_upload';
+export * from './component/document/partner_documents';
+export * from './component/document/document_review_queue';
 export * from './service/auth.service';
 export * from './service/sca_confirmer';
 export * from './service/domain_verifier';
@@ -79,6 +83,7 @@ export * from './service/agency.service';
 export * from './service/oauth_connection.service';
 export * from './service/notification_inbox.service';
 export * from './service/user_payment_method.service';
+export * from './service/partner_document.service';
 export * from './service/script_loader';
 export * from './service/auth.interceptor';
 export * from './service/realtime.service';

package/src/model/document.ts

@@ -0,0 +1,36 @@
+/** One `partner_document` row in Sail's generic REST field shape. */
+export interface PartnerDocument {
+  Id:             number;
+  ContrepId:      string;
+  DocKey:         string;
+  PartnerId:      number;
+  /** null means the partner itself. */
+  UserId:         number | null;
+  DocumentType:   string;
+  Title:          string;
+  FileName:       string;
+  VersionNo:      number;
+  DocumentNumber: string | null;
+  ExpiresOn:      string | null;
+  OriginIp:       string | null;
+  UploadedBy:     number | null;
+  UploadedAt:     string;
+  /** `partner_document_status`: P pending, Y approved, N rejected, X superseded, R retired. */
+  Status:         string;
+  ReviewerId:     number | null;
+  ReviewedAt:     string | null;
+  ReviewerNotes:  string | null;
+  SupersededAt:   string | null;
+  RetiredAt:      string | null;
+  PurgedAt:       string | null;
+}
+
+export interface DocumentUploadRequest {
+  documentType:    string;
+  title?:          string;
+  documentNumber?: string;
+  /** YYYY-MM-DD. */
+  expiresOn?:      string;
+  /** The member the document is about; omitted = the partner. */
+  userId?:         number;
+}

package/src/service/label.service.ts

@@ -2,6 +2,11 @@ import { inject, Injectable } from "@angular/core";
 import { Observable, map, of, shareReplay, take, tap } from "rxjs";
 import { BaseAuthService } from "./auth.service";
 
+export interface LabelOption {
+    code: string;
+    caption: string;
+}
+
 @Injectable({ providedIn: 'root' })
 export class LabelService {
     private readonly auth = inject(BaseAuthService);
@@ -13,6 +18,23 @@ export class LabelService {
         return this.labels.get(constantId)?.get(key) ?? key;
     }
 
+    /** Caption of a backend-sourced value; throws when the domain is not loaded or lacks the key. */
+    requireLabel(constantId: string, key: string): string {
+        const domain = this.labels.get(constantId);
+        if (!domain) throw new Error(`sail: constant domain "${constantId}" is not loaded.`);
+        const caption = domain.get(key);
+        if (caption === undefined) throw new Error(`sail: constant domain "${constantId}" has no value "${key}".`);
+        return caption;
+    }
+
+    /** Every value of a loaded domain, by caption (keel's ConstantCache carries no display order). */
+    options(constantId: string): LabelOption[] {
+        const domain = this.labels.get(constantId);
+        if (!domain) throw new Error(`sail: constant domain "${constantId}" is not loaded.`);
+        return [...domain].map(([code, caption]) => ({ code, caption }))
+            .sort((a, b) => a.caption.localeCompare(b.caption));
+    }
+
     /**
      * Load one backend-provided `constant_value` domain from ApplicationData.
      * Completed and concurrent requests are cached; a failed application-data

package/src/service/notification_inbox.service.ts

@@ -1,16 +1,24 @@
-import { Injectable, Signal, signal } from '@angular/core';
+import { Injectable, Signal, inject, signal } from '@angular/core';
 import { HttpParams } from '@angular/common/http';
-import { Observable, tap } from 'rxjs';
+import { EMPTY, Observable, Subscription, catchError, filter, switchMap, tap } from 'rxjs';
 import { BaseRestService } from './base_rest.service';
+import { RealtimeService } from './realtime.service';
 import { RestURL } from './rest_url';
 import { InboxMessage, InboxPage } from '../model/notification';
 
 export const INBOX_MAX_PAGE_SIZE = 100;
 export const INBOX_DEFAULT_PAGE_SIZE = 20;
 
-/** Stateful client for keel's `InboxHandler` (v1.2.71+). Call `reset()` on logout. */
+/**
+ * Stateful client for keel's `InboxHandler` (v1.2.71+). After `load()` it re-fetches
+ * the newest page on each realtime `notification` frame (keel `realtime.UserDispatcher`).
+ * Call `reset()` on logout.
+ */
 @Injectable({ providedIn: 'root' })
 export class NotificationInboxService extends BaseRestService {
+  private readonly realtime = inject(RealtimeService);
+  private live: Subscription | null = null;
+  private pageSize = INBOX_DEFAULT_PAGE_SIZE;
   private readonly cached = signal<InboxMessage[]>([]);
   private readonly unread = signal(0);
   private readonly older = signal(false);
@@ -20,17 +28,25 @@ export class NotificationInboxService extends BaseRestService {
   readonly hasMore: Signal<boolean> = this.older.asReadonly();
 
   load(limit = INBOX_DEFAULT_PAGE_SIZE): Observable<InboxPage> {
-    return this.fetch('', limit).pipe(tap((page) => this.cached.set(page.messages)));
+    this.pageSize = pageSizeOf(limit);
+    return this.fetch('', limit).pipe(tap((page) => {
+      this.cached.set(page.messages);
+      this.older.set(this.isFull(page, limit));
+      this.follow();
+    }));
   }
 
   loadMore(limit = INBOX_DEFAULT_PAGE_SIZE): Observable<InboxPage> {
     const loaded = this.cached();
     const oldest = loaded.length ? loaded[loaded.length - 1].id : '';
     return this.fetch(oldest, limit).pipe(
-      tap((page) => this.cached.update((rows) => {
-        const ids = new Set(rows.map((message) => message.id));
-        return rows.concat(page.messages.filter((message) => !ids.has(message.id)));
-      })),
+      tap((page) => {
+        this.older.set(this.isFull(page, limit));
+        this.cached.update((rows) => {
+          const ids = new Set(rows.map((message) => message.id));
+          return rows.concat(page.messages.filter((message) => !ids.has(message.id)));
+        });
+      }),
     );
   }
 
@@ -54,23 +70,46 @@ export class NotificationInboxService extends BaseRestService {
   }
 
   reset(): void {
+    this.live?.unsubscribe();
+    this.live = null;
     this.cached.set([]);
     this.unread.set(0);
     this.older.set(false);
   }
 
+  /** The frame carries no message id, so the newest page is re-fetched and merged over the cache head. */
+  private follow(): void {
+    if (this.live) return;
+    this.live = this.realtime.userFrames<{ op?: unknown }>().pipe(
+      filter((frame) => frame?.op === 'notification'),
+      switchMap(() => this.fetch('', this.pageSize).pipe(
+        catchError((err) => {
+          console.error('notification inbox: refresh after realtime frame failed', err);
+          return EMPTY;
+        }),
+      )),
+    ).subscribe((page) => {
+      const fresh = new Set(page.messages.map((message) => message.id));
+      this.cached.update((rows) => page.messages.concat(rows.filter((message) => !fresh.has(message.id))));
+    });
+  }
+
   private fetch(before: string, limit: number): Observable<InboxPage> {
-    const requested = Number.isFinite(limit) ? Math.trunc(limit) : INBOX_DEFAULT_PAGE_SIZE;
-    const size = Math.min(Math.max(1, requested), INBOX_MAX_PAGE_SIZE);
-    let params = new HttpParams().set('limit', size);
+    let params = new HttpParams().set('limit', pageSizeOf(limit));
     if (before) params = params.set('before', before);
     return this.http.get<InboxPage>(this.url(RestURL.notificationsURL), { params }).pipe(
-      tap((page) => {
-        this.unread.set(page.unreadCount);
-        this.older.set(page.messages.length >= size);
-      }),
+      tap((page) => this.unread.set(page.unreadCount)),
     );
   }
+
+  private isFull(page: InboxPage, limit: number): boolean {
+    return page.messages.length >= pageSizeOf(limit);
+  }
+}
+
+function pageSizeOf(limit: number): number {
+  const requested = Number.isFinite(limit) ? Math.trunc(limit) : INBOX_DEFAULT_PAGE_SIZE;
+  return Math.min(Math.max(1, requested), INBOX_MAX_PAGE_SIZE);
 }
 
 function nowIso(): string {

package/src/service/partner_document.service.ts

@@ -0,0 +1,111 @@
+import { inject, Injectable } from '@angular/core';
+import { HttpEvent, HttpEventType, HttpParams, HttpResponse } from '@angular/common/http';
+import { Observable, map } from 'rxjs';
+import { BaseRestService } from './base_rest.service';
+import { BackendService } from './rest_service';
+import { RestURL } from './rest_url';
+import { DocumentUploadRequest, PartnerDocument } from '../model/document';
+
+interface DocumentHandlerResponse {
+  ID: number;
+  ContRepID: string;
+  DocKey: string;
+  PartnerID: number;
+  UserID: number;
+  DocumentType: string;
+  Title: string;
+  FileName: string;
+  VersionNo: number;
+  DocumentNumber: string;
+  ExpiresOn: string;
+  OriginIP: string;
+  UploadedBy: number;
+  UploadedAt: string;
+  Status: string;
+  ReviewerID: number;
+  ReviewedAt: string;
+  ReviewerNotes: string;
+  SupersededAt: string;
+  RetiredAt: string;
+  PurgedAt: string;
+}
+
+/** Client for keel's `handler.DocumentHandler` and `partner_document` REST table. */
+@Injectable({ providedIn: 'root' })
+export class PartnerDocumentService extends BaseRestService {
+  private readonly backend = inject(BackendService);
+
+  list(userId?: number): Observable<PartnerDocument[]> {
+    const filter = userId === undefined ? undefined : { UserId: String(userId) };
+    return this.backend.list<PartnerDocument>('partner_document', filter);
+  }
+
+  pending(): Observable<PartnerDocument[]> {
+    return this.backend.list<PartnerDocument>('partner_document', { Status: 'P' });
+  }
+
+  /** Multipart upload with progress events; the final response carries the stored document. */
+  upload(file: File, request: DocumentUploadRequest): Observable<HttpEvent<PartnerDocument>> {
+    const form = new FormData();
+    form.append('file', file);
+    form.append('document_type', request.documentType);
+    if (request.title) form.append('title', request.title);
+    if (request.documentNumber) form.append('document_number', request.documentNumber);
+    if (request.expiresOn) form.append('expires_on', request.expiresOn);
+    if (request.userId) form.append('user_id', String(request.userId));
+    return this.http.post<DocumentHandlerResponse>(this.url(RestURL.partnerDocumentUploadURL), form, {
+      reportProgress: true,
+      observe: 'events',
+    }).pipe(map((event) => normalizeUploadEvent(event)));
+  }
+
+  /** Short-lived signed read URL. */
+  previewUrl(id: number): Observable<string> {
+    const params = new HttpParams().set('id', id);
+    return this.http.get<{ url: string }>(this.url(RestURL.partnerDocumentPreviewURL), { params })
+      .pipe(map((resp) => resp.url));
+  }
+
+  review(id: number, approve: boolean, notes = ''): Observable<void> {
+    // keel decodes the id with `json:"id,string"`.
+    return this.http.post<void>(this.url(RestURL.partnerDocumentReviewURL), { id: String(id), approve, notes });
+  }
+}
+
+function normalizeUploadEvent(event: HttpEvent<DocumentHandlerResponse>): HttpEvent<PartnerDocument> {
+  if (event.type !== HttpEventType.Response) return event;
+  return (event as HttpResponse<DocumentHandlerResponse>).clone({
+    body: event.body ? normalizeDocument(event.body) : null,
+  });
+}
+
+/** DocumentHandler answers with keel's Go struct: zero values stand for the row's NULLs. */
+function normalizeDocument(doc: DocumentHandlerResponse): PartnerDocument {
+  return {
+    Id: doc.ID,
+    ContrepId: doc.ContRepID,
+    DocKey: doc.DocKey,
+    PartnerId: doc.PartnerID,
+    UserId: doc.UserID || null,
+    DocumentType: doc.DocumentType,
+    Title: doc.Title,
+    FileName: doc.FileName,
+    VersionNo: doc.VersionNo,
+    DocumentNumber: doc.DocumentNumber || null,
+    ExpiresOn: timeOrNull(doc.ExpiresOn),
+    OriginIp: doc.OriginIP || null,
+    UploadedBy: doc.UploadedBy || null,
+    UploadedAt: doc.UploadedAt,
+    Status: doc.Status,
+    ReviewerId: doc.ReviewerID || null,
+    ReviewedAt: timeOrNull(doc.ReviewedAt),
+    ReviewerNotes: doc.ReviewerNotes || null,
+    SupersededAt: timeOrNull(doc.SupersededAt),
+    RetiredAt: timeOrNull(doc.RetiredAt),
+    PurgedAt: timeOrNull(doc.PurgedAt),
+  };
+}
+
+function timeOrNull(value: string): string | null {
+  return !value || value.startsWith('0001-01-01') ? null : value;
+}

package/src/service/realtime.service.ts

@@ -8,9 +8,11 @@ export interface RealtimeChannelFrame<T = unknown> {
   data:    T;
 }
 
+const CONTROL_OPS = ['subscribed', 'unsubscribed', 'error'] as const;
+
 /** Control frames of the keel realtime wire protocol. */
 interface ControlFrame {
-  op:       'subscribed' | 'unsubscribed' | 'error';
+  op:       typeof CONTROL_OPS[number];
   channel?: string;
   reason?:  string;
 }
@@ -93,7 +95,7 @@ export class RealtimeService {
     if (this.channels.delete(channel) && this.connected()) this.sendFrame({ op: 'unsubscribe', channel });
   }
 
-  /** Payloads keel delivers to this user directly (SendToUser / PublishUser). */
+  /** Payloads keel delivers to this user directly (SendToUser / PublishUser), e.g. `{op: 'notification', ...}`. */
   userFrames<T = unknown>(): Observable<T> {
     return this.frames$.pipe(filter((f): f is T => !isChannelFrame(f) && !isControlFrame(f)));
   }
@@ -132,7 +134,7 @@ function isChannelFrame(f: unknown): f is RealtimeChannelFrame {
 }
 
 function isControlFrame(f: unknown): f is ControlFrame {
-  return !!f && typeof f === 'object' && 'op' in f;
+  return !!f && typeof f === 'object' && CONTROL_OPS.includes((f as { op?: unknown }).op as ControlFrame['op']);
 }
 
 /** ws(s):// form of the configured backend host plus `path`; same-origin when no host is set. */

package/src/service/rest_service.ts

@@ -153,8 +153,18 @@ export class BackendService extends BaseRestService {
      * the call will POST to {host}{api_prefix}{actionPath} with the
      * supplied body. For record-specific actions the body carries the
      * primary key values; for table-level actions it is typically `{}`.
+     * A body carrying a File/Blob posts as `multipart/form-data`.
      */
     executeAction<T = unknown>(actionPath: string, body: Record<string, unknown> = {}): Observable<T> {
-        return this.http.post<T>(this.apiUrl(actionPath), body).pipe(catchError((err) => this.handleError(err)));
+        return this.http.post<T>(this.apiUrl(actionPath), multipartWhenFile(body)).pipe(catchError((err) => this.handleError(err)));
     }
 }
+
+function multipartWhenFile(body: Record<string, unknown>): Record<string, unknown> | FormData {
+    if (!Object.values(body).some((value) => value instanceof Blob)) return body;
+    const form = new FormData();
+    for (const [key, value] of Object.entries(body)) {
+        if (value != null) form.append(key, value instanceof Blob ? value : String(value));
+    }
+    return form;
+}

package/src/service/rest_url.ts

@@ -77,11 +77,14 @@ export const RestURL = {
   agencyAcceptInviteURL:     '/api/v1/agency/invite/accept',
   agencyDelegationURL:       '/api/v1/agency/delegation',
   agencyRevokeDelegationURL: '/api/v1/agency/delegation/revoke',
-  // User payment methods — list/delete go through keel's generic REST
-  // CRUD against the UserSpecific basis table; set-default is a
-  // TableAction (basis table_action row), mounted at the conventional
-  // URL POST /api/v1/user_payment_method/set_default.
+  // User payment methods — list is keel's generic REST CRUD; set_default and
+  // remove are keel UserPaymentMethodHandler table actions.
   paymentMethodSetDefaultURL: '/api/v1/user_payment_method/set_default',
+  paymentMethodRemoveURL:     '/api/v1/user_payment_method/remove',
+  // Partner documents — keel DocumentHandler, mounted at its TableActionPath shape.
+  partnerDocumentUploadURL:  '/api/v1/partner_document/upload',
+  partnerDocumentPreviewURL: '/api/v1/partner_document/preview',
+  partnerDocumentReviewURL:  '/api/v1/partner_document/review',
 };
 
 /** Call this at app startup to set the backend host URL */

package/src/service/user_payment_method.service.ts

@@ -8,13 +8,10 @@ import { UserPaymentMethod } from '../model/appdata';
 /**
  * UserPaymentMethodService — consumer-side saved-payment-methods API.
  *
- * list and delete go through keel's generic REST CRUD against the
- * basis user_payment_method table — that table is UserSpecific (FK
- * column `user_id`), so the auto-filter scopes reads + owner-locks
- * DELETE without any custom server-side glue. setDefault has a custom
- * endpoint because it needs an atomic multi-row UPDATE
- * (`SET is_default = (id = ?) WHERE user_id = session`) that abstract
- * single-row CRUD can't express.
+ * list goes through keel's generic REST CRUD against the UserSpecific basis
+ * user_payment_method table. remove and setDefault are keel table actions:
+ * remove detaches the method at the provider before deleting the row, so keel
+ * grants no generic DELETE on the table.
  */
 @Injectable({ providedIn: 'root' })
 export class UserPaymentMethodService extends BaseRestService {
@@ -29,15 +26,12 @@ export class UserPaymentMethodService extends BaseRestService {
     return this.backend.list<UserPaymentMethod>('user_payment_method');
   }
 
-  /** Delete a saved payment method. user_id is auto-scoped by keel. */
-  delete(id: number): Observable<{ message: string }> {
-    return this.backend.delete('user_payment_method', { Id: String(id) });
+  /** Detach a saved payment method at the provider and delete it. */
+  remove(id: number): Observable<{ message: string }> {
+    return this.http.post<{ message: string }>(this.url(RestURL.paymentMethodRemoveURL), { id });
   }
 
-  /**
-   * Mark one row as default; clears every other row in the same call.
-   * Custom endpoint — see service-class doc for the rationale.
-   */
+  /** Mark one row as default; clears every other row in the same call. */
   setDefault(id: number): Observable<{ message: string }> {
     return this.http.post<{ message: string }>(this.url(RestURL.paymentMethodSetDefaultURL), { id });
   }