@noatgnu/cupcake-core 1.0.0

package/index.d.ts

@@ -0,0 +1,1175 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit, ModuleWithProviders } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import * as i3 from '@angular/common/http';
+import { HttpClient, HttpParams, HttpInterceptorFn } from '@angular/common/http';
+import * as i4 from '@angular/router';
+import { CanActivateFn } from '@angular/router';
+import * as _noatgnu_cupcake_core from '@noatgnu/cupcake-core';
+import * as i2 from '@angular/forms';
+import { FormGroup } from '@angular/forms';
+import * as i1 from '@angular/common';
+import * as i5 from '@ng-bootstrap/ng-bootstrap';
+
+declare enum ResourceType {
+    METADATA_TABLE = "metadata_table",
+    METADATA_TABLE_TEMPLATE = "metadata_table_template",
+    METADATA_COLUMN_TEMPLATE = "metadata_column_template",
+    FILE = "file",
+    DATASET = "dataset",
+    SCHEMA = "schema"
+}
+declare const ResourceTypeLabels: Record<ResourceType, string>;
+declare enum ResourceVisibility {
+    PRIVATE = "private",
+    GROUP = "group",
+    PUBLIC = "public"
+}
+declare const ResourceVisibilityLabels: Record<ResourceVisibility, string>;
+declare enum ResourceRole {
+    OWNER = "owner",
+    ADMIN = "admin",
+    EDITOR = "editor",
+    VIEWER = "viewer"
+}
+declare const ResourceRoleLabels: Record<ResourceRole, string>;
+declare enum InvitationStatus {
+    PENDING = "pending",
+    ACCEPTED = "accepted",
+    REJECTED = "rejected",
+    EXPIRED = "expired",
+    CANCELLED = "cancelled"
+}
+declare const InvitationStatusLabels: Record<InvitationStatus, string>;
+
+interface BaseTimestampedModel {
+    createdAt: string;
+    updatedAt: string;
+}
+interface BaseResource extends BaseTimestampedModel {
+    id: number;
+    resourceType: ResourceType;
+    owner?: number;
+    labGroup?: number;
+    visibility: ResourceVisibility;
+    isActive: boolean;
+    isLocked: boolean;
+    canEdit?: boolean;
+    canView?: boolean;
+    canDelete?: boolean;
+}
+interface PaginatedResponse<T> {
+    count: number;
+    next?: string;
+    previous?: string;
+    results: T[];
+}
+interface ApiResponse<T = any> {
+    data?: T;
+    error?: any;
+    status: number;
+    success: boolean;
+}
+interface ResourceQueryParams {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    ordering?: string;
+    visibility?: ResourceVisibility;
+    owner?: number;
+    labGroup?: number;
+    includeInactive?: boolean;
+}
+
+interface SiteConfig extends BaseTimestampedModel {
+    siteName: string;
+    logoUrl?: string;
+    logoImage?: string;
+    primaryColor?: string;
+    showPoweredBy: boolean;
+    allowUserRegistration: boolean;
+    enableOrcidLogin: boolean;
+    installedApps: {
+        [appCode: string]: {
+            name: string;
+            code: string;
+            description: string;
+            installed: boolean;
+        };
+    };
+    updatedBy?: number;
+}
+interface SiteConfigUpdateRequest {
+    siteName?: string;
+    logoUrl?: string;
+    logoImage?: string;
+    primaryColor?: string;
+    showPoweredBy?: boolean;
+    allowUserRegistration?: boolean;
+    enableOrcidLogin?: boolean;
+}
+interface AuthConfig {
+    registrationEnabled: boolean;
+    orcidLoginEnabled: boolean;
+    regularLoginEnabled: boolean;
+}
+interface RegistrationStatus {
+    registrationEnabled: boolean;
+    message: string;
+}
+
+interface User {
+    id: number;
+    username: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    isStaff: boolean;
+    isSuperuser: boolean;
+    isActive: boolean;
+    dateJoined: string;
+    lastLogin?: string;
+    hasOrcid: boolean;
+    orcidId?: string;
+}
+interface UserCreateRequest {
+    username: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    password: string;
+    passwordConfirm: string;
+    isStaff?: boolean;
+    isSuperuser?: boolean;
+    isActive?: boolean;
+}
+interface UserRegistrationRequest {
+    username: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    password: string;
+    passwordConfirm: string;
+}
+interface UserOrcidProfile extends BaseTimestampedModel {
+    user: number;
+    userUsername?: string;
+    userEmail?: string;
+    orcidId: string;
+    orcidName?: string;
+    orcidEmail?: string;
+    verified: boolean;
+    linkedAt: string;
+}
+interface AccountMergeRequest extends BaseTimestampedModel {
+    id: number;
+    primaryUser: number;
+    primaryUserUsername?: string;
+    duplicateUser: number;
+    duplicateUserUsername?: string;
+    requestedBy: number;
+    requestedByUsername?: string;
+    reason?: string;
+    status: string;
+    reviewedBy?: number;
+    reviewedByUsername?: string;
+    adminNotes?: string;
+    completedAt?: string;
+}
+interface PasswordChangeRequest {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}
+interface UserProfileUpdateRequest {
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    currentPassword: string;
+}
+interface PasswordResetRequest {
+    email: string;
+}
+interface PasswordResetConfirmRequest {
+    token: string;
+    password: string;
+    passwordConfirm: string;
+}
+interface EmailChangeRequest {
+    newEmail: string;
+    currentPassword: string;
+}
+interface EmailChangeConfirmRequest {
+    token: string;
+}
+interface UserResponse {
+    user: User;
+    message?: string;
+}
+interface PasswordChangeResponse {
+    message: string;
+}
+interface AdminPasswordResetRequest {
+    userId: number;
+    newPassword: string;
+    confirmPassword: string;
+    forcePasswordChange?: boolean;
+    reason?: string;
+}
+interface EmailChangeConfirmResponse {
+    message: string;
+}
+interface UserListResponse {
+    count: number;
+    next?: string;
+    previous?: string;
+    results: User[];
+}
+
+interface LabGroup extends BaseTimestampedModel {
+    id: number;
+    name: string;
+    description?: string;
+    creator: number;
+    creatorName?: string;
+    isActive: boolean;
+    allowMemberInvites: boolean;
+    memberCount: number;
+    isCreator: boolean;
+    isMember: boolean;
+    canInvite: boolean;
+    canManage: boolean;
+}
+interface LabGroupInvitation extends BaseTimestampedModel {
+    id: number;
+    labGroup: number;
+    labGroupName?: string;
+    inviter: number;
+    inviterName?: string;
+    invitedUser?: number;
+    invitedEmail: string;
+    status: InvitationStatus;
+    message?: string;
+    invitationToken: string;
+    expiresAt: string;
+    respondedAt?: string;
+    canAccept: boolean;
+}
+interface LabGroupCreateRequest {
+    name: string;
+    description?: string;
+    allowMemberInvites?: boolean;
+}
+interface LabGroupUpdateRequest {
+    name?: string;
+    description?: string;
+    isActive?: boolean;
+    allowMemberInvites?: boolean;
+}
+interface LabGroupInviteRequest {
+    emails: string[];
+    message?: string;
+}
+interface InvitationResponseRequest {
+    accept: boolean;
+}
+interface LabGroupMember {
+    id: number;
+    username: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    isStaff: boolean;
+    isSuperuser: boolean;
+    isActive: boolean;
+    dateJoined: string;
+    lastLogin?: string;
+    hasOrcid: boolean;
+    orcidId?: string;
+}
+interface LabGroupQueryResponse {
+    count: number;
+    next?: string;
+    previous?: string;
+    results: LabGroup[];
+}
+interface LabGroupInvitationQueryResponse {
+    count: number;
+    next?: string;
+    previous?: string;
+    results: LabGroupInvitation[];
+}
+interface LabGroupInvitationCreateRequest {
+    labGroup: number;
+    invitedEmail: string;
+    message?: string;
+}
+
+interface AnnotationFolder extends BaseResource {
+    folderName: string;
+    parentFolder?: number;
+    isSharedDocumentFolder: boolean;
+    ownerName?: string;
+    fullPath?: string;
+    childFoldersCount: number;
+    annotationsCount: number;
+}
+interface Annotation extends BaseResource {
+    annotation: string;
+    annotationType: string;
+    file?: number;
+    fileUrl?: string;
+    fileSize?: number;
+    folder?: number;
+    folderPath?: string;
+    transcribed: boolean;
+    transcription?: string;
+    language?: string;
+    translation?: string;
+    scratched: boolean;
+    ownerName?: string;
+}
+interface AnnotationFolderCreateRequest {
+    folderName: string;
+    parentFolder?: number;
+    isSharedDocumentFolder?: boolean;
+    labGroup?: number;
+    visibility?: string;
+}
+interface AnnotationFolderUpdateRequest {
+    folderName?: string;
+    parentFolder?: number;
+    isSharedDocumentFolder?: boolean;
+    isActive?: boolean;
+}
+interface AnnotationCreateRequest {
+    annotation: string;
+    annotationType?: string;
+    file?: File;
+    folder?: number;
+    language?: string;
+    labGroup?: number;
+    visibility?: string;
+}
+interface AnnotationUpdateRequest {
+    annotation?: string;
+    annotationType?: string;
+    folder?: number;
+    transcribed?: boolean;
+    transcription?: string;
+    language?: string;
+    translation?: string;
+    scratched?: boolean;
+}
+
+interface ResourcePermission extends BaseTimestampedModel {
+    id: number;
+    user: number;
+    userUsername?: string;
+    userDisplayName?: string;
+    resourceContentType: number;
+    resourceTypeName?: string;
+    resourceModel?: string;
+    resourceObjectId: number;
+    role: ResourceRole;
+    grantedBy?: number;
+    grantedByUsername?: string;
+    grantedAt: string;
+}
+interface ResourcePermissionCreateRequest {
+    user: number;
+    resourceContentType: number;
+    resourceObjectId: number;
+    role: ResourceRole;
+}
+interface ResourcePermissionUpdateRequest {
+    role: ResourceRole;
+}
+interface BulkPermissionRequest {
+    users: number[];
+    role: ResourceRole;
+    resourceContentType: number;
+    resourceObjectId: number;
+}
+
+interface RemoteHost extends BaseTimestampedModel {
+    id: number;
+    hostName: string;
+    hostPort: number;
+    hostProtocol: string;
+    hostDescription?: string;
+    hostToken?: string;
+}
+interface RemoteHostCreateRequest {
+    hostName: string;
+    hostPort?: number;
+    hostProtocol?: string;
+    hostDescription?: string;
+    hostToken?: string;
+}
+interface RemoteHostUpdateRequest {
+    hostName?: string;
+    hostPort?: number;
+    hostProtocol?: string;
+    hostDescription?: string;
+    hostToken?: string;
+}
+
+interface CupcakeCoreConfig {
+    apiUrl: string;
+}
+declare const CUPCAKE_CORE_CONFIG: InjectionToken<CupcakeCoreConfig>;
+interface AuthResponse {
+    accessToken: string;
+    refreshToken: string;
+    user: User;
+}
+interface AuthStatus {
+    authenticated: boolean;
+    user?: User;
+}
+declare class AuthService {
+    private http;
+    private config;
+    private apiUrl;
+    private currentUserSubject;
+    currentUser$: Observable<User | null>;
+    private isAuthenticatedSubject;
+    isAuthenticated$: Observable<boolean>;
+    constructor();
+    private hasValidTokenOnInit;
+    private initializeAuthState;
+    private isTokenExpired;
+    getUserFromToken(): User | null;
+    initiateORCIDLogin(): Observable<{
+        authorizationUrl: string;
+        state: string;
+    }>;
+    handleORCIDCallback(code: string, state: string): Observable<AuthResponse>;
+    exchangeORCIDToken(accessToken: string, orcidId: string): Observable<AuthResponse>;
+    login(username: string, password: string): Observable<AuthResponse>;
+    logout(): Observable<any>;
+    checkAuthStatus(): Observable<AuthStatus>;
+    fetchUserProfile(): Observable<User>;
+    getCurrentUser(): User | null;
+    isAuthenticated(): boolean;
+    getAccessToken(): string | null;
+    getRefreshToken(): string | null;
+    private setAuthData;
+    tryRefreshToken(): Observable<{
+        access: string;
+    }>;
+    refreshToken(): Observable<{
+        access: string;
+    }>;
+    updateAuthStateAfterRefresh(): void;
+    private clearAuthData;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AuthService>;
+}
+
+declare class ApiService {
+    private http;
+    private config;
+    private apiUrl;
+    private resourceService;
+    constructor(http: HttpClient);
+    /**
+     * Transform camelCase object to snake_case for API requests
+     */
+    private transformToSnakeCase;
+    /**
+     * Transform snake_case object to camelCase for TypeScript interfaces
+     */
+    private transformToCamelCase;
+    /**
+     * Make HTTP GET request with automatic snake_case to camelCase transformation
+     */
+    get<T>(url: string, options?: any): Observable<T>;
+    /**
+     * Make HTTP POST request with automatic camelCase to snake_case transformation
+     */
+    post<T>(url: string, body: any, options?: any): Observable<T>;
+    /**
+     * Make HTTP PUT request with automatic camelCase to snake_case transformation
+     */
+    put<T>(url: string, body: any, options?: any): Observable<T>;
+    /**
+     * Make HTTP PATCH request with automatic camelCase to snake_case transformation
+     */
+    patch<T>(url: string, body: any, options?: any): Observable<T>;
+    /**
+     * Make HTTP DELETE request with automatic snake_case to camelCase transformation
+     */
+    delete<T>(url: string, options?: any): Observable<T>;
+    getUserProfile(): Observable<{
+        user: any;
+    }>;
+    getSiteConfig(): Observable<SiteConfig[]>;
+    updateSiteConfig(id: number, config: Partial<SiteConfig>): Observable<SiteConfig>;
+    getUsers(params?: {
+        isStaff?: boolean;
+        isActive?: boolean;
+        search?: string;
+        page?: number;
+        pageSize?: number;
+    }): Observable<UserListResponse>;
+    getUser(id: number): Observable<User>;
+    createUser(userData: UserCreateRequest): Observable<UserResponse>;
+    updateUser(id: number, userData: Partial<User>): Observable<User>;
+    deleteUser(id: number): Observable<void>;
+    registerUser(userData: UserRegistrationRequest): Observable<UserResponse>;
+    getAuthConfig(): Observable<AuthConfig>;
+    getRegistrationStatus(): Observable<RegistrationStatus>;
+    changePassword(passwordData: PasswordChangeRequest): Observable<PasswordChangeResponse>;
+    updateProfile(profileData: UserProfileUpdateRequest): Observable<UserResponse>;
+    requestEmailChange(emailData: EmailChangeRequest): Observable<{
+        message: string;
+        new_email: string;
+    }>;
+    confirmEmailChange(confirmData: EmailChangeConfirmRequest): Observable<{
+        message: string;
+    }>;
+    resetUserPassword(userId: number, passwordData: AdminPasswordResetRequest): Observable<PasswordChangeResponse>;
+    requestPasswordReset(resetData: PasswordResetRequest): Observable<PasswordChangeResponse>;
+    confirmPasswordReset(confirmData: PasswordResetConfirmRequest): Observable<PasswordChangeResponse>;
+    linkOrcid(orcidData: {
+        orcidId: string;
+        verificationCode?: string;
+    }): Observable<any>;
+    unlinkOrcid(): Observable<PasswordChangeResponse>;
+    detectDuplicateAccounts(searchData: {
+        email?: string;
+        orcidId?: string;
+        firstName?: string;
+        lastName?: string;
+    }): Observable<any>;
+    requestAccountMerge(mergeData: {
+        duplicateUserId: number;
+        reason: string;
+    }): Observable<any>;
+    getAnnotationFolders(params?: {
+        search?: string;
+        parentFolder?: number;
+        isSharedDocumentFolder?: boolean;
+        labGroup?: number;
+        limit?: number;
+        offset?: number;
+    }): Observable<{
+        count: number;
+        results: AnnotationFolder[];
+    }>;
+    getAnnotationFolder(id: number): Observable<AnnotationFolder>;
+    createAnnotationFolder(folderData: AnnotationFolderCreateRequest): Observable<AnnotationFolder>;
+    updateAnnotationFolder(id: number, folderData: AnnotationFolderUpdateRequest): Observable<AnnotationFolder>;
+    deleteAnnotationFolder(id: number): Observable<void>;
+    getAnnotations(params?: {
+        search?: string;
+        annotationType?: string;
+        folder?: number;
+        transcribed?: boolean;
+        scratched?: boolean;
+        labGroup?: number;
+        limit?: number;
+        offset?: number;
+    }): Observable<{
+        count: number;
+        results: Annotation[];
+    }>;
+    getAnnotation(id: number): Observable<Annotation>;
+    createAnnotation(annotationData: AnnotationCreateRequest): Observable<Annotation>;
+    updateAnnotation(id: number, annotationData: AnnotationUpdateRequest): Observable<Annotation>;
+    deleteAnnotation(id: number): Observable<void>;
+    getResourcePermissions(params?: {
+        user?: number;
+        resourceContentType?: number;
+        resourceObjectId?: number;
+        role?: string;
+        limit?: number;
+        offset?: number;
+    }): Observable<{
+        count: number;
+        results: ResourcePermission[];
+    }>;
+    getResourcePermission(id: number): Observable<ResourcePermission>;
+    createResourcePermission(permissionData: ResourcePermissionCreateRequest): Observable<ResourcePermission>;
+    updateResourcePermission(id: number, permissionData: ResourcePermissionUpdateRequest): Observable<ResourcePermission>;
+    deleteResourcePermission(id: number): Observable<void>;
+    createBulkPermissions(bulkData: BulkPermissionRequest): Observable<{
+        created: ResourcePermission[];
+        errors: any[];
+    }>;
+    getResourcePermissionsByResource(resourceContentType: number, resourceObjectId: number): Observable<ResourcePermission[]>;
+    getRemoteHosts(params?: {
+        search?: string;
+        hostName?: string;
+        hostProtocol?: string;
+        limit?: number;
+        offset?: number;
+    }): Observable<{
+        count: number;
+        results: RemoteHost[];
+    }>;
+    getRemoteHost(id: number): Observable<RemoteHost>;
+    createRemoteHost(hostData: RemoteHostCreateRequest): Observable<RemoteHost>;
+    updateRemoteHost(id: number, hostData: RemoteHostUpdateRequest): Observable<RemoteHost>;
+    deleteRemoteHost(id: number): Observable<void>;
+    testRemoteHostConnection(id: number): Observable<{
+        success: boolean;
+        message: string;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ApiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ApiService>;
+}
+
+/**
+ * Base API service with systematic case transformation
+ * All other API services should extend this to get automatic snake_case <-> camelCase conversion
+ */
+declare class BaseApiService {
+    protected http: HttpClient;
+    private config;
+    protected apiUrl: string;
+    /**
+     * Transform camelCase object to snake_case for API requests
+     */
+    protected transformToSnakeCase(obj: any): any;
+    /**
+     * Transform snake_case object to camelCase for TypeScript interfaces
+     */
+    protected transformToCamelCase(obj: any): any;
+    /**
+     * Make HTTP GET request with automatic snake_case to camelCase transformation
+     */
+    protected get<T>(url: string, options?: any): Observable<T>;
+    /**
+     * Make HTTP POST request with automatic camelCase to snake_case transformation
+     */
+    protected post<T>(url: string, body: any, options?: any): Observable<T>;
+    /**
+     * Make HTTP PUT request with automatic camelCase to snake_case transformation
+     */
+    protected put<T>(url: string, body: any, options?: any): Observable<T>;
+    /**
+     * Make HTTP PATCH request with automatic camelCase to snake_case transformation
+     */
+    protected patch<T>(url: string, body: any, options?: any): Observable<T>;
+    /**
+     * Make HTTP DELETE request with automatic snake_case to camelCase transformation
+     */
+    protected delete<T>(url: string, options?: any): Observable<T>;
+    /**
+     * Build HttpParams from query parameters object with automatic case transformation
+     */
+    protected buildHttpParams(params: any): HttpParams;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseApiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BaseApiService>;
+}
+
+declare class SiteConfigService extends BaseApiService {
+    private readonly defaultConfig;
+    private configSubject;
+    config$: Observable<SiteConfig>;
+    constructor();
+    private loadConfig;
+    private fetchConfigFromBackend;
+    getCurrentConfig(): Observable<SiteConfig>;
+    updateConfig(config: Partial<SiteConfig>): Observable<SiteConfig>;
+    getSiteName(): string;
+    shouldShowPoweredBy(): boolean;
+    getLogoUrl(): string | null;
+    getPrimaryColor(): string;
+    isRegistrationEnabled(): boolean;
+    isOrcidLoginEnabled(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiteConfigService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SiteConfigService>;
+}
+
+interface ToastMessage {
+    id: string;
+    message: string;
+    type: 'success' | 'error' | 'warning' | 'info';
+    duration?: number;
+    dismissible?: boolean;
+}
+declare class ToastService {
+    private toastsSignal;
+    readonly toasts: _angular_core.Signal<ToastMessage[]>;
+    show(message: string, type?: 'success' | 'error' | 'warning' | 'info', duration?: number): void;
+    success(message: string, duration?: number): void;
+    error(message: string, duration?: number): void;
+    warning(message: string, duration?: number): void;
+    info(message: string, duration?: number): void;
+    remove(id: string): void;
+    clear(): void;
+    private generateId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ToastService>;
+}
+
+declare class UserManagementService {
+    private apiService;
+    private authService;
+    private usersSubject;
+    users$: Observable<User[]>;
+    private totalUsersSubject;
+    totalUsers$: Observable<number>;
+    constructor();
+    getUserProfile(): Observable<{
+        user: User;
+    }>;
+    updateProfile(profileData: UserProfileUpdateRequest): Observable<UserResponse>;
+    changePassword(passwordData: PasswordChangeRequest): Observable<{
+        message: string;
+    }>;
+    requestEmailChange(emailData: EmailChangeRequest): Observable<{
+        message: string;
+        new_email: string;
+    }>;
+    getUsers(params?: {
+        isStaff?: boolean;
+        isActive?: boolean;
+        search?: string;
+        page?: number;
+        pageSize?: number;
+    }): Observable<PaginatedResponse<User>>;
+    getUser(id: number): Observable<User>;
+    createUser(userData: UserCreateRequest): Observable<UserResponse>;
+    updateUser(id: number, userData: Partial<User>): Observable<User>;
+    deleteUser(id: number): Observable<void>;
+    resetUserPassword(userId: number, passwordData: AdminPasswordResetRequest): Observable<PasswordChangeResponse>;
+    getUserDisplayName(user: User | null): string;
+    formatDate(dateString?: string): string;
+    isCurrentUserAdmin(): boolean;
+    isCurrentUserSuperuser(): boolean;
+    updateUsersState(users: User[], total: number): void;
+    getCurrentUsers(): User[];
+    getCurrentTotalUsers(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserManagementService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UserManagementService>;
+}
+
+declare class ResourceService {
+    convertLegacyVisibility(isPublic: boolean | undefined, isDefault?: boolean): ResourceVisibility;
+    convertToLegacyVisibility(visibility: ResourceVisibility): boolean;
+    getVisibilityLabel(visibility: ResourceVisibility): string;
+    getRoleLabel(role: ResourceRole): string;
+    canPerformAction(resource: BaseResource, action: 'view' | 'edit' | 'delete' | 'share'): boolean;
+    getVisibilityOptions(): Array<{
+        value: ResourceVisibility;
+        label: string;
+        description: string;
+    }>;
+    getRoleOptions(): Array<{
+        value: ResourceRole;
+        label: string;
+        description: string;
+    }>;
+    transformLegacyResource<T extends Partial<BaseResource>>(legacyData: any): T;
+    prepareForAPI<T extends Record<string, any>>(resourceData: T): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourceService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ResourceService>;
+}
+
+interface LabGroupQueryParams {
+    search?: string;
+    limit?: number;
+    offset?: number;
+}
+interface LabGroupInvitationQueryParams {
+    labGroup?: number;
+    status?: string;
+    limit?: number;
+    offset?: number;
+}
+declare class LabGroupService extends BaseApiService {
+    getLabGroups(params?: LabGroupQueryParams): Observable<LabGroupQueryResponse>;
+    getMyLabGroups(params?: LabGroupQueryParams): Observable<LabGroupQueryResponse>;
+    createLabGroup(labGroup: LabGroupCreateRequest): Observable<LabGroup>;
+    updateLabGroup(id: number, labGroup: Partial<LabGroup>): Observable<LabGroup>;
+    deleteLabGroup(id: number): Observable<void>;
+    getLabGroupMembers(id: number): Observable<LabGroupMember[]>;
+    inviteUserToLabGroup(id: number, invitation: LabGroupInvitationCreateRequest): Observable<LabGroupInvitation>;
+    leaveLabGroup(id: number): Observable<{
+        message: string;
+    }>;
+    removeMemberFromLabGroup(id: number, userId: number): Observable<{
+        message: string;
+    }>;
+    getLabGroupInvitations(params?: LabGroupInvitationQueryParams): Observable<LabGroupInvitationQueryResponse>;
+    getMyPendingInvitations(): Observable<LabGroupInvitation[]>;
+    acceptLabGroupInvitation(id: number): Observable<{
+        message: string;
+        invitation: LabGroupInvitation;
+    }>;
+    rejectLabGroupInvitation(id: number): Observable<{
+        message: string;
+        invitation: LabGroupInvitation;
+    }>;
+    cancelLabGroupInvitation(id: number): Observable<{
+        message: string;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LabGroupService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LabGroupService>;
+}
+
+declare const authGuard: CanActivateFn;
+
+declare const adminGuard: CanActivateFn;
+
+declare const authInterceptor: HttpInterceptorFn;
+
+declare class LoginComponent implements OnInit {
+    private authService;
+    private fb;
+    private router;
+    private route;
+    private siteConfigService;
+    private apiService;
+    loginForm: FormGroup;
+    loading: _angular_core.WritableSignal<boolean>;
+    error: _angular_core.WritableSignal<string | null>;
+    success: _angular_core.WritableSignal<string | null>;
+    siteConfig$: rxjs.Observable<_noatgnu_cupcake_core.SiteConfig>;
+    authConfig: _angular_core.WritableSignal<AuthConfig | null>;
+    registrationStatus: _angular_core.WritableSignal<RegistrationStatus | null>;
+    constructor();
+    private returnUrl;
+    ngOnInit(): void;
+    /**
+     * Load authentication configuration to determine available login options
+     */
+    private loadAuthConfig;
+    /**
+     * Handle traditional username/password login
+     */
+    onSubmit(): void;
+    /**
+     * Initiate ORCID OAuth login
+     */
+    loginWithORCID(): void;
+    /**
+     * Handle ORCID OAuth callback
+     */
+    private handleORCIDCallback;
+    /**
+     * Clear error message
+     */
+    clearError(): void;
+    /**
+     * Clear success message
+     */
+    clearSuccess(): void;
+    /**
+     * Computed signals for UI display logic
+     */
+    shouldShowOrcidLogin: _angular_core.Signal<boolean>;
+    shouldShowRegistration: _angular_core.Signal<boolean>;
+    shouldShowRegularLogin: _angular_core.Signal<boolean>;
+    registrationMessage: _angular_core.Signal<string>;
+    /**
+     * Navigate to registration page
+     */
+    goToRegister(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoginComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoginComponent, "app-login", never, {}, {}, never, never, true, never>;
+}
+
+declare class RegisterComponent implements OnInit {
+    private apiService;
+    private fb;
+    private router;
+    private route;
+    private siteConfigService;
+    registrationForm: FormGroup;
+    loading: _angular_core.WritableSignal<boolean>;
+    error: _angular_core.WritableSignal<string | null>;
+    success: _angular_core.WritableSignal<string | null>;
+    siteConfig$: rxjs.Observable<_noatgnu_cupcake_core.SiteConfig>;
+    registrationStatus: _angular_core.WritableSignal<RegistrationStatus | null>;
+    registrationEnabled: _angular_core.WritableSignal<boolean>;
+    private returnUrl;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Check if registration is enabled
+     */
+    private checkRegistrationStatus;
+    /**
+     * Custom validator to check if passwords match
+     */
+    private passwordMatchValidator;
+    /**
+     * Handle form submission
+     */
+    onSubmit(): void;
+    /**
+     * Navigate back to login
+     */
+    goToLogin(): void;
+    /**
+     * Clear error message
+     */
+    clearError(): void;
+    /**
+     * Clear success message
+     */
+    clearSuccess(): void;
+    /**
+     * Get field error message
+     */
+    getFieldErrorMessage(fieldName: string): string | null;
+    /**
+     * Get user-friendly field display name
+     */
+    private getFieldDisplayName;
+    /**
+     * Check if a field has errors and should display error styling
+     */
+    hasFieldError(fieldName: string): boolean;
+    /**
+     * Computed signals for UI display logic
+     */
+    isRegistrationDisabled: _angular_core.Signal<boolean>;
+    canSubmitForm: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RegisterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RegisterComponent, "app-register", never, {}, {}, never, never, true, never>;
+}
+
+declare class UserManagementComponent implements OnInit {
+    private fb;
+    private userManagementService;
+    private authService;
+    private modalService;
+    users: _angular_core.WritableSignal<User[]>;
+    totalUsers: _angular_core.WritableSignal<number>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    searchForm: FormGroup;
+    searchTerm: _angular_core.WritableSignal<string>;
+    staffFilter: _angular_core.WritableSignal<string>;
+    activeFilter: _angular_core.WritableSignal<string>;
+    currentPage: _angular_core.WritableSignal<number>;
+    pageSize: _angular_core.WritableSignal<number>;
+    selectedUser: _angular_core.WritableSignal<User | null>;
+    isCreatingUser: _angular_core.WritableSignal<boolean>;
+    isUpdatingUser: _angular_core.WritableSignal<boolean>;
+    isDeletingUser: _angular_core.WritableSignal<boolean>;
+    isResettingPassword: _angular_core.WritableSignal<boolean>;
+    successMessage: _angular_core.WritableSignal<string>;
+    errorMessage: _angular_core.WritableSignal<string>;
+    Math: Math;
+    totalPages: _angular_core.Signal<number>;
+    pages: _angular_core.Signal<number[]>;
+    showingFrom: _angular_core.Signal<number>;
+    showingTo: _angular_core.Signal<number>;
+    hasResults: _angular_core.Signal<boolean>;
+    canGoToPreviousPage: _angular_core.Signal<boolean>;
+    canGoToNextPage: _angular_core.Signal<boolean>;
+    isAnyActionInProgress: _angular_core.Signal<boolean>;
+    selectedUserDisplayName: _angular_core.Signal<string>;
+    hasSelectedUser: _angular_core.Signal<boolean>;
+    canCreateUser: _angular_core.Signal<boolean>;
+    canUpdateUser: _angular_core.Signal<boolean>;
+    canResetPassword: _angular_core.Signal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    loadUsers(): void;
+    openCreateUserModal(content: any): void;
+    openEditUserModal(content: any, user: User): void;
+    openPasswordResetModal(content: any, user: User): void;
+    createUser(userData: UserCreateRequest): void;
+    updateUser(userId: number, userData: Partial<User>): void;
+    deleteUser(user: User): void;
+    resetUserPassword(userId: number, passwordData: AdminPasswordResetRequest): void;
+    toggleUserStatus(user: User): void;
+    toggleStaffStatus(user: User): void;
+    onPageChange(page: number): void;
+    clearMessages(): void;
+    formatDate(dateString?: string): string;
+    getUserDisplayName(user: User): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserManagementComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserManagementComponent, "app-user-management", never, {}, {}, never, never, true, never>;
+}
+
+declare class LabGroupsComponent implements OnInit {
+    private readonly fb;
+    private readonly labGroupService;
+    private readonly modalService;
+    private readonly toastService;
+    searchForm: FormGroup;
+    createGroupForm: FormGroup;
+    inviteForm: FormGroup;
+    private searchParams;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    isCreatingGroup: _angular_core.WritableSignal<boolean>;
+    isInviting: _angular_core.WritableSignal<boolean>;
+    currentPage: _angular_core.WritableSignal<number>;
+    pageSize: _angular_core.WritableSignal<number>;
+    totalItems: _angular_core.WritableSignal<number>;
+    labGroupsData: _angular_core.WritableSignal<LabGroupQueryResponse>;
+    selectedGroup: _angular_core.WritableSignal<LabGroup | null>;
+    groupMembers: _angular_core.WritableSignal<LabGroupMember[]>;
+    pendingInvitations: _angular_core.WritableSignal<LabGroupInvitation[]>;
+    showCreateForm: _angular_core.WritableSignal<boolean>;
+    showInviteForm: _angular_core.WritableSignal<boolean>;
+    selectedGroupForMembers: _angular_core.WritableSignal<LabGroup | null>;
+    hasLabGroups: _angular_core.Signal<boolean>;
+    showPagination: _angular_core.Signal<boolean>;
+    totalPages: _angular_core.Signal<number>;
+    hasSearchValue: _angular_core.Signal<boolean>;
+    hasGroupMembers: _angular_core.Signal<boolean>;
+    hasPendingInvitations: _angular_core.Signal<boolean>;
+    canInviteToCurrentGroup: _angular_core.Signal<boolean>;
+    canManageCurrentGroup: _angular_core.Signal<boolean>;
+    currentGroupName: _angular_core.Signal<string>;
+    groupMembersCount: _angular_core.Signal<number>;
+    pendingInvitationsCount: _angular_core.Signal<number>;
+    constructor();
+    ngOnInit(): void;
+    private loadInitialData;
+    private setupSearch;
+    private loadLabGroupsWithParams;
+    onPageChange(page: number): void;
+    toggleCreateForm(): void;
+    createLabGroup(): void;
+    viewGroupMembers(group: LabGroup): void;
+    private loadGroupMembers;
+    private loadPendingInvitations;
+    toggleInviteForm(): void;
+    inviteMember(): void;
+    removeMember(userId: number): void;
+    cancelInvitation(invitationId: number): void;
+    leaveGroup(group: LabGroup): void;
+    deleteGroup(group: LabGroup): void;
+    private refreshLabGroups;
+    closeGroupDetails(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LabGroupsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LabGroupsComponent, "app-lab-groups", never, {}, {}, never, never, true, never>;
+}
+
+declare class UserProfileComponent implements OnInit {
+    private fb;
+    private userManagementService;
+    private authService;
+    currentUser: _angular_core.WritableSignal<User | null>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    profileForm: FormGroup;
+    passwordForm: FormGroup;
+    emailChangeForm: FormGroup;
+    activeTab: _angular_core.WritableSignal<"password" | "email" | "profile" | "account">;
+    isUpdatingProfile: _angular_core.WritableSignal<boolean>;
+    isChangingPassword: _angular_core.WritableSignal<boolean>;
+    isChangingEmail: _angular_core.WritableSignal<boolean>;
+    profileMessage: _angular_core.WritableSignal<string>;
+    passwordMessage: _angular_core.WritableSignal<string>;
+    emailMessage: _angular_core.WritableSignal<string>;
+    errorMessage: _angular_core.WritableSignal<string>;
+    fullName: _angular_core.Signal<string>;
+    isStaff: _angular_core.Signal<boolean>;
+    joinDate: _angular_core.Signal<string>;
+    lastLogin: _angular_core.Signal<string>;
+    constructor();
+    ngOnInit(): void;
+    loadUserProfile(): void;
+    updateProfile(): void;
+    changePassword(): void;
+    requestEmailChange(): void;
+    setActiveTab(tab: 'profile' | 'password' | 'email' | 'account'): void;
+    private passwordMatchValidator;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserProfileComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserProfileComponent, "app-user-profile", never, {}, {}, never, never, true, never>;
+}
+
+declare class SiteConfigComponent implements OnInit {
+    private fb;
+    private siteConfigService;
+    configForm: FormGroup;
+    loading: _angular_core.WritableSignal<boolean>;
+    error: _angular_core.WritableSignal<string | null>;
+    success: _angular_core.WritableSignal<string | null>;
+    selectedLogoFile: _angular_core.WritableSignal<File | null>;
+    currentConfig: _angular_core.WritableSignal<SiteConfig | null>;
+    previewConfig: _angular_core.Signal<any>;
+    presetColors: string[];
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Update site configuration
+     */
+    onSubmit(): void;
+    /**
+     * Reset form to current configuration
+     */
+    resetForm(): void;
+    /**
+     * Handle color change from ngx-color picker
+     */
+    onColorChange(event: any): void;
+    /**
+     * Get a darker version of the given color for gradients
+     */
+    getDarkerColor(hex: string): string;
+    /**
+     * Get the current primary color value for styling
+     */
+    getCurrentPrimaryColor(): string;
+    /**
+     * Clear error message
+     */
+    clearError(): void;
+    /**
+     * Clear success message
+     */
+    clearSuccess(): void;
+    /**
+     * Handle logo file selection
+     */
+    onLogoFileSelected(event: Event): void;
+    /**
+     * Remove selected logo file
+     */
+    clearLogoFile(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiteConfigComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiteConfigComponent, "app-site-config", never, {}, {}, never, never, true, never>;
+}
+
+declare class ToastContainerComponent {
+    private toastService;
+    /**
+     * Signal containing all active toast messages
+     */
+    toasts: _angular_core.Signal<ToastMessage[]>;
+    /**
+     * Computed signal that maps toast types to their CSS classes
+     */
+    private toastClassMap;
+    /**
+     * Computed signal that maps toast types to their Bootstrap icons
+     */
+    private toastIconMap;
+    /**
+     * Removes a toast message from the service
+     */
+    remove(toast: ToastMessage): void;
+    /**
+     * Gets the CSS class for a toast based on its type
+     */
+    getToastClass(type: string): string;
+    /**
+     * Gets the Bootstrap icon class for a toast based on its type
+     */
+    getToastIcon(type: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToastContainerComponent, "app-toast-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class CupcakeCoreModule {
+    static forRoot(config: CupcakeCoreConfig): ModuleWithProviders<CupcakeCoreModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CupcakeCoreModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CupcakeCoreModule, never, [typeof i1.CommonModule, typeof i2.ReactiveFormsModule, typeof i3.HttpClientModule, typeof i4.RouterModule, typeof i5.NgbModule, typeof LoginComponent, typeof RegisterComponent, typeof ToastContainerComponent], [typeof LoginComponent, typeof RegisterComponent, typeof ToastContainerComponent, typeof i1.CommonModule, typeof i2.ReactiveFormsModule, typeof i5.NgbModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CupcakeCoreModule>;
+}
+
+export { ApiService, AuthService, BaseApiService, CUPCAKE_CORE_CONFIG, CupcakeCoreModule, InvitationStatus, InvitationStatusLabels, LabGroupService, LabGroupsComponent, LoginComponent, RegisterComponent, ResourceRole, ResourceRoleLabels, ResourceService, ResourceType, ResourceTypeLabels, ResourceVisibility, ResourceVisibilityLabels, SiteConfigComponent, SiteConfigService, ToastContainerComponent, ToastService, UserManagementComponent, UserManagementService, UserProfileComponent, adminGuard, authGuard, authInterceptor };
+export type { AccountMergeRequest, AdminPasswordResetRequest, Annotation, AnnotationCreateRequest, AnnotationFolder, AnnotationFolderCreateRequest, AnnotationFolderUpdateRequest, AnnotationUpdateRequest, ApiResponse, AuthConfig, AuthResponse, AuthStatus, BaseResource, BaseTimestampedModel, BulkPermissionRequest, CupcakeCoreConfig, EmailChangeConfirmRequest, EmailChangeConfirmResponse, EmailChangeRequest, InvitationResponseRequest, LabGroup, LabGroupCreateRequest, LabGroupInvitation, LabGroupInvitationCreateRequest, LabGroupInvitationQueryParams, LabGroupInvitationQueryResponse, LabGroupInviteRequest, LabGroupMember, LabGroupQueryParams, LabGroupQueryResponse, LabGroupUpdateRequest, PaginatedResponse, PasswordChangeRequest, PasswordChangeResponse, PasswordResetConfirmRequest, PasswordResetRequest, RegistrationStatus, RemoteHost, RemoteHostCreateRequest, RemoteHostUpdateRequest, ResourcePermission, ResourcePermissionCreateRequest, ResourcePermissionUpdateRequest, ResourceQueryParams, SiteConfig, SiteConfigUpdateRequest, ToastMessage, User, UserCreateRequest, UserListResponse, UserOrcidProfile, UserProfileUpdateRequest, UserRegistrationRequest, UserResponse };