@honuware/ui 0.1.0

package/types/honuware-ui-crud.d.ts

@@ -0,0 +1,287 @@
+import { Observable } from 'rxjs';
+import { DatabaseSchema, CrudAccess, TableSchema, TableBinding, FilterPair, ColumnDataInfo, ForeignKeyInfo, PhotoUrlBuilder, CrudFormAssist, ComputedDateRule } from '@honuware/ui/access';
+import { AuthService } from '@honuware/ui/auth';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, OnChanges, SimpleChanges, QueryList, OnDestroy } from '@angular/core';
+import { Router, ActivatedRoute } from '@angular/router';
+import { MatDialog } from '@angular/material/dialog';
+import { CompositeControlComponent } from '@honuware/ui/controls';
+import { PhotoUploadComponent } from '@honuware/ui/photos';
+
+declare class DatabaseSchemaService {
+    private crudAccess;
+    private authService;
+    private _schema?;
+    private _schemaSubject;
+    private _refreshSub?;
+    private _fetchInProgress;
+    private _retryTimeoutMs;
+    private readonly destroyRef;
+    readonly schema$: Observable<DatabaseSchema | undefined>;
+    constructor(crudAccess: CrudAccess, authService: AuthService);
+    private startSchemaPolling;
+    refreshSchema(): void;
+    private tryFetchSchema;
+    /**
+     * Returns the cached DatabaseSchema if present, otherwise waits for a successful fetch.
+     */
+    GetDBSchema(): Observable<DatabaseSchema>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseSchemaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatabaseSchemaService>;
+}
+
+/**
+ * Serialize a binding stack to a ctx query param string.
+ * Format: "table:pkColumn:pkValue,table:pkColumn:pkValue"
+ */
+declare function serializeBindingStack(stack: TableBinding[]): string;
+/**
+ * Deserialize a ctx query param string into a TableBinding array.
+ * Returns empty array for null/empty input.
+ */
+declare function parseBindingStack(ctx: string | null | undefined): TableBinding[];
+/**
+ * Derive filter pairs from the binding stack for the current table.
+ * Looks at the current table's foreign keys and matches them against
+ * the binding stack to build WHERE clause filters.
+ *
+ * For example, if viewing purchases with ctx=people:person_id:42,
+ * and purchases has FK column payer_person_id -> people.person_id,
+ * this returns [{ column_name: 'payer_person_id', column_value: '42' }].
+ */
+declare function deriveFilterPairs(currentTableSchema: TableSchema, bindingStack: TableBinding[]): FilterPair[];
+
+interface CrudEditorRoutes {
+    /**
+     * Base path for the generic table editor routes. Navigation is built as
+     * `[basePath, tableName, 'view'|'edit'|'new', ...]`, so this must be the
+     * absolute prefix the editor routes are mounted at.
+     */
+    basePath: string;
+    /** The admin portal home the "back" links point at. */
+    adminHome: string;
+}
+declare const DEFAULT_CRUD_EDITOR_ROUTES: CrudEditorRoutes;
+declare const CRUD_EDITOR_ROUTES: InjectionToken<CrudEditorRoutes>;
+
+interface ChildTableReference$1 {
+    childTableName: string;
+    childTableFriendlyName: string;
+    foreignKey: ForeignKeyInfo;
+}
+declare class TableViewControlComponent implements OnInit, OnChanges {
+    private dbSchemaService;
+    private crudAccess;
+    private photoUrlBuilder;
+    private editorRoutes;
+    private router;
+    private dialog;
+    tableName: string;
+    pageSize: number;
+    pageOffset: number;
+    sortColumn?: string;
+    sortAscending: boolean;
+    bindingStack: TableBinding[];
+    databaseSchema?: DatabaseSchema;
+    tableSchema?: TableSchema;
+    columns: ColumnDataInfo[];
+    displayedColumns: string[];
+    dataSource: Record<string, string>[];
+    totalCount: number;
+    loading: boolean;
+    error?: string;
+    childTableReferences: ChildTableReference$1[];
+    /** Maps column_name → pk_value → display_text for FK columns. */
+    fkDisplayMap: Record<string, Record<string, string>>;
+    pageSizeOptions: number[];
+    constructor(dbSchemaService: DatabaseSchemaService, crudAccess: CrudAccess, photoUrlBuilder: PhotoUrlBuilder, editorRoutes: CrudEditorRoutes, router: Router, dialog: MatDialog);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private loadData;
+    private getChildTableReferences;
+    private resolveFkDisplayValues;
+    onNavigateToChild(ref: ChildTableReference$1, row: Record<string, string>): void;
+    private isTrueValue;
+    formatCellValue(column: ColumnDataInfo, value: string): string;
+    isBoolColumn(column: ColumnDataInfo): boolean;
+    getBoolValue(value: string): boolean;
+    getColumnHeader(column: ColumnDataInfo): string;
+    get hasPhotoSupport(): boolean;
+    getPhotoUrl(row: Record<string, string>): string;
+    getPrimaryKeyValue(row: Record<string, string>): string;
+    get currentPage(): number;
+    get totalPages(): number;
+    get startRow(): number;
+    get endRow(): number;
+    get canGoPrevious(): boolean;
+    get canGoNext(): boolean;
+    goToFirstPage(): void;
+    goToPreviousPage(): void;
+    goToNextPage(): void;
+    goToLastPage(): void;
+    /** Build query params preserving ctx for nested navigation. */
+    private buildCtxQueryParams;
+    private navigateToPage;
+    onPageSizeChange(newPageSize: number): void;
+    onNewItem(): void;
+    onEditRow(row: Record<string, string>): void;
+    /** Navigate back to the parent table's edit page by popping the binding stack. */
+    onNavigateToParent(): void;
+    get hasParent(): boolean;
+    get parentFriendlyName(): string;
+    onDeleteRow(row: Record<string, string>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableViewControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableViewControlComponent, "hw-table-view-control", never, { "tableName": { "alias": "tableName"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageOffset": { "alias": "pageOffset"; "required": false; }; "sortColumn": { "alias": "sortColumn"; "required": false; }; "sortAscending": { "alias": "sortAscending"; "required": false; }; "bindingStack": { "alias": "bindingStack"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A child table reference discovered from the schema.
+ * Represents a nested table that has an FK pointing back to the current table.
+ */
+interface ChildTableReference {
+    childTableName: string;
+    childTableFriendlyName: string;
+    foreignKey: ForeignKeyInfo;
+}
+declare class CompositeRowControlComponent implements OnInit {
+    private dbSchemaService;
+    private crudAccess;
+    private editorRoutes;
+    private router;
+    tableName: string;
+    columnNames: string[];
+    primaryKeyName?: string;
+    primaryKeyValue?: string;
+    isCreateMode: boolean;
+    returnUrl?: string;
+    bindingStack: TableBinding[];
+    formAssist?: CrudFormAssist;
+    controls: QueryList<CompositeControlComponent>;
+    photoUpload?: PhotoUploadComponent;
+    columnInfos: ColumnDataInfo[];
+    loading: boolean;
+    columnValues: (string | undefined)[];
+    hasPhotoSupport: boolean;
+    childTableReferences: ChildTableReference[];
+    /** Set of FK column names from navigation context (readonly + pre-filled in create mode). */
+    private contextFkColumnNames;
+    private databaseSchema?;
+    private tableSchema?;
+    /** Tracks whether each computed date dest column is in auto-compute mode. */
+    computedDateAutoState: Record<string, boolean>;
+    constructor(dbSchemaService: DatabaseSchemaService, crudAccess: CrudAccess, editorRoutes: CrudEditorRoutes, router: Router);
+    ngOnInit(): void;
+    private loadColumnInfos;
+    /**
+     * Compute the set of FK column names that come from navigation context.
+     * These should be readonly in both edit and create mode.
+     */
+    private computeContextFkColumns;
+    /**
+     * Get the pre-fill value for an FK column from the binding stack.
+     * Returns null if the column is not an FK from context.
+     */
+    private getContextFkValue;
+    /**
+     * Find nested tables that have FK references to the current table.
+     * Only includes tables listed in schema.nested_tables.
+     */
+    private getChildTableReferences;
+    get visibleColumns(): {
+        col: ColumnDataInfo;
+        index: number;
+    }[];
+    /** Check if a column should be readonly. Includes context FK columns. */
+    isReadonlyColumn(col: ColumnDataInfo): boolean;
+    /** Whether the column is an FK from navigation context. */
+    isContextFkColumn(col: ColumnDataInfo): boolean;
+    onValueChanged(index: number, value: string): void;
+    getControlValues(): Record<string, string | undefined>;
+    private isTextColumnType;
+    onSubmit(): void;
+    onCancel(): void;
+    private isTrueValue;
+    get showPhotoUpload(): boolean;
+    get photoItemId(): number;
+    getForeignKeyInfo(col: ColumnDataInfo): ForeignKeyInfo | undefined;
+    isPrimaryKeyColumn(col: ColumnDataInfo): boolean;
+    get hasParent(): boolean;
+    get parentFriendlyName(): string;
+    /** Navigate back to the parent table's edit page by popping the binding stack. */
+    onNavigateToParent(): void;
+    /** Navigate to a child (nested) table filtered by the current row. */
+    onNavigateToChild(ref: ChildTableReference): void;
+    private initComputedDateState;
+    /** When a source field changes, update any auto-computed dest fields. */
+    private applyComputedDates;
+    private computeAndSetDate;
+    /** Toggle auto-compute for a computed date dest column. */
+    onToggleComputedDate(destColumn: string): void;
+    /** Check if a column is a computed date dest in auto mode. */
+    isComputedDateAuto(columnName: string): boolean;
+    /** Get the computed date rule for a column, if any. */
+    getComputedDateRule(columnName: string): ComputedDateRule | undefined;
+    private navigateBack;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompositeRowControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CompositeRowControlComponent, "hw-composite-row-control", never, { "tableName": { "alias": "tableName"; "required": false; }; "columnNames": { "alias": "columnNames"; "required": false; }; "primaryKeyName": { "alias": "primaryKeyName"; "required": false; }; "primaryKeyValue": { "alias": "primaryKeyValue"; "required": false; }; "isCreateMode": { "alias": "isCreateMode"; "required": false; }; "returnUrl": { "alias": "returnUrl"; "required": false; }; "bindingStack": { "alias": "bindingStack"; "required": false; }; "formAssist": { "alias": "formAssist"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TableViewPageComponent implements OnInit, OnDestroy {
+    private route;
+    tableName: string;
+    pageSize: number;
+    pageOffset: number;
+    bindingStack: TableBinding[];
+    readonly adminHome: string;
+    private destroy$;
+    constructor(route: ActivatedRoute, editorRoutes: CrudEditorRoutes);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableViewPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableViewPageComponent, "hw-table-view-page", never, {}, {}, never, never, true, never>;
+}
+
+declare class TableEditPageComponent implements OnInit, OnDestroy {
+    private route;
+    private dbSchemaService;
+    tableName: string;
+    primaryKeyName: string;
+    primaryKeyValue: string;
+    columnNames: string[];
+    tableFriendlyName: string;
+    returnUrl: string;
+    bindingStack: TableBinding[];
+    loading: boolean;
+    error?: string;
+    readonly adminHome: string;
+    private destroy$;
+    constructor(route: ActivatedRoute, dbSchemaService: DatabaseSchemaService, editorRoutes: CrudEditorRoutes);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableEditPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableEditPageComponent, "hw-table-edit-page", never, {}, {}, never, never, true, never>;
+}
+
+declare class TableNewPageComponent implements OnInit, OnDestroy {
+    private route;
+    private router;
+    private dbSchemaService;
+    tableName: string;
+    columnNames: string[];
+    tableFriendlyName: string;
+    returnUrl: string;
+    bindingStack: TableBinding[];
+    formAssist?: CrudFormAssist;
+    loading: boolean;
+    error?: string;
+    readonly adminHome: string;
+    private destroy$;
+    constructor(route: ActivatedRoute, router: Router, dbSchemaService: DatabaseSchemaService, editorRoutes: CrudEditorRoutes);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableNewPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableNewPageComponent, "hw-table-new-page", never, {}, {}, never, never, true, never>;
+}
+
+export { CRUD_EDITOR_ROUTES, CompositeRowControlComponent, DEFAULT_CRUD_EDITOR_ROUTES, DatabaseSchemaService, TableEditPageComponent, TableNewPageComponent, TableViewControlComponent, TableViewPageComponent, deriveFilterPairs, parseBindingStack, serializeBindingStack };
+export type { ChildTableReference, CrudEditorRoutes };

package/types/honuware-ui-foundation.d.ts

@@ -0,0 +1,89 @@
+import { MatSnackBar } from '@angular/material/snack-bar';
+import * as i0 from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as _angular_animations from '@angular/animations';
+
+type ToastType = 'success' | 'error' | 'warning' | 'info';
+declare class ToastService {
+    private snackBar;
+    private readonly defaultDuration;
+    constructor(snackBar: MatSnackBar);
+    /**
+     * Show a success toast notification
+     */
+    success(message: string, duration?: number): void;
+    /**
+     * Show an error toast notification
+     */
+    error(message: string, duration?: number): void;
+    /**
+     * Show a warning toast notification
+     */
+    warning(message: string, duration?: number): void;
+    /**
+     * Show an info toast notification
+     */
+    info(message: string, duration?: number): void;
+    /**
+     * Show a toast notification with the specified type
+     */
+    show(message: string, type?: ToastType, duration?: number): void;
+    /**
+     * Dismiss any currently visible toast
+     */
+    dismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}
+
+interface ConfirmDialogData {
+    title: string;
+    description?: string;
+    buttonText?: string;
+}
+declare class ConfirmDialogComponent {
+    readonly dialogRef: MatDialogRef<ConfirmDialogComponent, boolean>;
+    readonly data: ConfirmDialogData;
+    clickConfirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDialogComponent, "hw-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare const fuseAnimations: _angular_animations.AnimationTriggerMetadata[];
+
+declare function sanitizeReturnUrl(raw: string | null | undefined, allowlist: ReadonlyArray<string>): string;
+
+declare function isMicrosecondTimestamp(value: string): boolean;
+declare function microsToDate(value: string): Date;
+declare function dateToMicros(date: Date): string;
+/**
+ * Format a microsecond timestamp as a UTC calendar date.
+ * Use for dates that represent calendar days stored as UTC midnight
+ * (e.g., period_start_us, valid_from_us, next_billing_us).
+ */
+declare function formatCalendarDate(value: string | number, long?: boolean): string;
+/**
+ * Format an exclusive-end microsecond timestamp as an inclusive UTC date.
+ * Subtracts 1 day to convert from "first moment of next period" to "last day of period".
+ * Use for period_end_us, valid_to_us where the stored value is the start of the next period.
+ */
+declare function formatPeriodEndDate(value: string | number, long?: boolean): string;
+/** Get the UTC year from a microsecond timestamp string. */
+declare function getUtcYear(value: string): number;
+/** Get the UTC month (0-indexed) from a microsecond timestamp string. */
+declare function getUtcMonth(value: string): number;
+declare function areSameDates(date1: Date, date2: Date): boolean;
+/** The Sunday starting the week containing `date` (local time). */
+declare function firstDayOfWeek(date: Date): Date;
+/** The Saturday ending the week containing `date` (local time). */
+declare function lastDayOfWeek(date: Date): Date;
+declare function firstDayOfMonth(date: Date): Date;
+/** Expects the first day of a month; returns that month's last day. */
+declare function lastDayOfMonth(date: Date): Date;
+declare function addDaysToDate(date: Date, days: number): Date;
+declare function addWeeksToDate(date: Date, weeks: number): Date;
+declare function addMonthsToDate(date: Date, months: number): Date;
+declare function formatMicroseconds(value: string): string;
+
+export { ConfirmDialogComponent, ToastService, addDaysToDate, addMonthsToDate, addWeeksToDate, areSameDates, dateToMicros, firstDayOfMonth, firstDayOfWeek, formatCalendarDate, formatMicroseconds, formatPeriodEndDate, fuseAnimations, getUtcMonth, getUtcYear, isMicrosecondTimestamp, lastDayOfMonth, lastDayOfWeek, microsToDate, sanitizeReturnUrl };
+export type { ConfirmDialogData, ToastType };

package/types/honuware-ui-photos.d.ts

@@ -0,0 +1,46 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { Observable } from 'rxjs';
+import { PhotoAccess, PhotoUrlBuilder } from '@honuware/ui/access';
+
+declare class PhotoUploadComponent implements OnInit, OnChanges, OnDestroy {
+    private photoAccess;
+    private photoUrlBuilder;
+    tableName: string;
+    tableItemId: number;
+    userMode: boolean;
+    deferUpload: boolean;
+    private static readonly MAX_IMAGE_DIMENSION;
+    photoUrl: string;
+    hasPhoto: boolean;
+    loading: boolean;
+    uploading: boolean;
+    error?: string;
+    pendingFile: File | null;
+    pendingPreviewUrl: string;
+    constructor(photoAccess: PhotoAccess, photoUrlBuilder: PhotoUrlBuilder);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private checkPhoto;
+    private buildPhotoUrl;
+    onFileSelected(event: Event): void;
+    onDragOver(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    private uploadFile;
+    get hasPendingFile(): boolean;
+    clearPendingFile(): void;
+    uploadPendingPhoto(tableName: string, tableItemId: number): Observable<void>;
+    /**
+     * Re-encode the image as JPEG and resize if it exceeds the max dimensions.
+     * Converting to JPEG dramatically reduces file size for photographic content
+     * (a 25 MB PNG becomes ~1-2 MB JPEG) and keeps uploads under the server's
+     * image_max_upload_bytes limit.
+     */
+    private prepareImageForUpload;
+    onDeletePhoto(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhotoUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PhotoUploadComponent, "hw-photo-upload", never, { "tableName": { "alias": "tableName"; "required": false; }; "tableItemId": { "alias": "tableItemId"; "required": false; }; "userMode": { "alias": "userMode"; "required": false; }; "deferUpload": { "alias": "deferUpload"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { PhotoUploadComponent };

package/types/honuware-ui-square.d.ts

@@ -0,0 +1,65 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+interface SquareConfig {
+    applicationId: string;
+    locationId: string;
+    scriptUrl: string;
+}
+declare const SQUARE_CONFIG: InjectionToken<SquareConfig>;
+
+/**
+ * Service for handling Square Web Payments SDK integration.
+ * Dynamically loads the Square SDK script based on the injected SQUARE_CONFIG.
+ *
+ * @example
+ * ```typescript
+ * // In a component
+ * async ngAfterViewInit() {
+ *   await this.squarePayment.attachCard('#card-container');
+ * }
+ *
+ * async onSubmit() {
+ *   const token = await this.squarePayment.tokenizeCard();
+ *   // Send token to server
+ * }
+ * ```
+ */
+declare class SquarePaymentService {
+    private squareConfig;
+    private payments;
+    private card;
+    private scriptLoaded;
+    constructor(squareConfig: SquareConfig);
+    /**
+     * Dynamically loads the Square SDK script based on the injected config.
+     * Only loads once; subsequent calls return immediately.
+     */
+    private loadScript;
+    /**
+     * Initializes the Square Payments SDK.
+     * Automatically loads the script if not already loaded.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Attaches the Square card input form to a DOM element.
+     * @param containerId CSS selector for the container element (e.g., '#card-container')
+     */
+    attachCard(containerId: string): Promise<void>;
+    /**
+     * Tokenizes the card data entered by the user.
+     * @returns The payment token to send to the server
+     * @throws Error if tokenization fails
+     */
+    tokenizeCard(): Promise<string>;
+    /**
+     * Destroys the card form and resets state.
+     * Call this when navigating away from the payment page.
+     */
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SquarePaymentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SquarePaymentService>;
+}
+
+export { SQUARE_CONFIG, SquarePaymentService };
+export type { SquareConfig };

package/types/honuware-ui-testing.d.ts

@@ -0,0 +1,126 @@
+import { Observable } from 'rxjs';
+import { CrudAccess, DatabaseSchema, DataResults, DataResultsWithCount, FilterPair, AddItemBody, UpdateItemBody, FkOptionsResponse, FkDisplayResponse, AuthAccess, UserInfo, LoginInfo, SetUserInfo, UpdateUserPasswordInfo, PhotoAccess, SourcePhotoInfo } from '@honuware/ui/access';
+import { Provider } from '@angular/core';
+
+/** A stored row: a column-name → string-value map. */
+type MockRow = Record<string, string>;
+interface MockCrudAccessOptions {
+    /** The schema this store honors (columns, primary keys, FK display templates). */
+    schema?: DatabaseSchema;
+    /** Seed rows keyed by table name. */
+    seedRows?: Record<string, MockRow[]>;
+}
+/**
+ * In-memory, schema-driven {@link CrudAccess} for library/consumer tests. Honors
+ * a supplied {@link DatabaseSchema} (columns, primary keys, FK display
+ * templates) and keeps rows per table. Deterministic and dependency-free — the
+ * framework counterpart to the app's ServerAccessMock, but only the 12 generic
+ * CRUD methods.
+ */
+declare class MockCrudAccess implements CrudAccess {
+    private readonly schema;
+    private readonly rows;
+    private readonly pkCounters;
+    constructor(options?: MockCrudAccessOptions);
+    getDbSchema(): Observable<DatabaseSchema>;
+    getTableRows(tableName: string): Observable<DataResults>;
+    getRowsByColumn(tableName: string, columnName: string, ascending: boolean, pageSize: number, pageNumber: number): Observable<DataResultsWithCount>;
+    getFilteredTableRows(tableName: string, columnName: string, ascending: boolean, pageSize: number, page: number, filterPairs: FilterPair[]): Observable<DataResultsWithCount>;
+    getRow(tableName: string, columnName: string, columnValue: string): Observable<DataResults>;
+    getRowByValues(tableName: string, filterPairs: FilterPair[]): Observable<DataResults>;
+    addItem(body: AddItemBody): Observable<void>;
+    addItemFetchPrimaryKey(body: AddItemBody): Observable<string>;
+    updateItem(body: UpdateItemBody): Observable<void>;
+    deleteItem(tableName: string, columnName: string, columnValue: string): Observable<void>;
+    getFkOptions(tableName: string, searchText: string, pageSize: number): Observable<FkOptionsResponse>;
+    resolveFkDisplay(parentTableName: string, values: string[]): Observable<FkDisplayResponse>;
+    private tableSchema;
+    private columnNames;
+    private tableRows;
+    private toDataResults;
+    private insert;
+    private nextPrimaryKey;
+    private applyFilters;
+    private sorted;
+    private paginate;
+    private renderTemplate;
+}
+
+interface StoredUser {
+    user: UserInfo;
+    password: string;
+}
+interface MockAuthAccessOptions {
+    /** Seed users the store knows about (with their login password). */
+    users?: StoredUser[];
+}
+/**
+ * In-memory {@link AuthAccess} session simulator for tests. Tracks registered
+ * users, a current session, and a "remember me" token. `me()`/`getUserInfo()`
+ * reject with a 401-shaped error when no session is active — enough to exercise
+ * AuthService's login / silent-reauth (me → remember → me) flows.
+ */
+declare class MockAuthAccess implements AuthAccess {
+    private readonly users;
+    private currentEmail;
+    private rememberedEmail;
+    private personIdCounter;
+    constructor(options?: MockAuthAccessOptions);
+    register(firstName: string, lastName: string, email: string, password: string): Observable<void>;
+    verify(): Observable<void>;
+    login(loginInfo: LoginInfo): Observable<void>;
+    logout(): Observable<void>;
+    me(): Observable<void>;
+    remember(): Observable<void>;
+    getUserInfo(): Observable<UserInfo>;
+    setUserInfo(userInfo: SetUserInfo): Observable<void>;
+    updateUserPassword(passwordInfo: UpdateUserPasswordInfo): Observable<void>;
+    /**
+     * Test helper (not part of AuthAccess): drop the active session but keep the
+     * "remember me" token — so a subsequent `me()` rejects and `remember()` can
+     * restore the session, exercising the silent-reauth path (me → remember → me).
+     */
+    expireSession(): void;
+}
+
+/**
+ * In-memory {@link PhotoAccess} simulator for tests. Remembers which table rows
+ * have a photo so `hasPhoto()` reflects prior `uploadPhoto()`/`deletePhoto()`
+ * calls. Ignores the image bytes (mocks the server's re-encode + store).
+ */
+declare class MockPhotoAccess implements PhotoAccess {
+    private readonly photos;
+    private nextId;
+    uploadPhoto(tableName: string, tableItemId: number, imageData: ArrayBuffer, imageType: string): Observable<SourcePhotoInfo>;
+    uploadUserPhoto(imageData: ArrayBuffer, imageType: string): Observable<SourcePhotoInfo>;
+    deletePhoto(tableName: string, tableItemId: number): Observable<void>;
+    hasPhoto(tableName: string, tableItemId: number): Observable<{
+        has_photo: boolean;
+    }>;
+    private key;
+}
+
+interface HonuwareAccessMocks {
+    crud: MockCrudAccess;
+    auth: MockAuthAccess;
+    photo: MockPhotoAccess;
+}
+interface ProvideHonuwareAccessMockOptions {
+    crud?: MockCrudAccessOptions;
+    auth?: MockAuthAccessOptions;
+}
+/**
+ * Test wiring: creates the three in-memory framework mocks and provides them for
+ * the `HONUWARE_*_ACCESS` tokens (mock mode of `provideHonuwareAccess`). Pass a
+ * `capture` callback to grab the mock instances for seeding/assertions.
+ *
+ * @example
+ * let mocks: HonuwareAccessMocks;
+ * TestBed.configureTestingModule({
+ *   providers: [provideHonuwareAccessMock({ crud: { schema } }, (m) => (mocks = m))],
+ * });
+ */
+declare function provideHonuwareAccessMock(options?: ProvideHonuwareAccessMockOptions, capture?: (mocks: HonuwareAccessMocks) => void): Provider[];
+
+export { MockAuthAccess, MockCrudAccess, MockPhotoAccess, provideHonuwareAccessMock };
+export type { HonuwareAccessMocks, MockAuthAccessOptions, MockCrudAccessOptions, MockRow, ProvideHonuwareAccessMockOptions, StoredUser };

package/types/honuware-ui.d.ts

@@ -0,0 +1,3 @@
+declare const HONUWARE_UI_VERSION = "0.1.0";
+
+export { HONUWARE_UI_VERSION };