@honuware/ui 0.1.0

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

@@ -0,0 +1,382 @@
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider } from '@angular/core';
+import { HttpClient, HttpErrorResponse, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+
+interface DataResults {
+    sortedColumnNames: string[];
+    dataTable: string[][];
+}
+interface DataResultsWithCount extends DataResults {
+    totalCount: number;
+}
+
+interface ColumnDataInfo {
+    column_name: string;
+    type: string;
+    primary_key: boolean;
+    unique: boolean;
+    nullable: boolean;
+    column_friendly_name?: string;
+    label?: string;
+    hint?: string;
+    place_holder?: string;
+    regex?: string;
+    html_input_type?: string;
+    required?: boolean;
+    max_length?: number;
+    default_value?: string;
+    rows?: number;
+    hidden?: boolean;
+    readonly?: boolean;
+    enum_values?: string[];
+}
+
+interface ForeignKeyInfo {
+    column_name: string;
+    parent_column_name: string;
+    parent_table_name: string;
+}
+
+interface TableSchema {
+    columns: ColumnDataInfo[];
+    description: string;
+    foreign_keys: ForeignKeyInfo[];
+    has_photo_support?: boolean;
+    primary_key: string;
+    table_friendly_name: string;
+    table_name: string;
+}
+
+interface DatabaseSchema {
+    root_tables: string[];
+    nested_tables: string[];
+    tables: TableSchema[];
+    display_templates: Record<string, string>;
+    fk_picker_preload_threshold: number;
+}
+
+interface FilterPair {
+    column_name: string;
+    column_value: string;
+}
+interface TableBinding {
+    tableName: string;
+    primaryKeyName: string;
+    primaryKeyValue: string;
+}
+interface FkOption {
+    value: string;
+    display: string;
+}
+interface FkOptionsResponse {
+    total_count: number;
+    options: FkOption[];
+}
+interface FkDisplayResponse {
+    resolved: Record<string, string>;
+}
+interface ComputedDateRule {
+    source: string;
+    dest: string;
+    offsetMinutes: number;
+    autoByDefault: boolean;
+}
+interface CrudFormAssist {
+    defaults?: Record<string, string>;
+    computedDates?: ComputedDateRule[];
+}
+
+interface AddItemBody {
+    table_name: string;
+    value: unknown;
+}
+interface UpdateItemBody {
+    table_name: string;
+    value: unknown;
+    column_name: string;
+    column_value: string;
+}
+interface CrudAccess {
+    addItem(body: AddItemBody): Observable<void>;
+    addItemFetchPrimaryKey(body: AddItemBody): Observable<string>;
+    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>;
+    updateItem(body: UpdateItemBody): Observable<void>;
+    deleteItem(tableName: string, columnName: string, columnValue: string): Observable<void>;
+    getDbSchema(): Observable<DatabaseSchema>;
+    getFkOptions(tableName: string, searchText: string, pageSize: number): Observable<FkOptionsResponse>;
+    resolveFkDisplay(parentTableName: string, values: string[]): Observable<FkDisplayResponse>;
+}
+
+interface UserInfo {
+    person_id: number;
+    first_name: string;
+    last_name: string;
+    email: string;
+    created_at: string;
+    roles: string[];
+    permissions: string[];
+    must_change_password?: boolean;
+}
+interface SetUserInfo {
+    first_name: string;
+    last_name: string;
+    email: string;
+}
+interface LoginInfo {
+    email: string;
+    password: string;
+    remember: boolean;
+}
+interface UpdateUserPasswordInfo {
+    old_password: string;
+    new_password: string;
+}
+interface AuthAccess {
+    register(firstName: string, lastName: string, email: string, password: string): Observable<void>;
+    verify(email: string, secret: string): 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>;
+}
+
+interface SourcePhotoInfo {
+    source_photo_id: number;
+    type: string;
+    width: number;
+    height: number;
+    created_at_us?: number;
+}
+interface HomePagePhotoInfo {
+    id: number;
+    title?: string;
+    description?: string;
+    created_at_us: number;
+}
+
+interface PhotoAccess {
+    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;
+    }>;
+}
+
+declare const HONUWARE_CRUD_ACCESS: InjectionToken<CrudAccess>;
+declare const HONUWARE_AUTH_ACCESS: InjectionToken<AuthAccess>;
+declare const HONUWARE_PHOTO_ACCESS: InjectionToken<PhotoAccess>;
+interface HonuwareAccessConfig {
+    /**
+     * 'http' (default): wire the three tokens to the serializing proxy over the
+     * default HTTP implementations. 'mock': wire them to caller-supplied
+     * implementations (e.g. the in-memory mocks from @honuware/ui/testing).
+     */
+    mode?: 'http' | 'mock';
+    crud?: CrudAccess;
+    auth?: AuthAccess;
+    photo?: PhotoAccess;
+}
+declare function provideHonuwareAccess(config?: HonuwareAccessConfig): Provider[];
+
+declare const HONUWARE_API_BASE: InjectionToken<string>;
+
+declare class CrudHttpAccess implements CrudAccess {
+    private http;
+    private base;
+    constructor(http: HttpClient, base: string);
+    addItem(body: AddItemBody): Observable<void>;
+    addItemFetchPrimaryKey(body: AddItemBody): Observable<string>;
+    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>;
+    updateItem(body: UpdateItemBody): Observable<void>;
+    deleteItem(tableName: string, columnName: string, columnValue: string): Observable<void>;
+    getDbSchema(): Observable<DatabaseSchema>;
+    getFkOptions(tableName: string, searchText: string, pageSize: number): Observable<FkOptionsResponse>;
+    resolveFkDisplay(parentTableName: string, values: string[]): Observable<FkDisplayResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudHttpAccess, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CrudHttpAccess>;
+}
+
+declare class AuthHttpAccess implements AuthAccess {
+    private http;
+    private base;
+    constructor(http: HttpClient, base: string);
+    register(firstName: string, lastName: string, email: string, password: string): Observable<void>;
+    verify(email: string, secret: string): 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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthHttpAccess, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthHttpAccess>;
+}
+
+declare class PhotoHttpAccess implements PhotoAccess {
+    private http;
+    private base;
+    constructor(http: HttpClient, base: string);
+    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;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhotoHttpAccess, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PhotoHttpAccess>;
+}
+
+declare class HonuwareAccessProxy implements CrudAccess, AuthAccess, PhotoAccess {
+    private crud;
+    private auth;
+    private photo;
+    private queue;
+    private busy;
+    constructor(crud: CrudHttpAccess, auth: AuthHttpAccess, photo: PhotoHttpAccess);
+    private serialize;
+    private pump;
+    addItem(body: AddItemBody): Observable<void>;
+    addItemFetchPrimaryKey(body: AddItemBody): Observable<string>;
+    getTableRows(tableName: string): Observable<DataResults>;
+    getRowsByColumn(t: string, c: string, a: boolean, s: number, p: number): Observable<DataResultsWithCount>;
+    getFilteredTableRows(t: string, c: string, a: boolean, s: number, p: number, f: FilterPair[]): Observable<DataResultsWithCount>;
+    getRow(t: string, c: string, v: string): Observable<DataResults>;
+    getRowByValues(t: string, f: FilterPair[]): Observable<DataResults>;
+    updateItem(body: UpdateItemBody): Observable<void>;
+    deleteItem(t: string, c: string, v: string): Observable<void>;
+    getDbSchema(): Observable<DatabaseSchema>;
+    getFkOptions(t: string, s: string, p: number): Observable<FkOptionsResponse>;
+    resolveFkDisplay(t: string, v: string[]): Observable<FkDisplayResponse>;
+    register(f: string, l: string, e: string, p: string): Observable<void>;
+    verify(email: string, secret: string): 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>;
+    uploadPhoto(t: string, id: number, data: ArrayBuffer, type: string): Observable<SourcePhotoInfo>;
+    uploadUserPhoto(data: ArrayBuffer, type: string): Observable<SourcePhotoInfo>;
+    deletePhoto(t: string, id: number): Observable<void>;
+    hasPhoto(t: string, id: number): Observable<{
+        has_photo: boolean;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HonuwareAccessProxy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HonuwareAccessProxy>;
+}
+
+declare class PhotoUrlBuilder {
+    private apiBase;
+    constructor(apiBase: string);
+    scaledPhotoUrl(tableName: string, tableItemId: number | string, width: number, height: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhotoUrlBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PhotoUrlBuilder>;
+}
+
+/**
+ * RFC 7807 Problem Details for HTTP APIs
+ * https://tools.ietf.org/html/rfc7807
+ */
+interface ProblemDetails {
+    /** Error type identifier (e.g., "validation_error") */
+    type: string;
+    /** Short human-readable summary */
+    title: string;
+    /** HTTP status code */
+    status: number;
+    /** Human-readable explanation for this specific occurrence */
+    detail: string;
+    /** URI reference identifying the specific occurrence (optional) */
+    instance?: string;
+    /** For validation errors, which field failed (extension) */
+    field?: string;
+    /** What constraint was violated (extension) */
+    constraint?: string;
+    /** For payment errors, which provider (extension) */
+    provider?: string;
+    /** Provider's error code (extension) */
+    provider_code?: string;
+    /** Allow additional extension fields */
+    [key: string]: unknown;
+}
+/** Error type constants matching server-side ErrorCodes */
+declare const ErrorTypes: {
+    readonly VALIDATION_ERROR: "validation_error";
+    readonly BAD_REQUEST: "bad_request";
+    readonly NOT_AUTHENTICATED: "not_authenticated";
+    readonly INVALID_CREDENTIALS: "invalid_credentials";
+    readonly SESSION_EXPIRED: "session_expired";
+    readonly NOT_AUTHORIZED: "not_authorized";
+    readonly NOT_FOUND: "not_found";
+    readonly IDEMPOTENCY_CONFLICT: "idempotency_conflict";
+    readonly INTERNAL_ERROR: "internal_error";
+    readonly PAYMENT_DECLINED: "payment_declined";
+    readonly PAYMENT_FAILED: "payment_failed";
+    readonly VOUCHER_INVALID: "voucher_invalid";
+    readonly SEATS_EXCEEDED: "seats_exceeded";
+    readonly BOOKING_CONFLICT: "booking_conflict";
+};
+type ErrorType = (typeof ErrorTypes)[keyof typeof ErrorTypes];
+/** Check if an error response is in RFC 7807 format */
+declare function isProblemDetails(error: unknown): error is ProblemDetails;
+
+declare class ErrorService {
+    /**
+     * Parse an HTTP error response into RFC 7807 ProblemDetails format.
+     * Handles both new RFC 7807 responses and legacy plain-text errors.
+     */
+    parseError(error: HttpErrorResponse): ProblemDetails;
+    /**
+     * Get user-friendly message from a ProblemDetails error.
+     * The detail field should already be user-friendly.
+     */
+    getUserFriendlyMessage(error: ProblemDetails): string;
+    private inferTypeFromStatus;
+    private getTitleForStatus;
+    private extractDetailFromError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorService>;
+}
+
+/**
+ * Phase 4.3 of the security review: companion to the server-side
+ * CsrfGuard middleware.
+ *
+ * On every state-changing request, read the `csrft` cookie that the
+ * backend set at login time (Phase 4.1), and copy its value into the
+ * `X-CSRF-Token` header. The double-submit pattern: an attacker on
+ * a different origin cannot read the cookie value across origins, so
+ * they can't forge a matching header.
+ *
+ * GETs / HEADs / OPTIONS pass through untouched. Requests that fire
+ * before the user has logged in (no cookie present) pass through
+ * unmodified — the server-side guard exempts the bootstrap endpoints
+ * (login / register / remember / verify) explicitly, so these still
+ * succeed.
+ */
+declare class CsrfInterceptor implements HttpInterceptor {
+    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    private readCsrfCookie;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CsrfInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CsrfInterceptor>;
+}
+
+declare function ColumnDataInfoFromJSON(obj: unknown): ColumnDataInfo;
+
+export { AuthHttpAccess, ColumnDataInfoFromJSON, CrudHttpAccess, CsrfInterceptor, ErrorService, ErrorTypes, HONUWARE_API_BASE, HONUWARE_AUTH_ACCESS, HONUWARE_CRUD_ACCESS, HONUWARE_PHOTO_ACCESS, HonuwareAccessProxy, PhotoHttpAccess, PhotoUrlBuilder, isProblemDetails, provideHonuwareAccess };
+export type { AddItemBody, AuthAccess, ColumnDataInfo, ComputedDateRule, CrudAccess, CrudFormAssist, DataResults, DataResultsWithCount, DatabaseSchema, ErrorType, FilterPair, FkDisplayResponse, FkOption, FkOptionsResponse, ForeignKeyInfo, HomePagePhotoInfo, HonuwareAccessConfig, LoginInfo, PhotoAccess, ProblemDetails, SetUserInfo, SourcePhotoInfo, TableBinding, TableSchema, UpdateItemBody, UpdateUserPasswordInfo, UserInfo };

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

@@ -0,0 +1,164 @@
+import { Observable } from 'rxjs';
+import { AuthAccess, UserInfo, ErrorService, ProblemDetails } from '@honuware/ui/access';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import { CanActivateFn, CanActivateChildFn, Router, ActivatedRoute } from '@angular/router';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpErrorResponse } from '@angular/common/http';
+import { FormGroup, FormBuilder } from '@angular/forms';
+import { ToastService } from '@honuware/ui/foundation';
+
+type AuthData = {
+    isAuth: false;
+} | {
+    isAuth: true;
+    personId: number;
+    firstName: string;
+    lastName: string;
+    email: string;
+    createdAt: string;
+    isAdmin: boolean;
+    roles: string[];
+    permissions: string[];
+    mustChangePassword: boolean;
+};
+declare const DEFAULT_NON_AUTH_DATA: AuthData;
+declare function hasPermission(authData: AuthData, permission: string): boolean;
+declare function hasManageProducts(authData: AuthData): boolean;
+declare function hasStaffAccess(authData: AuthData): boolean;
+
+declare class AuthService {
+    private authAccess;
+    private _authDataSubject;
+    get authData$(): Observable<AuthData>;
+    get authData(): AuthData;
+    constructor(authAccess: AuthAccess);
+    updateAuthData(userInfo: UserInfo): void;
+    setUserInfo(firstName: string, lastName: string, email: string): Observable<void>;
+    doSetUserInfo(firstName: string, lastName: string, email: string): void;
+    updateUserPassword(oldPassword: string, newPassword: string): Observable<void>;
+    doUpdateUserPassword(oldPassword: string, newPassword: string): void;
+    tryTokenLogin(): Observable<boolean>;
+    login(email: string, password: string, remember: boolean): Observable<void>;
+    logout(): Observable<void>;
+    register(firstName: string, lastName: string, email: string, password: string): Observable<void>;
+    verify(email: string, secret: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+
+interface AuthRoutes {
+    /** Where the login page lives. */
+    loginPath: string;
+    /** Where the register page lives. */
+    registerPath: string;
+    /**
+     * Home path — used both after logout and as the "access denied" fallback
+     * for guard checks that reject the current user.
+     */
+    postLogoutPath: string;
+    /** Forced-password-change page (users with must_change_password). */
+    mustChangePasswordPath: string;
+    /**
+     * Same-origin path prefixes a post-login returnUrl may target. Anything
+     * outside this list (or off-origin) is rejected to '/' by sanitizeReturnUrl.
+     */
+    returnUrlAllowlist: ReadonlyArray<string>;
+}
+declare const DEFAULT_AUTH_ROUTES: AuthRoutes;
+declare const AUTH_ROUTES: InjectionToken<AuthRoutes>;
+
+declare const AdminGuard: CanActivateFn | CanActivateChildFn;
+declare const AuthGuard: CanActivateFn | CanActivateChildFn;
+declare const ManageProductsGuard: CanActivateFn | CanActivateChildFn;
+declare const StaffGuard: CanActivateFn | CanActivateChildFn;
+declare const NoAuthGuard: CanActivateFn | CanActivateChildFn;
+
+/**
+ * Extended HttpErrorResponse that includes parsed ProblemDetails
+ */
+interface ParsedHttpErrorResponse extends HttpErrorResponse {
+    problemDetails: ProblemDetails;
+}
+declare class ErrorInterceptor implements HttpInterceptor {
+    private errorService;
+    private router;
+    private authRoutes;
+    constructor(errorService: ErrorService, router: Router, authRoutes: AuthRoutes);
+    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    private isAuthEndpoint;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorInterceptor>;
+}
+
+declare class LoginComponent {
+    private fb;
+    private authService;
+    private router;
+    private route;
+    private toastService;
+    private errorService;
+    private authRoutes;
+    form: FormGroup;
+    hidePassword: boolean;
+    private returnUrl;
+    constructor(fb: FormBuilder, authService: AuthService, router: Router, route: ActivatedRoute, toastService: ToastService, errorService: ErrorService, authRoutes: AuthRoutes);
+    togglePasswordVisibility(): void;
+    onSignIn(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoginComponent, "hw-login", never, {}, {}, never, never, true, never>;
+}
+
+declare class RegisterComponent {
+    private fb;
+    private authService;
+    private router;
+    private toastService;
+    private errorService;
+    private authRoutes;
+    form: FormGroup;
+    hidePassword: boolean;
+    constructor(fb: FormBuilder, authService: AuthService, router: Router, toastService: ToastService, errorService: ErrorService, authRoutes: AuthRoutes);
+    togglePasswordVisibility(): void;
+    private passwordsMatchValidator;
+    onRegister(): void;
+    showPasswordMismatch(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegisterComponent, "hw-register", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Phase 3.3 of the security review.
+ *
+ * The verification email links at this SPA route — `/verify?email=…&secret=…` —
+ * rather than at the API. The component:
+ *
+ *   1. Reads `email` and `secret` from the query string.
+ *   2. Immediately calls `AuthService.verify(email, secret)` (POST /api/verify).
+ *   3. Right after firing the request, scrubs the URL via
+ *      `history.replaceState({}, '', '/verify-success')` so the secret
+ *      stops appearing in the URL bar / browser history. We do this
+ *      synchronously, NOT inside the response callback, so the URL is
+ *      sanitized whether the request succeeds, fails, or is delayed.
+ *   4. On success or failure, routes to `/login` with a toast. The two
+ *      paths use different toasts but the toast text never echoes the
+ *      server's error detail — failed verifications all collapse to one
+ *      generic message to avoid distinguishing "wrong secret" from
+ *      "expired" from "already verified".
+ */
+declare class VerifyComponent implements OnInit {
+    private route;
+    private router;
+    private authService;
+    private toastService;
+    private authRoutes;
+    constructor(route: ActivatedRoute, router: Router, authService: AuthService, toastService: ToastService, authRoutes: AuthRoutes);
+    ngOnInit(): void;
+    private scrubUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerifyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VerifyComponent, "hw-verify", never, {}, {}, never, never, true, never>;
+}
+
+declare function tryTokenLoginInitializer(authService: AuthService): () => Promise<void>;
+
+export { AUTH_ROUTES, AdminGuard, AuthGuard, AuthService, DEFAULT_AUTH_ROUTES, DEFAULT_NON_AUTH_DATA, ErrorInterceptor, LoginComponent, ManageProductsGuard, NoAuthGuard, RegisterComponent, StaffGuard, VerifyComponent, hasManageProducts, hasPermission, hasStaffAccess, tryTokenLoginInitializer };
+export type { AuthData, AuthRoutes, ParsedHttpErrorResponse };

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

@@ -0,0 +1,136 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, EventEmitter, SimpleChanges, OnDestroy } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { ColumnDataInfo, ForeignKeyInfo, FkOption, CrudAccess } from '@honuware/ui/access';
+
+declare class SimpleTextComponent implements OnInit, OnChanges {
+    dataInfo?: ColumnDataInfo;
+    value?: string;
+    readOnly: boolean;
+    valueChanged: EventEmitter<string>;
+    textInput: FormControl;
+    isLoading: boolean;
+    private skipValueChanges;
+    get displayLabel(): string;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getValidators;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleTextComponent, "hw-simple-text", never, { "dataInfo": { "alias": "dataInfo"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+declare class LongTextComponent implements OnInit, OnChanges {
+    dataInfo?: ColumnDataInfo;
+    value?: string;
+    readOnly: boolean;
+    valueChanged: EventEmitter<string>;
+    textInput: FormControl;
+    isLoading: boolean;
+    private skipValueChanges;
+    get displayLabel(): string;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getValidators;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LongTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LongTextComponent, "hw-long-text", never, { "dataInfo": { "alias": "dataInfo"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+declare class SimpleBoolComponent implements OnInit, OnChanges {
+    dataInfo?: ColumnDataInfo;
+    value?: string;
+    readOnly: boolean;
+    checkboxValueChange: EventEmitter<string>;
+    checkboxControl: FormControl;
+    isLoading: boolean;
+    private skipValueChanges;
+    private isTrueValue;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private emitCheckboxValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleBoolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleBoolComponent, "hw-simple-bool", never, { "dataInfo": { "alias": "dataInfo"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; }, { "checkboxValueChange": "checkboxValueChange"; }, never, never, true, never>;
+}
+
+declare class SimpleEnumComponent implements OnInit, OnChanges {
+    dataInfo?: ColumnDataInfo;
+    value?: string;
+    readOnly: boolean;
+    enumValueChange: EventEmitter<string>;
+    selectControl: FormControl;
+    isLoading: boolean;
+    private skipValueChanges;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleEnumComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleEnumComponent, "hw-simple-enum", never, { "dataInfo": { "alias": "dataInfo"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; }, { "enumValueChange": "enumValueChange"; }, never, never, true, never>;
+}
+
+declare class SimpleDateComponent implements OnInit, OnChanges {
+    dataInfo?: ColumnDataInfo;
+    value?: string;
+    loading: boolean;
+    readOnly: boolean;
+    type: 'datetime' | 'date' | 'time';
+    timeIncrementMinutes: number;
+    valueChange: EventEmitter<string>;
+    dateControl: FormControl<any>;
+    private isMicrosecondInput;
+    private isBigIntColumn;
+    private parseInputValue;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleDateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleDateComponent, "hw-simple-date", never, { "dataInfo": { "alias": "dataInfo"; "required": false; }; "value": { "alias": "value"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "type": { "alias": "type"; "required": false; }; "timeIncrementMinutes": { "alias": "timeIncrementMinutes"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class FkPickerComponent implements OnInit, OnChanges, OnDestroy {
+    private serverAccess;
+    dataInfo?: ColumnDataInfo;
+    value?: string;
+    readOnly: boolean;
+    foreignKeyInfo?: ForeignKeyInfo;
+    preloadThreshold: number;
+    valueChanged: EventEmitter<string>;
+    searchControl: FormControl<string | null>;
+    filteredOptions: FkOption[];
+    isLoading: boolean;
+    resolvedDisplayText: string;
+    private selectedValue;
+    private skipValueChanges;
+    private searchSubject;
+    private subscriptions;
+    constructor(serverAccess: CrudAccess);
+    get displayLabel(): string;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    displayFn: (option: FkOption | string) => string;
+    onOptionSelected(event: {
+        option: {
+            value: FkOption;
+        };
+    }): void;
+    private setupSearch;
+    private loadInitialOptions;
+    private updateSearchControlFromValue;
+    private resolveDisplayText;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FkPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FkPickerComponent, "hw-fk-picker", never, { "dataInfo": { "alias": "dataInfo"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "foreignKeyInfo": { "alias": "foreignKeyInfo"; "required": false; }; "preloadThreshold": { "alias": "preloadThreshold"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+declare class CompositeControlComponent implements OnChanges {
+    dataInfo?: ColumnDataInfo;
+    value?: string;
+    readOnly: boolean;
+    foreignKeyInfo?: ForeignKeyInfo;
+    valueChanged: EventEmitter<string>;
+    isLoading: boolean;
+    activeComponent: 'text' | 'long-text' | 'bool' | 'date' | 'time' | 'enum' | 'fk' | null;
+    ngOnChanges(changes: SimpleChanges): void;
+    private determineActiveComponent;
+    onValueChanged(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompositeControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CompositeControlComponent, "hw-composite-control", never, { "dataInfo": { "alias": "dataInfo"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "foreignKeyInfo": { "alias": "foreignKeyInfo"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+export { CompositeControlComponent, FkPickerComponent, LongTextComponent, SimpleBoolComponent, SimpleDateComponent, SimpleEnumComponent, SimpleTextComponent };