cat-documents-ng 1.0.2 → 1.0.4

package/lib/document/services/document-http.service.d.ts

@@ -0,0 +1,179 @@
+import { Observable } from 'rxjs';
+import { AppConfigService } from '../../../Shared/services/app-config.service';
+import { DocumentStore } from '../state/document.store';
+import { HttpClient } from '@angular/common/http';
+import { DocumentTypeModel } from '../models/document-type.model';
+import { DocumentAlertModel } from '../models/document-alert.model';
+import { DocumentModel } from '../models/document.model';
+import { FolderBlockModel } from '../models/folder.model';
+import { DocumentCategory } from '../models/document-category.model';
+import { UserListModel } from '../models/user-list.model';
+import { StatusDataModel } from '../models/status-data.model';
+import { DocumentHistorySection } from '../models/document-history.model';
+import * as i0 from "@angular/core";
+/**
+ * Service for making HTTP requests related to documents.
+ * Authentication is handled automatically by the HTTP interceptor in the main project.
+ * @class DocumentHttpService
+ * @typedef {DocumentHttpService}
+ */
+export declare class DocumentHttpService {
+    documentStore: DocumentStore;
+    private http;
+    appConfigService: AppConfigService;
+    /**
+     * Creates an instance of DocumentService.
+     * @param {DocumentStore} documentStore - Store managing the state of documents.
+     * @param {HttpClient} http - Angular HTTP client for making API requests.
+     * @param {AppConfigService} appConfigService - Service for retrieving application configuration, such as API base URL.
+     */
+    constructor(documentStore: DocumentStore, http: HttpClient, appConfigService: AppConfigService);
+    /**
+     * Get api url from appConfigService.
+     * @readonly
+     * @type {string}
+     */
+    get apiUrl(): string;
+    /**
+     * Fetches a document by its path name and transforms the response for dropdown options.
+     * Includes error handling for failed API requests.
+     * @param {string} contextId - The context ID to fetch the document.
+     * @returns {Observable<any>} Observable that emits the transformed data for dropdown options.
+     */
+    getFoldersData(contextId: string | undefined): Observable<FolderBlockModel[]>;
+    /**
+     * Fetches a document catagories by its path name.
+     * Includes error handling for failed API requests.
+     * @param {string} contextId - The context ID to fetch the document.
+     * @returns {Observable<any>} Observable that emits the transformed data for dropdown options.
+     */
+    getDocumentCatagories(contextId: string): Observable<any>;
+    /**
+     * Fetches a document by its path name and transforms the response for dropdown options.
+     * Includes error handling for failed API requests.
+     * @returns {Observable<any>} Observable that emits the transformed data for dropdown options.
+      */
+    /**
+     * Fetches a document by its path name and transforms the response for dropdown options.
+     * @param {string} documentId - The document ID to fetch the document.
+     * @returns {Observable<any>} Observable that emits the transformed data for dropdown options.
+    */
+    getAlertsByDocumentID(documentId: string): Observable<DocumentAlertModel>;
+    /**
+     * Fetches a document by its folder ID and transforms the response for dropdown options.
+     * @param {string} folderId - The folder ID to fetch the document.
+     * @param {string} contextId - The context ID to fetch the document.
+     * @returns {Observable<any>} Observable that emits the transformed data for dropdown options.
+    */
+    getDocumentByFolderID(folderId: string, contextId: string): Observable<DocumentModel[]>;
+    /**
+     * Updates the name of a document.
+     * This method sends an HTTP PUT request to update the document's file name using the provided document ID and payload.
+     * In case of an error, it will return an observable that throws an Error.
+     * @param {string} documentId - The unique identifier of the document to update.
+     * @param {any} payload - The payload containing the updated document data (e.g., fileName).
+     * @returns {Observable<DocumentModel>} An observable that emits the updated DocumentModel.
+     */
+    updateDocumentName(documentId: string, payload: any): Observable<DocumentModel>;
+    /**
+    * Fetches a userlist by its path name.
+    * @param {string} contextId - The document ID to fetch the document.
+    * @returns {Observable<UserListModel[]>} Observable that emits the user list data.
+    */
+    getUserListByContextId(contextId: string): Observable<UserListModel[]>;
+    /**
+     * Fetches document status count data by application ID with optional context ID and category parameters.
+     * @param {string} applicationId - The application ID to fetch status data.
+     * @param {string | null} contextId - The context ID (applicant ID) to filter by. If null, uses applicationId.
+     * @param {string | null} categoryId - The category ID to filter by.
+     * @returns {Observable<StatusDataModel[]>} Observable that emits the status data.
+     */
+    getStatusDocumentCount(applicationId: string, contextId?: string | null, categoryId?: string | null): Observable<StatusDataModel[]>;
+    /**
+     * Fetches documents based on selection criteria (user ID, status, and search key).
+     * This method sends an HTTP GET request with query parameters for the selected filters.
+     * Note: Menu item filtering has been removed - menu items are now used for navigation only.
+     * @param {string} contextId - The context ID (applicationId or applicantId).
+     * @param {string | null} menuItem - Reserved parameter (no longer used for filtering).
+     * @param {string | null} userId - The selected user ID filter.
+     * @param {string | null} status - The selected status filter.
+     * @param {string | null} searchKey - The search key filter.
+     * @returns {Observable<any>} An observable that emits the filtered document data.
+     */
+    getDocumentsBySelection(contextId: string, menuItem: string | null, userId: string | null, status: string | null, searchKey?: string | null): Observable<any>;
+    getDocumentHistory(documentId: string): Observable<DocumentHistorySection[]>;
+    /**
+     * Fetches document categories by source (Applicant/Application).
+     * @param {string} source - The source type (Applicant or Application).
+     * @returns {Observable<DocumentCategory[]>} Observable that emits the categories.
+     */
+    getCategoriesBySource(source: string): Observable<DocumentCategory[]>;
+    /**
+     * Fetches document types by category ID.
+     * @param {string} categoryId - The category ID to fetch document types for.
+     * @returns {Observable<DocumentTypeModel[]>} Observable that emits the document types.
+     */
+    getDocumentTypesByCategory(categoryId: string): Observable<DocumentTypeModel[]>;
+    /**
+     * Uploads a single file using the uploadFile API.
+     * @param {FormData} formData - The form data containing the file and metadata.
+     * @returns {Observable<any>} Observable that emits the upload response.
+     */
+    uploadFile(formData: FormData): Observable<any>;
+    /**
+     * Saves the complete document upload data.
+     * @param {any} payload - The document upload payload containing all necessary data.
+     * @returns {Observable<any>} Observable that emits the save response.
+     */
+    saveDocumentUpload(payload: any): Observable<any>;
+    /**
+     * Updates the status of a document by document ID
+     * @param {string} documentId - The ID of the document to update
+     * @param {string} status - The new status (Approved, Rejected, etc.)
+     * @param {string} statusUpdateDescription - The description/note for the status update
+     * @returns {Observable<any>} Observable that emits the updated document data with normalized status
+     */
+    updateDocumentStatus(documentId: string, status: string, statusUpdateDescription: string): Observable<any>;
+    /**
+     * Normalizes the status from API response to match component expectations
+     * @param {string} status - The status from API response (Approved, Rejected, etc.)
+     * @returns {string} Normalized status value
+     */
+    private normalizeStatus;
+    /**
+     * Deletes a document by its ID and refreshes all data (categories, userlist, status, and document list)
+     * @param {string} documentId - The ID of the document to delete
+     * @param {string} contextId - The context ID to refresh all data
+     * @returns {Observable<any>} Observable that emits the delete response
+     */
+    deleteDocument(documentId: string, contextId: string): Observable<any>;
+    /**
+     * Downloads an Excel file with proper authentication headers
+     * Authentication is handled automatically by the HTTP interceptor
+     * @param {string} documentUrl - The URL of the Excel file to download
+     * @returns {Observable<ArrayBuffer>} Observable that emits the file data as ArrayBuffer
+     */
+    downloadExcelFile(documentUrl: string): Observable<ArrayBuffer>;
+    /**
+     * Downloads a CSV file with proper authentication headers
+     * Authentication is handled automatically by the HTTP interceptor
+     * @param {string} documentUrl - The URL of the CSV file to download
+     * @returns {Observable<string>} Observable that emits the file data as string
+     */
+    downloadCsvFile(documentUrl: string): Observable<string>;
+    /**
+     * Downloads an email file (EML) with appropriate handling for different storage types
+     * @param documentUrl - URL of the email file
+     * @returns Observable of file content as text
+     */
+    downloadEmailFile(documentUrl: string): Observable<string>;
+    documentRequest(payload: any): Observable<any>;
+    /**
+     * Checks if valuation report data exists for the given context ID
+     * @param {string} contextId - The context ID to check for valuation report data
+     * @returns {Observable<any>} Observable that emits the valuation report data or empty object
+     */
+    getValuationReportByContextId(contextId: string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentHttpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentHttpService>;
+}

package/lib/document/services/document-list.service.d.ts

@@ -0,0 +1,74 @@
+import { Observable } from 'rxjs';
+import { DocumentUploadService } from './document-upload.service';
+import { DocumentHttpService } from './document-http.service';
+import { DocumentQuery } from '../state/document.query';
+import { DocumentStore } from '../state/document.store';
+import { DocumentTableBuilderService } from './document-table-builder.service';
+import { DocumentHelperService } from './document.service';
+import { DocumentListItem, DocumentListResponse } from '../models/document-list-response.model';
+import { TableData } from '../../../Shared/components/table-primary/table-primary.model';
+import * as i0 from "@angular/core";
+export declare class DocumentListService {
+    private documentUploadService;
+    private documentHttpService;
+    private documentQuery;
+    private documentStore;
+    private documentTableBuilder;
+    private documentHelperService;
+    constructor(documentUploadService: DocumentUploadService, documentHttpService: DocumentHttpService, documentQuery: DocumentQuery, documentStore: DocumentStore, documentTableBuilder: DocumentTableBuilderService, documentHelperService: DocumentHelperService);
+    /**
+     * Handle file upload click event
+     */
+    handleFileUploadClick(): void;
+    /**
+     * Handle save click to update document name
+     */
+    handleSaveClick(fileName: string, selectedDocument: DocumentListItem): Observable<any>;
+    /**
+     * Get completion count for a category
+     */
+    getCompletionCount(category: DocumentListResponse): string;
+    /**
+     * Get pending document count for a category
+     */
+    getPendingDocumentCount(category: DocumentListResponse): number;
+    /**
+     * Get approved document count for a category
+     */
+    getApprovedDocumentCount(category: DocumentListResponse): number;
+    /**
+     * Build document categories from API response
+     */
+    buildDocumentCategories(documentListResponse: DocumentListResponse[] | null): {
+        documentCategories: DocumentListResponse[];
+        categoryTables: TableData[];
+        categoryCompletionCounts: string[];
+        categorySeverities: ('success' | 'info' | 'warning' | 'danger')[];
+    };
+    /**
+     * Handle table row click
+     */
+    handleTableRowClick(rowData: any): DocumentListItem;
+    /**
+     * Handle delete action
+     */
+    handleDeleteAction(rowData: any, contextId: string): Observable<any>;
+    /**
+     * Refresh document list for new context
+     */
+    refreshDocumentListForNewContext(contextId: string): void;
+    /**
+     * Refresh document list after status update
+     */
+    refreshDocumentList(contextId: string): void;
+    /**
+     * Setup subscription to document list response
+     */
+    setupDocumentListSubscription(): Observable<DocumentListResponse[] | null>;
+    /**
+     * Refresh all data with current filters
+     */
+    refreshAllDataWithCurrentFilters(contextId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentListService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentListService>;
+}

package/lib/document/services/document-menu.service.d.ts

@@ -0,0 +1,122 @@
+import { DocumentCategory, DocumentCategoryItem } from '../models/document-category.model';
+import { DocumentStore } from '../state/document.store';
+import { DocumentListResponse } from '../models/document-list-response.model';
+import * as i0 from "@angular/core";
+export declare class DocumentMenuService {
+    private documentStore;
+    constructor(documentStore: DocumentStore);
+    /**
+     * Sorts categories alphabetically by label
+     * @param categories - The list of document categories to sort
+     * @returns Sorted categories array
+     */
+    sortCategoriesAlphabetically(categories: DocumentCategory[]): DocumentCategory[];
+    /**
+     * Sorts menu items within each category alphabetically by label
+     * @param categories - The list of document categories to sort
+     * @returns Categories with sorted menu items
+     */
+    sortMenuItemsAlphabetically(categories: DocumentCategory[]): DocumentCategory[];
+    /**
+     * Sorts both categories and their menu items alphabetically
+     * @param categories - The list of document categories to sort
+     * @returns Fully sorted categories array
+     */
+    sortCategoriesAndMenuItems(categories: DocumentCategory[]): DocumentCategory[];
+    /**
+     * Gets the category name for a given menu item _id
+     * @param menuItemId - The _id of the menu item
+     * @param categories - The list of document categories
+     * @returns The category name or null if not found
+     */
+    getMenuItemCategory(menuItemId: string, categories: DocumentCategory[]): string | null;
+    /**
+     * Gets the menu item by its _id
+     * @param menuItemId - The _id of the menu item
+     * @param categories - The list of document categories
+     * @returns The menu item or null if not found
+     */
+    getMenuItemById(menuItemId: string, categories: DocumentCategory[]): DocumentCategoryItem | null;
+    /**
+     * Handles user list visibility based on menu item category
+     * @param menuItemId - The _id of the menu item
+     * @param categories - The list of document categories
+     */
+    handleUserListVisibility(menuItemId: string, categories: DocumentCategory[]): void;
+    /**
+     * Calculates total documents for a menu item
+     * @param item - The menu item
+     * @returns Total number of documents
+     */
+    getTotalDocuments(item: DocumentCategoryItem): number;
+    /**
+     * Gets badge value for a menu item
+     * @param item - The menu item
+     * @returns Badge value string (e.g., "2/3")
+     */
+    getBadgeValue(item: DocumentCategoryItem): string;
+    /**
+     * Gets badge severity based on status
+     * @param item - The menu item
+     * @returns Badge severity for PrimeNG
+     */
+    getBadgeSeverity(item: DocumentCategoryItem): 'success' | 'info' | 'warning' | 'danger';
+    /**
+     * Checks if badge should be shown for a menu item
+     * @param item - The menu item
+     * @returns True if badge should be shown
+     */
+    shouldShowBadge(item: DocumentCategoryItem): boolean;
+    /**
+     * Calculates approved documents for a menu item
+     * @param item - The menu item
+     * @returns Number of approved documents
+     */
+    getApprovedDocuments(item: DocumentCategoryItem): number;
+    /**
+     * Checks if a menu item's section is visible in the filtered document list
+     * @param menuItemId - The ID of the menu item to check
+     * @param documentListResponse - The filtered document list response
+     * @returns True if the section is visible, false otherwise
+     */
+    isMenuItemSectionVisible(menuItemId: string, documentListResponse: DocumentListResponse[] | null, menuItemLabel?: string): boolean;
+    /**
+     * Performs smart partial matching to prevent substring conflicts
+     * @param menuLabel - The menu item label to match
+     * @param categoryLabel - The category label to match against
+     * @returns True if it's a valid partial match, false otherwise
+     */
+    private isSmartPartialMatch;
+    /**
+     * Deselects a menu item if its section is not visible in the filtered document list
+     * @param menuItemId - The ID of the menu item to check
+     * @param documentListResponse - The filtered document list response
+     * @param menuItemLabel - The label of the menu item (optional)
+     * @returns True if the menu item was deselected, false otherwise
+     */
+    deselectMenuItemIfSectionNotVisible(menuItemId: string, documentListResponse: DocumentListResponse[] | null, menuItemLabel?: string): boolean;
+    /**
+     * Checks if a menu item should be selectable based on the filtered document list
+     * @param menuItemId - The ID of the menu item to check
+     * @param documentListResponse - The filtered document list response
+     * @param menuItemLabel - The label of the menu item (optional)
+     * @returns True if the menu item should be selectable, false otherwise
+     */
+    isMenuItemSelectable(menuItemId: string, documentListResponse: DocumentListResponse[] | null, menuItemLabel?: string): boolean;
+    /**
+     * Gets the selectability status for all menu items in categories
+     * @param categories - The document categories containing menu items
+     * @param documentListResponse - The filtered document list response
+     * @returns Map of menu item IDs to their selectability status
+     */
+    getMenuItemsSelectabilityStatus(categories: DocumentCategory[], documentListResponse: DocumentListResponse[] | null): Map<string, boolean>;
+    /**
+     * Updates menu items with selectability status
+     * @param categories - The document categories containing menu items
+     * @param documentListResponse - The filtered document list response
+     * @returns Updated categories with selectability information
+     */
+    updateMenuItemsWithSelectabilityStatus(categories: DocumentCategory[], documentListResponse: DocumentListResponse[] | null): DocumentCategory[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentMenuService>;
+}

package/lib/document/services/document-scroll.service.d.ts

@@ -0,0 +1,55 @@
+import { OnDestroy } from '@angular/core';
+import { DocumentStore } from '../state/document.store';
+import * as i0 from "@angular/core";
+export interface ScrollTarget {
+    element: Element;
+    menuItemId: string;
+}
+export declare class DocumentScrollService implements OnDestroy {
+    private documentStore;
+    private sectionObserver;
+    private currentObservedSection;
+    private isScrolling;
+    private scrollHandler;
+    private scrollTimeout;
+    constructor(documentStore: DocumentStore);
+    /**
+     * Sets up scroll event listeners to track scrolling state
+     * @param containerElement - The container element to monitor for scroll events
+     */
+    setupScrollListeners(containerElement: HTMLElement): void;
+    /**
+     * Sets up intersection observer to detect when the selected section scrolls out of view
+     * @param sectionElement - The section element to observe
+     * @param menuItemId - The ID of the selected menu item
+     */
+    setupSectionObserver(sectionElement: Element, menuItemId: string): void;
+    /**
+     * Disconnects the section observer
+     */
+    disconnectSectionObserver(): void;
+    /**
+     * Sets the scrolling flag to true (called when starting a scroll operation)
+     */
+    setScrolling(): void;
+    /**
+     * Resets the scrolling flag after a specified delay
+     * @param delay - Delay in milliseconds before resetting the flag
+     */
+    resetScrollingAfterDelay(delay?: number): void;
+    /**
+     * Gets the current scrolling state
+     */
+    get isCurrentlyScrolling(): boolean;
+    /**
+     * Cleans up all resources
+     */
+    ngOnDestroy(): void;
+    /**
+     * Removes scroll event listeners
+     * @param containerElement - The container element to remove listeners from
+     */
+    cleanupScrollListeners(containerElement?: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentScrollService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentScrollService>;
+}

package/lib/document/services/document-table-builder.service.d.ts

@@ -0,0 +1,38 @@
+import { DocumentListResponse, DocumentListItem } from '../models/document-list-response.model';
+import { TableData } from '../../../Shared/components/table-primary/table-primary.model';
+import * as i0 from "@angular/core";
+export declare class DocumentTableBuilderService {
+    constructor();
+    /**
+     * Builds a single table from document list items
+     * @param documents Array of document list items
+     * @returns TableData object
+     */
+    buildDocumentTable(documents: DocumentListItem[]): TableData;
+    /**
+     * Gets completion count for a category
+     * @param category Document category
+     * @returns Completion string (e.g., "2/4")
+     */
+    getCompletionCount(category: DocumentListResponse): string;
+    /**
+     * Gets pending document count for a category
+     * @param category Document category
+     * @returns Number of pending documents
+     */
+    getPendingDocumentCount(category: DocumentListResponse): number;
+    /**
+     * Gets approved document count for a category
+     * @param category Document category
+     * @returns Number of approved documents
+     */
+    getApprovedDocumentCount(category: DocumentListResponse): number;
+    /**
+     * Transforms document model to document list item
+     * @param documents Array of DocumentModel
+     * @returns Array of DocumentListItem
+     */
+    transformDocumentModelToListItem(documents: any[]): DocumentListItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentTableBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentTableBuilderService>;
+}

package/lib/document/services/document-upload-business.service.d.ts

@@ -0,0 +1,107 @@
+import { Observable } from 'rxjs';
+import { DocumentHttpService } from './document-http.service';
+import { FileFormatService } from './file-format.service';
+import { UserListModel } from '../models/user-list.model';
+import { DocumentCategory } from '../models/document-category.model';
+import { DocumentTypeModel } from '../models/document-type.model';
+import { UploadedFileResponse } from '../models/uploaded-file-response.model';
+import * as i0 from "@angular/core";
+export interface UploadedFile {
+    file: File;
+    formattedSize?: string;
+    progress?: number;
+    uploadResponse?: UploadedFileResponse;
+    url?: string;
+    contentType?: string;
+    fileName?: string;
+    size?: string;
+}
+export interface DocumentUploadPayload {
+    source: 'Applicant' | 'Application';
+    categoryId: string;
+    documentTypeId: string;
+    applicantId?: string;
+    contextId: string;
+    documents: {
+        fileName: string;
+        fileSize: number;
+        uploadedFileId?: string;
+        url?: string;
+        contentType?: string;
+        size?: string;
+    }[];
+}
+export declare class DocumentUploadBusinessService {
+    private documentHttpService;
+    private fileFormatService;
+    private destroy$;
+    constructor(documentHttpService: DocumentHttpService, fileFormatService: FileFormatService);
+    /**
+     * Loads applicants for a given context ID
+     */
+    loadApplicants(contextId: string): Observable<UserListModel[]>;
+    /**
+     * Loads categories based on assignment type
+     */
+    loadCategories(assignmentType: string): Observable<DocumentCategory[]>;
+    /**
+     * Loads document types based on category
+     */
+    loadDocumentTypes(categoryId: string): Observable<DocumentTypeModel[]>;
+    /**
+     * Filters applicants based on assignment type
+     */
+    filterApplicants(applicantList: UserListModel[], assignmentType: 'Applicant' | 'Application'): UserListModel[];
+    /**
+     * Helper method to validate form data and return validation result
+     */
+    private validateFormData;
+    /**
+     * Validates form data
+     */
+    validateForm(assignmentType: 'Applicant' | 'Application' | null, selectedCategory: string, selectedDocumentType: string, selectedApplicant: string, uploadedFiles: UploadedFile[], categoryOptions: DocumentCategory[], documentTypeOptions: DocumentTypeModel[]): boolean;
+    /**
+     * Checks if save button should be disabled
+     */
+    isSaveButtonDisabled(assignmentType: 'Applicant' | 'Application' | null, selectedCategory: string, selectedDocumentType: string, selectedApplicant: string, uploadedFiles: UploadedFile[], isSaving: boolean): boolean;
+    /**
+     * Validates the complete payload before save
+     */
+    validatePayload(assignmentType: 'Applicant' | 'Application' | null, selectedCategory: string, selectedDocumentType: string, selectedApplicant: string, uploadedFiles: UploadedFile[]): {
+        isValid: boolean;
+        message: string;
+    };
+    /**
+     * Prepares upload payload
+     */
+    prepareUploadPayload(assignmentType: 'Applicant' | 'Application', selectedCategory: string, selectedDocumentType: string, selectedApplicant: string, uploadedFiles: UploadedFile[], contextId: string): DocumentUploadPayload;
+    /**
+     * Saves document upload
+     */
+    saveDocumentUpload(payload: DocumentUploadPayload): Observable<any>;
+    /**
+     * Formats file size
+     */
+    formatFileSize(fileSize: number, config: any): string;
+    /**
+     * Creates uploaded file object
+     */
+    createUploadedFile(file: File, formattedSize: string): UploadedFile;
+    /**
+     * Resets form data to initial state
+     */
+    getInitialFormState(): {
+        selectedAssignmentType: null;
+        selectedApplicant: null;
+        selectedCategory: null;
+        selectedDocumentType: null;
+        uploadedFiles: UploadedFile[];
+        isFormValid: boolean;
+    };
+    /**
+     * Destroys the service
+     */
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentUploadBusinessService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentUploadBusinessService>;
+}

package/lib/document/services/document-upload-data.service.d.ts

@@ -0,0 +1,40 @@
+import { Observable } from 'rxjs';
+import { DocumentUploadBusinessService } from './document-upload-business.service';
+import { DocumentUploadFormService } from './document-upload-form.service';
+import { UserListModel } from '../models/user-list.model';
+import { DocumentCategory } from '../models/document-category.model';
+import { DocumentTypeModel } from '../models/document-type.model';
+import * as i0 from "@angular/core";
+export interface DataLoadingState {
+    isLoadingApplicants: boolean;
+    isLoadingCategories: boolean;
+    isLoadingDocumentTypes: boolean;
+}
+export declare class DocumentUploadDataService {
+    private businessService;
+    private formService;
+    private destroy$;
+    constructor(businessService: DocumentUploadBusinessService, formService: DocumentUploadFormService);
+    /**
+     * Loads applicants and handles the response
+     */
+    loadApplicants(contextId: string, onSuccess: (applicants: UserListModel[]) => void, onError: (error: any) => void): Observable<UserListModel[]>;
+    /**
+     * Loads categories and handles the response
+     */
+    loadCategories(assignmentType: string, onSuccess: (categories: DocumentCategory[]) => void, onError: (error: any) => void): Observable<DocumentCategory[]>;
+    /**
+     * Loads document types and handles the response
+     */
+    loadDocumentTypes(categoryId: string, onSuccess: (documentTypes: DocumentTypeModel[]) => void, onError: (error: any) => void): Observable<DocumentTypeModel[]>;
+    /**
+     * Handles applicants loaded successfully
+     */
+    handleApplicantsLoaded(applicants: UserListModel[], assignmentType: 'Applicant' | 'Application' | null): UserListModel[];
+    /**
+     * Destroys the service
+     */
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentUploadDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentUploadDataService>;
+}

package/lib/document/services/document-upload-form.service.d.ts

@@ -0,0 +1,41 @@
+import { MessageService } from 'primeng/api';
+import { UploadedFile } from './document-upload-business.service';
+import * as i0 from "@angular/core";
+export declare class DocumentUploadFormService {
+    private messageService;
+    constructor(messageService: MessageService);
+    /**
+     * Shows error message
+     */
+    showErrorMessage(summary: string, detail: string): void;
+    /**
+     * Shows warning message
+     */
+    showWarningMessage(summary: string, detail: string): void;
+    /**
+     * Shows success message
+     */
+    showSuccessMessage(summary: string, detail: string): void;
+    /**
+     * Helper method to validate required fields and show appropriate messages
+     */
+    private validateRequiredFieldsWithMessages;
+    /**
+     * Validates required fields for upload
+     */
+    validateRequiredFields(assignmentType: 'Applicant' | 'Application' | null, selectedApplicant: string, selectedCategory: string, selectedDocumentType: string, uploadedFiles: UploadedFile[]): boolean;
+    /**
+     * Shows appropriate validation message based on the field that failed
+     */
+    private showValidationMessage;
+    /**
+     * Validates form completeness
+     */
+    validateFormCompleteness(): boolean;
+    /**
+     * Validates context ID presence
+     */
+    validateContextId(contextId: string, message: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentUploadFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentUploadFormService>;
+}