@codex-ts/core-lib 1.0.9 → 1.0.13

package/lib/components/base-form.component.d.ts

@@ -1,40 +1,42 @@
-import { OnInit } from '@angular/core';
-import { ComponentContext } from '../enums/component-context.enum';
-import { FormGroup } from '@angular/forms';
+import { OnDestroy, OnInit } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
 import { FormlyFieldConfig } from '@ngx-formly/core';
-import { BasePageComponent } from './base-page.component';
-import { UtilsService } from '../services/utils.service';
-import { NotificationService } from '../services/notification.service';
-import { AppConstants, PageMode } from '../constants/app.constants';
 import { Observable } from 'rxjs';
-import { FormlyConfigService } from '../services/formly-config.service';
+import { AppConstants } from '../constants/app.constants';
+import { ComponentContext } from '../enums/component-context.enum';
 import { EntityService } from '../services/entity.service';
+import { FormlyConfigService } from '../services/formly-config.service';
+import { NotificationService } from '../services/notification.service';
+import { UtilsService } from '../services/utils.service';
+import { FormComponentState } from '../states/form-component.state';
+import { BasePageComponent } from './base-page.component';
 import * as i0 from "@angular/core";
 export declare abstract class BaseFormComponent<T extends {
     uuid: string;
-}> extends BasePageComponent implements OnInit {
+}> extends BasePageComponent implements OnInit, OnDestroy {
     protected route: ActivatedRoute;
     protected router: Router;
     protected notificationService: NotificationService;
     protected utilsService: UtilsService;
     protected formlyConfigService: FormlyConfigService;
-    form: FormGroup<any>;
-    fields: FormlyFieldConfig[];
-    isNew: boolean;
-    mode: PageMode;
-    currentFormData: any;
-    protected originalFormData: T | null;
-    protected hasChanges: boolean;
-    context: ComponentContext;
+    private readonly destroyed$;
+    protected state: FormComponentState<T>;
     constructor(route: ActivatedRoute, router: Router, notificationService: NotificationService, utilsService: UtilsService, formlyConfigService: FormlyConfigService);
     ngOnInit(): void;
-    private initializeFormData;
-    private loadFromUuid;
     private initializeForm;
+    private loadFormData;
+    private getRouterState;
+    private initializeFormSubscriptions;
+    set formData(data: T | null);
+    private updateCurrentData;
+    private checkFormChanges;
+    protected updateFormState(data: T): void;
+    private handleInitError;
+    private handleLoadError;
     protected patchFormData(data: any): void;
     private initializeFormMode;
     private setupFormState;
+    private onFormReady;
     protected getFormlyFieldConfig(): FormlyFieldConfig[];
     protected onSubmitRoute(): string[];
     protected getEntityOperations(): {
@@ -43,9 +45,12 @@ export declare abstract class BaseFormComponent<T extends {
         getById: (uuid: string) => Observable<T>;
     };
     protected onSubmit(): void;
+    private validateSubmission;
+    private getSubmitOperation;
+    private handleSubmitSuccess;
+    private handleSubmitError;
     protected hasFormChanges(currentData: any): boolean;
-    protected saveEntity(): void;
-    protected loadEntity(uuid: string): void;
+    ngOnDestroy(): void;
     protected abstract getEntityService(): EntityService<T>;
     private isValidPageMode;
     protected getDropdownOptions(): Record<string, any>;
@@ -57,6 +62,6 @@ export declare abstract class BaseFormComponent<T extends {
      */
     protected isInContext(contextType: ComponentContext): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BaseFormComponent<any>, "ng-component", never, { "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseFormComponent<any>, "ng-component", never, { "formData": { "alias": "formData"; "required": false; }; }, {}, never, never, true, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BaseFormComponent<any>>;
 }

package/lib/components/base-list-page.component.d.ts

@@ -1,78 +1,24 @@
-import { OnInit, OnDestroy } from '@angular/core';
 import { Router } from '@angular/router';
-import { Table, TableLazyLoadEvent } from 'primeng/table';
 import { ConfirmationService } from 'primeng/api';
+import { Observable } from 'rxjs';
+import { BaseTableComponent } from './base-table.component';
 import { NotificationService } from '../services/notification.service';
-import { Subscription, Observable } from 'rxjs';
-import { Page } from '../models/pagination/page.interface';
-import { PageRequest } from '../models/pagination/page-request.interface';
-import { FilterCriteria, FilterOperator } from '../models/pagination/filter-criteria.interface';
-import { BasePageComponent } from './base-page.component';
 import { UtilsService } from '../services/utils.service';
 import * as i0 from "@angular/core";
 /**
  * Base component for all list page components in the application.
- * Provides common functionality for list operations like loading data,
- * pagination, sorting, and CRUD operations.
+ * Provides common functionality for list operations like CRUD operations
+ * while inheriting table functionality from BaseTableComponent.
  */
 export declare abstract class BaseListPageComponent<T extends {
     uuid: string;
-}> extends BasePageComponent implements OnInit, OnDestroy {
+}> extends BaseTableComponent<T> {
     protected router: Router;
     protected notificationService: NotificationService;
     protected utilsService: UtilsService;
     protected confirmationService: ConfirmationService;
-    table: Table;
-    items: T[];
     actionLoading: boolean;
-    rows: number;
-    totalRecords: number;
-    filters: FilterCriteria[];
-    protected subscriptions: Subscription[];
     constructor(router: Router, notificationService: NotificationService, utilsService: UtilsService, confirmationService: ConfirmationService);
-    /**
-     * Initialize the component, subscribe to loading state if available,
-     * and load initial data.
-     */
-    ngOnInit(): void;
-    /**
-     * Clean up any subscriptions when the component is destroyed
-     */
-    ngOnDestroy(): void;
-    /**
-     * Handle search event from the UI
-     * @param event The search event
-     */
-    onSearch(event: Event): void;
-    /**
-     * Load data with pagination and sorting
-     * @param event The lazy load event from PrimeNG table
-     */
-    /**
-     * Convert PrimeNG filter format to backend format
-     * @param filters The PrimeNG filters object
-     * @returns Converted filters object for backend
-     */
-    /**
-     * Convert PrimeNG filter format to backend format
-     * @param filters The PrimeNG filters object
-     * @returns Converted filters object for backend
-     */
-    /**
-     * Convert PrimeNG filters to backend format with proper operator mapping
-     */
-    protected convertFilters(filters: {
-        [key: string]: any;
-    }): FilterCriteria[];
-    /**
-     * Transform filter value based on backend requirements - all values must be strings
-     */
-    protected transformFilterValue(value: any): string;
-    /**
-     * Map PrimeNG operators to backend operators
-     */
-    protected transformOperator(operator: string): FilterOperator;
-    loadData(event?: TableLazyLoadEvent): void;
     /**
      * Navigate to create a new entity
      */
@@ -87,6 +33,11 @@ export declare abstract class BaseListPageComponent<T extends {
      * @param item The entity to edit
      */
     onEdit(item: T): void;
+    /**
+     * Delete an entity with confirmation
+     * @param item The entity to delete
+     */
+    onDelete(item: T): void;
     /**
      * Navigate to a route with error handling
      * @param path The route path
@@ -95,11 +46,6 @@ export declare abstract class BaseListPageComponent<T extends {
     protected navigateTo(path: any[], matrixParams?: {
         [key: string]: any;
     }): void;
-    /**
-     * Delete an entity with confirmation
-     * @param item The entity to delete
-     */
-    onDelete(item: T): void;
     /**
      * Validate that an entity has a UUID
      * @param item The entity to validate
@@ -108,15 +54,10 @@ export declare abstract class BaseListPageComponent<T extends {
      */
     protected validateItemUuid(item: T, action: string): boolean;
     /**
-     * Get an observable for loading state from the entity service
-     * @returns An observable of loading state if available, null otherwise
-     */
-    protected getLoadingObservable(): Observable<boolean> | null;
-    /**
-     * Get the entity service for data operations
+     * Override the getEntityService to include the delete operation
      */
     protected abstract getEntityService(): {
-        getAll: (pageRequest?: PageRequest) => Observable<Page<T>>;
+        getAll: (pageRequest?: any) => Observable<any>;
         delete: (uuid: string) => Observable<any>;
     };
     /**

package/lib/components/base-list-tabbed-form.component.d.ts

@@ -0,0 +1,40 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { FormComponentState } from '../states/form-component.state';
+import { BasePageComponent } from './base-page.component';
+import { UtilsService } from '../services/utils.service';
+import { NotificationService } from '../services/notification.service';
+import { ListTabbedFormState } from '../states/list-tabbed-form.state';
+import * as i0 from "@angular/core";
+export declare abstract class BaseListTabbedFormComponent<T extends {
+    uuid: string;
+}> extends BasePageComponent implements OnInit, OnDestroy {
+    protected route: ActivatedRoute;
+    protected router: Router;
+    protected notificationService: NotificationService;
+    protected utilsService: UtilsService;
+    private readonly destroyed$;
+    private readonly tabState$;
+    state: ListTabbedFormState<T> & FormComponentState<T>;
+    constructor(route: ActivatedRoute, router: Router, notificationService: NotificationService, utilsService: UtilsService);
+    ngOnInit(): void;
+    private initializeFormFromQueryParams;
+    private setupTabStateSubscription;
+    private setupRouteParamsSubscription;
+    private handleTabChange;
+    private findTabData;
+    private updateComponentState;
+    private initializeForm;
+    private initializeFormMode;
+    private setupFormState;
+    protected initializeListForm(): void;
+    private createTabsFromFormDataList;
+    protected onTabChange(event: any): void;
+    protected navigateToTab(uuid: string): void;
+    ngOnDestroy(): void;
+    private isValidPageMode;
+    protected abstract getTabTitle(data: T): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseListTabbedFormComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseListTabbedFormComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseListTabbedFormComponent<any>>;
+}

package/lib/components/base-tabbed-form.component.d.ts

@@ -1,33 +1,30 @@
-import { OnInit } from '@angular/core';
+import { OnInit, OnDestroy } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
 import { BasePageComponent } from './base-page.component';
 import { UtilsService } from '../services/utils.service';
 import { NotificationService } from '../services/notification.service';
-import { PageMode } from '../constants/app.constants';
 import { EntityService } from '../services/entity.service';
+import { TabConfig, TabbedFormState } from '../states/tabbed-form.state';
 import * as i0 from "@angular/core";
-export interface TabConfig {
-    value: string;
-    title: string;
-    isParentModel?: boolean;
-}
 export declare abstract class BaseTabbedFormComponent<T extends {
     uuid: string;
-}> extends BasePageComponent implements OnInit {
+}> extends BasePageComponent implements OnInit, OnDestroy {
     protected route: ActivatedRoute;
     protected router: Router;
     protected notificationService: NotificationService;
     protected utilsService: UtilsService;
-    activeTab: string;
-    tabs: TabConfig[];
-    formType: string;
-    isNew: boolean;
-    mode: PageMode;
-    currentFormData: T;
-    protected originalFormData: T | null;
-    protected hasChanges: boolean;
+    private readonly destroyed$;
+    private readonly stateManager$;
+    private getInitialState;
+    protected get state(): TabbedFormState<T>;
+    protected set state(value: TabbedFormState<T>);
+    private hasStateChanged;
+    private areTabsEqual;
     constructor(route: ActivatedRoute, router: Router, notificationService: NotificationService, utilsService: UtilsService);
     ngOnInit(): void;
+    private initializeFormWithErrorHandling;
+    private setupStateSubscription;
+    private handleStateChange;
     private initializeFormData;
     private loadFromUuid;
     private initializeForm;
@@ -38,16 +35,16 @@ export declare abstract class BaseTabbedFormComponent<T extends {
     protected findTabByValue(value: string): TabConfig | undefined;
     protected loadDefaultTab(): void;
     protected getTabFormData(tabConfig: TabConfig): T | null;
-    private initializeListForm;
-    private createTabsFromFormDataList;
-    protected abstract getTabTitle(data: T): string;
+    private isTabFormData;
     protected onTabChange(value: string | number): void;
     protected hasFormChanges(currentData: T): boolean;
-    private isEqual;
+    private detectChanges;
+    ngOnDestroy(): void;
     private isValidPageMode;
     protected abstract getTabs(): TabConfig[];
     protected abstract getEntityService(): EntityService<T>;
     protected abstract getEntityName(): string;
+    protected getTabTitle(data: T): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<BaseTabbedFormComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<BaseTabbedFormComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BaseTabbedFormComponent<any>>;

package/lib/components/base-table.component.d.ts

@@ -0,0 +1,72 @@
+import { Table, TableLazyLoadEvent } from 'primeng/table';
+import { Subscription, Observable } from 'rxjs';
+import { Page } from '../models/pagination/page.interface';
+import { PageRequest } from '../models/pagination/page-request.interface';
+import { FilterCriteria, FilterOperator } from '../models/pagination/filter-criteria.interface';
+import { BasePageComponent } from './base-page.component';
+import { UtilsService } from '../services/utils.service';
+import { NotificationService } from '../services/notification.service';
+import * as i0 from "@angular/core";
+/**
+ * Base component for all table components in the application.
+ * Provides common functionality for table operations like loading data,
+ * pagination, sorting, and filtering.
+ */
+export declare abstract class BaseTableComponent<T extends {
+    uuid: string;
+}> extends BasePageComponent {
+    protected utilsService: UtilsService;
+    protected notificationService: NotificationService;
+    table: Table;
+    items: T[];
+    rows: number;
+    totalRecords: number;
+    filters: FilterCriteria[];
+    protected subscriptions: Subscription[];
+    constructor(utilsService: UtilsService, notificationService: NotificationService);
+    /**
+     * Initialize the component and load initial data
+     */
+    ngOnInit(): void;
+    /**
+     * Clean up any subscriptions when the component is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Handle search event from the UI
+     * @param event The search event
+     */
+    onSearch(event: Event): void;
+    /**
+     * Load data with pagination and sorting
+     * @param event The lazy load event from PrimeNG table
+     */
+    loadData(event?: TableLazyLoadEvent): void;
+    /**
+     * Convert PrimeNG filters to backend format with proper operator mapping
+     */
+    protected convertFilters(filters: {
+        [key: string]: any;
+    }): FilterCriteria[];
+    /**
+     * Transform filter value based on backend requirements - all values must be strings
+     */
+    protected transformFilterValue(value: any): string;
+    /**
+     * Map PrimeNG operators to backend operators
+     */
+    protected transformOperator(operator: string): FilterOperator;
+    /**
+     * Get an observable for loading state from the entity service
+     * @returns An observable of loading state if available, null otherwise
+     */
+    protected getLoadingObservable(): Observable<boolean> | null;
+    /**
+     * Get the entity service for data operations
+     */
+    protected abstract getEntityService(): {
+        getAll: (pageRequest?: PageRequest) => Observable<Page<T>>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTableComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseTableComponent<any>, never, never, {}, {}, never, never, true, never>;
+}

package/lib/components/base-task-details.component.d.ts

@@ -0,0 +1,59 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { BasePageComponent } from './base-page.component';
+import { UtilsService } from '../services/utils.service';
+import { NotificationService } from '../services/notification.service';
+import { FormlyConfigService } from '../services/formly-config.service';
+import { EntityService } from '../services/entity.service';
+import { FormService } from '../services/form.service';
+import { ComponentContext } from '../enums/component-context.enum';
+import { FormComponentState } from '../states/form-component.state';
+import * as i0 from "@angular/core";
+/**
+ * Base component for all task detail components in the application.
+ * Uses composition with FormService for form functionality.
+ */
+export declare abstract class BaseTaskDetailsComponent<T extends {
+    uuid: string;
+}> extends BasePageComponent implements OnInit, OnDestroy {
+    protected route: ActivatedRoute;
+    protected router: Router;
+    protected notificationService: NotificationService;
+    protected utilsService: UtilsService;
+    protected formlyConfigService: FormlyConfigService;
+    private readonly destroyed$;
+    protected formService: FormService<T>;
+    protected state: FormComponentState<T>;
+    constructor(route: ActivatedRoute, router: Router, notificationService: NotificationService, utilsService: UtilsService, formlyConfigService: FormlyConfigService);
+    protected initializeServices(): Observable<void>;
+    ngOnInit(): void;
+    private initializeFromRoute;
+    protected loadData(uuid: string): void;
+    protected onSubmit(): void;
+    protected navigateAfterSubmit(): void;
+    private onInitialized;
+    private handleInitError;
+    protected handleLoadError(error: any): void;
+    protected handleSubmitError(error: any): void;
+    protected isInContext(contextType: ComponentContext): boolean;
+    ngOnDestroy(): void;
+    /**
+     * Get the entity service for CRUD operations
+     */
+    protected abstract getEntityService(): EntityService<T>;
+    /**
+     * Get field configuration for the form
+     */
+    protected abstract getJsonFields(): any;
+    /**
+     * Get dropdown options for form fields
+     */
+    protected abstract getDropdownOptions(): Record<string, any>;
+    /**
+     * Get entity name for messages
+     */
+    protected abstract getEntityName(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTaskDetailsComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseTaskDetailsComponent<any>, never, never, {}, {}, never, never, true, never>;
+}

package/lib/enums/task-role.enum.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Standard task roles that define user permissions within a task workflow.
+ * These roles control what operations a user can perform on tasks.
+ */
+export declare enum TaskRole {
+    /**
+     * Can create new tasks. This could be a user initiating a task manually
+     * or a system process creating tasks automatically.
+     */
+    TASK_CREATOR = "TASK_CREATOR",
+    /**
+     * Can assign or reassign tasks to other users. Typically used by
+     * team leads or workflow managers to distribute work.
+     */
+    TASK_ASSIGNER = "TASK_ASSIGNER",
+    /**
+     * Can pick tasks for self-assignment from a task pool.
+     * Useful in scenarios where tasks can be claimed by available workers.
+     */
+    TASK_PICKER = "TASK_PICKER",
+    /**
+     * Can review and approve completed tasks. This role is responsible for
+     * quality assurance or approval steps in the workflow.
+     */
+    TASK_REVIEWER = "TASK_REVIEWER",
+    /**
+     * Can view task details but cannot modify them. Useful for stakeholders
+     * who need to monitor task progress without making changes.
+     */
+    TASK_VIEWER = "TASK_VIEWER",
+    /**
+     * Has full administrative control over tasks. Can override or force
+     * state changes, bypass normal workflow restrictions, and manage
+     * task configuration.
+     */
+    TASK_ADMIN = "TASK_ADMIN"
+}

package/lib/keycloak/keycloak-config.interface.d.ts

@@ -0,0 +1,19 @@
+export interface KeycloakConfig {
+    authServerUrl: string;
+    realm: string;
+    clientId: string;
+    scope?: string;
+    useSSO?: boolean;
+    enableBearerInterceptor?: boolean;
+    tokenValidityInSeconds?: number;
+    bearerExcludedUrls?: string[];
+    silentCheckSsoRedirectUri?: string;
+    loginOptions?: KeycloakLoginOptions;
+}
+export interface KeycloakLoginOptions {
+    redirectUri?: string;
+    prompt?: 'none' | 'login' | 'consent';
+    maxAge?: number;
+    loginHint?: string;
+    idpHint?: string;
+}

package/lib/keycloak/keycloak.guard.d.ts

@@ -0,0 +1,25 @@
+import { ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree, Router } from '@angular/router';
+import { KeycloakService } from './keycloak.service';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class KeycloakAuthGuard {
+    protected keycloakService: KeycloakService;
+    protected router: Router;
+    constructor(keycloakService: KeycloakService, router: Router);
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean | UrlTree>;
+    protected hasRequiredRoles(requiredRoles: string[]): boolean;
+    /**
+     * Checks if all required roles are present
+     * @param route Route being activated
+     * @returns true if no roles are required or if all required roles are present
+     */
+    protected checkRoles(route: ActivatedRouteSnapshot): boolean;
+    /**
+     * Gets redirect URL from route if present
+     * @param state Router state
+     * @returns URL to redirect to after login or undefined
+     */
+    protected getLoginRedirectUrl(state: RouterStateSnapshot): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeycloakAuthGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KeycloakAuthGuard>;
+}

package/lib/keycloak/keycloak.service.d.ts

@@ -0,0 +1,24 @@
+import { KeycloakConfig } from './keycloak-config.interface';
+import { Observable } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class KeycloakService {
+    private config;
+    private http;
+    private keycloak;
+    private isAuthenticated$;
+    private userProfile$;
+    constructor(config: KeycloakConfig, http: HttpClient);
+    initialize(): Promise<boolean>;
+    login(options?: any): Promise<void>;
+    logout(): Promise<void>;
+    isLoggedIn(): Observable<boolean>;
+    getToken(): Promise<string | null>;
+    getRoles(): string[];
+    hasRole(role: string): boolean;
+    getUserProfile(): Observable<any>;
+    updateToken(minValidity?: number): Promise<boolean>;
+    private loadUserProfile;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeycloakService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KeycloakService>;
+}

package/lib/keycloak/keycloak.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { KeycloakConfig } from './keycloak-config.interface';
+export declare const KEYCLOAK_CONFIG: InjectionToken<KeycloakConfig>;

package/lib/models/base-create-request.model.d.ts

@@ -0,0 +1,12 @@
+import { BaseRequest } from './base-request.model';
+/**
+ * Base interface for create operation requests
+ * Contains minimal fields needed when creating a new entity
+ */
+export interface BaseCreateRequest extends BaseRequest {
+    /**
+     * Whether the entity should be active upon creation
+     * Optional, defaults to true on server
+     */
+    active?: boolean;
+}

package/lib/models/base-request.model.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Base interface for all API request DTOs
+ */
+export interface BaseRequest {
+    /**
+     * Unique request identifier for tracing/debugging
+     */
+    requestId?: string;
+}

package/lib/models/base-response.model.d.ts

@@ -0,0 +1,15 @@
+import { BaseModel } from './base.model';
+/**
+ * Base interface for all API response DTOs
+ * Extends BaseModel to include audit fields and adds response-specific fields
+ */
+export interface BaseResponse extends BaseModel {
+    /**
+ * Unique request identifier for tracing/debugging
+ */
+    requestId?: string;
+    /**
+     * Timestamp when the response was generated
+     */
+    timestamp: Date;
+}

package/lib/models/base-task.model.d.ts

@@ -0,0 +1,17 @@
+import { BaseModel } from './base.model';
+/**
+ * Base model interface for all task entities
+ * Contains common fields used across different types of tasks
+ */
+export interface BaseTaskModel extends BaseModel {
+    title: string;
+    description: string;
+    type: string;
+    category: string;
+    priority: string;
+    assignedUser: string;
+    assignedDepartment: string;
+    product: string;
+    subProduct: string;
+    business: string;
+}

package/lib/models/base-update-request.model.d.ts

@@ -0,0 +1,16 @@
+import { BaseRequest } from './base-request.model';
+/**
+ * Base interface for update operation requests
+ * Contains fields required for entity identification and version control
+ */
+export interface BaseUpdateRequest extends BaseRequest {
+    /**
+     * Unique identifier of the entity to update
+     */
+    uuid: string;
+    /**
+     * Version number for optimistic locking
+     * Must match the current version in database
+     */
+    version: number;
+}