import { Route } from '@angular/router';
import * as _angular_core from '@angular/core';
import { OnInit, OnDestroy, TemplateRef } from '@angular/core';
import * as _angular_forms from '@angular/forms';
import { FormGroup, FormArray, FormControl } from '@angular/forms';
import { TabItem, TemplateContext, GridConfiguration, GridEvent, DropdownConfig, DropdownItem, SelectOption as SelectOption$1 } from 'cloud-ide-element';
import { CideLytSharedWrapperSetupParam, BreadcrumbItem } from 'cloud-ide-layout';
import { Observable } from 'rxjs';
import { MAcademicYear, academicYearControllerResponse, MAcademicYearGetByIdPayload, academicYearByIdControllerResponse, MAcademicYearInsertUpdatePayload, academicYearInsertUpdateControllerResponse, MAcademicYearDeletePayload, academicYearDeleteControllerResponse, MAcademicYearToggleStatusPayload, academicYearToggleStatusControllerResponse, academicYearMappingInsertUpdateControllerResponse, MAcademicYearMapping, academicYearMappingControllerResponse, MAcademicYearMappingGetByIdPayload, academicYearMappingByIdControllerResponse, MAcademicYearMappingInsertUpdatePayload, MAcademicYearMappingDeletePayload, academicYearMappingDeleteControllerResponse, MAcademicYearMappingToggleStatusPayload, academicYearMappingToggleStatusControllerResponse, AcaClassPrgBranchResponse, ICoreSygms, AcaClassPrgBranchListPayload, classPrgBranchControllerResponse, AcaClassPrgBranchGetByIdPayload, classPrgBranchByIdControllerResponse, AcaClassPrgBranchInsertUpdatePayload, classPrgBranchInsertUpdateControllerResponse, AcaClassPrgBranchDeletePayload, classPrgBranchDeleteControllerResponse, AcaClassPrgBranchToggleStatusPayload, classPrgBranchToggleStatusControllerResponse, AcaClassPrgBranchToggleLockPayload, classPrgBranchToggleLockControllerResponse, AcaPrgTrmSectionResponse, MPrgTrmSection, prgTrmSectionControllerResponse, MPrgTrmSectionGetByIdPayload, prgTrmSectionByIdControllerResponse, MPrgTrmSectionInsertUpdatePayload, prgTrmSectionInsertUpdateControllerResponse, MPrgTrmSectionDeletePayload, prgTrmSectionDeleteControllerResponse, MPrgTrmSectionToggleStatusPayload, prgTrmSectionToggleStatusControllerResponse, MPrgTrmSectionToggleLockPayload, prgTrmSectionToggleLockControllerResponse, EducationBoardSearchParams, educationBoardListControllerResponse, educationBoardByIdControllerResponse, AcademicsEducationBoard, educationBoardDeleteControllerResponse, selectSearchType, AcaClassProgramMasterResponse } from 'cloud-ide-lms-model';
import { IEducationBoardService } from 'cloud-ide-shared';

declare const academicsRoutes: Route[];

interface AcademicYearMapping$1 {
    _id?: string;
    acayrmp_entity_id_syen: string;
    acayrmp_islocked?: boolean;
    acayrmp_iscurrent?: boolean;
}
interface Entity {
    _id?: string;
    syen_name?: string;
    syen_code?: string;
}
declare class AcademicYearCreateComponent implements OnInit, OnDestroy {
    readonly shared_wrapper_setup_param: _angular_core.WritableSignal<Partial<CideLytSharedWrapperSetupParam>>;
    readonly breadcrumb_data: _angular_core.WritableSignal<BreadcrumbItem[]>;
    private readonly destroyRef;
    private readonly fb;
    private readonly academicYearService;
    private readonly academicYearMappingService;
    private readonly entityService;
    private readonly router;
    private readonly route;
    private readonly componentContextService;
    private readonly rightsService;
    private readonly notificationService;
    private readonly cdr;
    private mappingsChangeTrigger;
    academicYearForm: FormGroup;
    readonly activeTab: _angular_core.WritableSignal<string>;
    readonly loading: _angular_core.WritableSignal<boolean>;
    readonly academicYearId: _angular_core.WritableSignal<string>;
    readonly isEditMode: _angular_core.WritableSignal<boolean>;
    readonly isViewMode: _angular_core.WritableSignal<boolean>;
    readonly originalMappings: _angular_core.WritableSignal<AcademicYearMapping$1[]>;
    readonly entityOptions: _angular_core.WritableSignal<Entity[]>;
    readonly isFormValidForSubmit: _angular_core.Signal<boolean>;
    readonly submitButtonDisabledReason: _angular_core.Signal<string>;
    /**
     * Get user-friendly field label
     */
    private getFieldLabel;
    constructor();
    ngOnInit(): void;
    /**
     * Setup breadcrumb based on component mode
     */
    private setupBreadcrumb;
    /**
     * Initialize component
     */
    private initializeComponent;
    /**
     * Load academic year for viewing
     */
    private loadAcademicYearForView;
    /**
     * Load academic year for editing
     */
    private loadAcademicYearForEdit;
    /**
     * Load dropdown options
     */
    private loadDropdownOptions;
    /**
     * Load academic year data for edit mode
     * Note: API will automatically filter by entity ID from token, no need to send entity ID from UI
     */
    private loadAcademicYearData;
    /**
     * Load academic year mappings for edit mode
     * Note: API will automatically filter by entity ID from token, no need to send entity ID from UI
     */
    private loadAcademicYearMappings;
    /**
     * Populate form with academic year data
     */
    private populateFormWithAcademicYearData;
    /**
     * Populate form with mappings data
     */
    private populateFormWithMappingsData;
    /**
     * Tab configuration
     */
    academicYearTabs(): {
        id: string;
        label: string;
        icon: string;
    }[];
    onTabChange(tab: TabItem): void;
    onSubmit(): void;
    /**
     * Mark all form controls as touched to trigger validation display
     */
    private markFormGroupTouched;
    resetForm(): void;
    /**
     * Go back to academic year list
     */
    goBackToAcademicYearList(): void;
    /**
     * Cancel form and optionally navigate back
     */
    cancelForm(): void;
    /**
     * Get page title based on mode
     */
    getPageTitle(): string;
    /**
     * Getter methods for form arrays
     */
    get academicYearMappingsArray(): FormArray;
    /**
     * Add new academic year mapping
     */
    addAcademicYearMapping(): void;
    /**
     * Update academic year ID in all existing mappings when academic year ID changes
     */
    private updateMappingsAcademicYearId;
    /**
     * Get form array value for validation or submission
     */
    getAcademicYearMappingsValue(): any[];
    /**
     * Check if mappings array has any invalid controls
     */
    isMappingsArrayValid(): boolean;
    /**
     * Set academic year ID for all existing mappings
     * This is useful when the academic year ID is generated after creation
     */
    setAcademicYearIdForMappings(academicYearId: string): void;
    /**
     * Validate that all mappings have required fields
     * For create mode: At least one mapping is required
     * For edit mode: Mappings are optional (can have zero mappings)
     */
    validateMappings(): boolean;
    /**
     * Find duplicate entity selection in mappings
     */
    private findDuplicateEntitySelection;
    /**
     * Remove academic year mapping
     */
    removeAcademicYearMapping(index: number): void;
    /**
     * Handle entity selection change for a specific mapping
     */
    onMappingEntityChange(event: any, mappingIndex: number): void;
    /**
     * Get filtered entity options excluding already selected entities in other mappings
     * @param currentMappingIndex The index of the current mapping being edited
     * @returns Entity options excluding already selected entities
     */
    getFilteredEntityOptions(currentMappingIndex: number): any[];
    /**
     * Get all currently selected entity IDs from other mappings
     */
    private getSelectedEntityIds;
    /**
     * Update entity options for all mappings to prevent duplicates
     */
    private updateEntityOptionsForMappings;
    /**
     * Check if an entity is disabled for a specific mapping
     */
    isEntityDisabled(entityId: string, mappingIndex: number): boolean;
    /**
     * Get the count of available entities for a specific mapping
     */
    getAvailableEntityCount(mappingIndex: number): number;
    /**
     * Get the count of total entities
     */
    getTotalEntityCount(): number;
    /**
     * Check if all entities are already selected in other mappings
     * @param currentMappingIndex The index of the current mapping being edited
     * @returns True if all entities are already selected
     */
    isAllEntitiesSelected(currentMappingIndex: number): boolean;
    /**
     * Check if all entities are already mapped (for disabling Add Entity Mapping button)
     * @returns True if all entities are already mapped
     */
    isAllEntitiesMapped(): boolean;
    /**
     * Cleanup when component is destroyed
     * This ensures that when the component is destroyed (e.g., tab closed),
     * all state is properly reset to prevent old data from persisting
     */
    ngOnDestroy(): void;
    /**
     * Delete removed academic year mappings
     */
    private deleteRemovedMappings;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AcademicYearCreateComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AcademicYearCreateComponent, "cide-core-academic-year-create", never, {}, {}, never, never, true, never>;
}

interface AcademicYear {
    _id?: string;
    acayr_code?: string;
    acayr_name?: string;
    acayr_description?: string;
    acayr_from_date?: string | Date;
    acayr_to_date?: string | Date;
    acayr_isactive?: boolean;
    acayr_iscurrent?: boolean;
    acayr_islocked?: boolean;
}
declare class AcademicYearListComponent implements OnInit, OnDestroy {
    readonly shared_wrapper_setup_param: CideLytSharedWrapperSetupParam;
    private readonly destroyRef;
    private readonly academicYearService;
    private readonly router;
    private readonly appState;
    private readonly confirmationService;
    private readonly notificationService;
    private readonly rightsService;
    readonly academicYearDetailsRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    readonly dateRangeRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    readonly statusRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    readonly actionsDropdownRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    readonly academicYears: _angular_core.WritableSignal<AcademicYear[]>;
    readonly loading: _angular_core.WritableSignal<boolean>;
    readonly error: _angular_core.WritableSignal<string | null>;
    readonly currentPage: _angular_core.WritableSignal<number>;
    readonly pageSize: _angular_core.WritableSignal<number>;
    readonly totalItems: _angular_core.WritableSignal<number>;
    readonly totalPages: _angular_core.WritableSignal<number>;
    readonly searchQuery: _angular_core.WritableSignal<string>;
    readonly sortColumn: _angular_core.WritableSignal<string>;
    readonly sortDirection: _angular_core.WritableSignal<"asc" | "desc">;
    readonly selectedStatusFilter: _angular_core.WritableSignal<string>;
    readonly statusFilterOptions: _angular_core.Signal<{
        value: string;
        label: string;
    }[]>;
    readonly canCreate: _angular_core.Signal<boolean>;
    readonly canEdit: _angular_core.Signal<boolean>;
    readonly canDelete: _angular_core.Signal<boolean>;
    readonly canView: _angular_core.Signal<boolean>;
    readonly canToggleStatus: _angular_core.Signal<boolean>;
    readonly gridConfig: _angular_core.Signal<GridConfiguration<AcademicYear>>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * Load academic years from API
     * Note: API will automatically filter by entity ID from token, no need to send entity ID from UI
     */
    loadAcademicYears(): void;
    templateRenderers: _angular_core.Signal<Record<string, TemplateRef<TemplateContext<Record<string, unknown>>>>>;
    /**
     * Handle grid events
     */
    onGridEvent(event: GridEvent<any>): void;
    onStatusFilterChange(): void;
    clearFilters(): void;
    createAcademicYear(): void;
    viewAcademicYear(academicYear: AcademicYear): void;
    editAcademicYear(academicYear: AcademicYear): void;
    /**
     * Get dropdown configuration
     */
    getDropdownConfig(): DropdownConfig;
    /**
     * Get action dropdown items
     */
    getActionDropdownItems(academicYear: AcademicYear): DropdownItem[];
    /**
     * Handle dropdown item click
     */
    onDropdownItemClick(item: DropdownItem, academicYear: AcademicYear): void;
    /**
     * Toggle academic year status (active/inactive)
     */
    toggleAcademicYearStatus(academicYear: AcademicYear): void;
    /**
     * Toggle status of all academic year mappings for a specific academic year
     */
    private toggleAcademicYearMappingsStatus;
    private handleExport;
    private exportToCSV;
    private exportToExcel;
    private exportToPDF;
    private downloadFile;
    formatDate(date: string | Date | null | undefined): string;
    getDuration(fromDate: string | Date | null | undefined, toDate: string | Date | null | undefined): string;
    getStatusBadgeClass(academicYear: AcademicYear): string;
    getActiveStatusBadgeClass(academicYear: AcademicYear): string;
    getStatusText(academicYear: AcademicYear): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AcademicYearListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AcademicYearListComponent, "cide-core-academic-year-list", never, {}, {}, never, never, true, never>;
}

interface AcademicYearMapping {
    _id?: string;
    acayrmp_entity_id_syen: string;
    acayrmp_islocked?: boolean;
    acayrmp_iscurrent?: boolean;
}
interface AcademicYearWithMappings {
    acayr_academic_year_mappings?: AcademicYearMapping[];
    [key: string]: any;
}
interface DeleteMappingPayload {
    acayrmp_id: string;
}
interface ToggleMappingPayload {
    acayrmp_id: string;
}
declare class CideLytAcademicYearService {
    private http;
    /**
     * Get list of academic years
     * @param payload - Query parameters for filtering/pagination
     * @returns Observable of academic year list response
     */
    getAcademicYearList(payload: MAcademicYear): Observable<academicYearControllerResponse>;
    /**
     * Get academic year by ID
     * @param payload - Academic year ID payload
     * @returns Observable of academic year data
     */
    getAcademicYearById(payload: MAcademicYearGetByIdPayload): Observable<academicYearByIdControllerResponse>;
    /**
     * Create or update academic year
     * @param data - Academic year data to save
     * @returns Observable of the save response
     */
    saveUpdateAcademicYear(data: MAcademicYearInsertUpdatePayload): Observable<academicYearInsertUpdateControllerResponse>;
    /**
     * Create or update academic year with mappings
     * @param data - Academic year data with mappings
     * @returns Observable of the save response
     */
    saveUpdateAcademicYearWithMappings(data: AcademicYearWithMappings): Observable<academicYearInsertUpdateControllerResponse>;
    /**
     * Delete academic year
     * @param payload - Academic year ID payload
     * @returns Observable of the delete response
     */
    deleteAcademicYear(payload: MAcademicYearDeletePayload): Observable<academicYearDeleteControllerResponse>;
    /**
     * Toggle academic year status
     * @param payload - Academic year ID payload
     * @returns Observable of the toggle response
     */
    toggleAcademicYearStatus(payload: MAcademicYearToggleStatusPayload): Observable<academicYearToggleStatusControllerResponse>;
    /**
     * Delete academic year mapping
     * @param payload - Academic year mapping ID payload
     * @returns Observable of the delete response
     */
    deleteAcademicYearMapping(payload: DeleteMappingPayload): Observable<academicYearMappingInsertUpdateControllerResponse>;
    /**
     * Toggle academic year mapping status
     * @param payload - Academic year mapping ID payload
     * @returns Observable of the toggle response
     */
    toggleAcademicYearMappingStatus(payload: ToggleMappingPayload): Observable<academicYearMappingInsertUpdateControllerResponse>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytAcademicYearService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytAcademicYearService>;
}

declare class CideLytAcademicYearMappingService {
    private http;
    /**
     * Get list of academic year mappings
     * @param payload - Query parameters for filtering/pagination
     * @returns Observable of academic year mapping list response
     *
     * Note: The JWT token is automatically sent via the auth interceptor in the Authorization header.
     * The API should:
     * 1. Extract the entity ID from the JWT token (from core_system_entity._id in the decoded token)
     * 2. Filter mappings to return only those where acayrmp_entity_id_syen matches the entity ID from the token
     * 3. Do NOT rely on entity ID from the request payload - it should come from the token only
     */
    getAcademicYearMappingList(payload: MAcademicYearMapping): Observable<academicYearMappingControllerResponse>;
    /**
     * Get academic year mapping by ID
     * @param payload - Academic year mapping ID payload
     * @returns Observable of academic year mapping data
     */
    getAcademicYearMappingById(payload: MAcademicYearMappingGetByIdPayload): Observable<academicYearMappingByIdControllerResponse>;
    /**
     * Create or update academic year mapping
     * @param data - Academic year mapping data to save
     * @returns Observable of the save response
     */
    saveUpdateAcademicYearMapping(data: MAcademicYearMappingInsertUpdatePayload): Observable<academicYearMappingInsertUpdateControllerResponse>;
    /**
     * Delete academic year mapping
     * @param payload - Academic year mapping ID payload
     * @returns Observable of the delete response
     */
    deleteAcademicYearMapping(payload: MAcademicYearMappingDeletePayload): Observable<academicYearMappingDeleteControllerResponse>;
    /**
     * Toggle academic year mapping status
     * @param payload - Academic year mapping ID payload
     * @returns Observable of the toggle response
     */
    toggleAcademicYearMappingStatus(payload: MAcademicYearMappingToggleStatusPayload): Observable<academicYearMappingToggleStatusControllerResponse>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytAcademicYearMappingService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytAcademicYearMappingService>;
}

interface ClassProgramBranch$2 {
    _id?: string;
    acabrn_class_program_id_acacpm?: any;
    acabrn_name?: string;
    acabrn_code?: string;
    acabrn_sequence?: number;
    acabrn_isactive?: boolean;
    acabrn_islocked?: boolean;
}
interface ClassProgramConfiguration$1 {
    branchType?: boolean;
    semesterType?: boolean;
}
interface ProgramClass$3 {
    _id?: string;
    acacpm_name?: string;
    acacpm_code?: string;
    acacpm_alise_title?: string;
    acacpm_description?: string;
    acacpm_class_program_id_sygms?: {
        _id?: string;
        sygms_code?: string;
        sygms_title?: string;
        sygms_configuration?: ClassProgramConfiguration$1 | string;
    } | string;
}
declare class CideLytClassProgramBranchListComponent implements OnInit {
    private destroyRef;
    private router;
    private route;
    private appState;
    private notificationService;
    private confirmationService;
    private classProgramBranchService;
    private programClassService;
    private rightsService;
    loading: _angular_core.WritableSignal<boolean>;
    error: _angular_core.WritableSignal<string | null>;
    branches: _angular_core.WritableSignal<ClassProgramBranch$2[]>;
    totalCount: _angular_core.WritableSignal<number>;
    programId: _angular_core.WritableSignal<string | null>;
    programClasses: _angular_core.WritableSignal<ProgramClass$3[]>;
    selectedProgramClassId: _angular_core.WritableSignal<string | null>;
    breadcrumbData: _angular_core.WritableSignal<{
        id: string;
        label: string;
        icon?: string;
        url?: string;
    }[]>;
    dragHandleRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>> | undefined>;
    classProgramRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>> | undefined>;
    actionsDropdownRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>> | undefined>;
    gridConfig: _angular_core.WritableSignal<GridConfiguration<ClassProgramBranch$2>>;
    templateRenderers: _angular_core.Signal<Record<string, TemplateRef<TemplateContext<Record<string, unknown>>>>>;
    canCreate: _angular_core.Signal<boolean>;
    canEdit: _angular_core.Signal<boolean>;
    canDelete: _angular_core.Signal<boolean>;
    canView: _angular_core.Signal<boolean>;
    ngOnInit(): void;
    /**
     * Initialize breadcrumb data for list view
     */
    private initializeBreadcrumbData;
    /**
     * Load program classes for dropdown
     * Only loads programs that have branchType: true in their configuration
     */
    private loadProgramClasses;
    /**
     * Handle Program Class selection change
     */
    onProgramClassChange(programClassId: string | number | string[] | null): void;
    /**
     * Check route parameters for program ID
     */
    private checkRouteParams;
    /**
     * Check direct query parameters for program ID
     */
    private checkQueryParams;
    /**
     * Load branches from API
     */
    private loadBranches;
    /**
     * Normalize branches to ensure class program object structure is preserved for grouping
     */
    private normalizeBranchesForGrouping;
    /**
     * Update grid data
     */
    private updateGridData;
    /**
     * Handle grid events
     */
    onGridEvent(event: GridEvent<ClassProgramBranch$2>): void;
    /**
     * Handle refresh
     */
    onRefresh(): void;
    /**
     * Handle page change
     */
    onPageChange(event: any): void;
    /**
     * Handle search
     */
    onSearch(event: any): void;
    /**
     * Handle row reorder (drag and drop)
     */
    onRowReorder(event: any): void;
    /**
     * Update sequence order for branches
     */
    private updateSequenceOrder;
    /**
     * Navigate to create branch
     */
    onCreateBranch(event?: Event): void;
    /**
     * Navigate to view branch
     */
    onViewBranch(branch: ClassProgramBranch$2): void;
    /**
     * Navigate to edit branch
     */
    onEditBranch(branch: ClassProgramBranch$2): void;
    /**
     * Navigate to manage term for branch
     */
    onManageTerm(branch: ClassProgramBranch$2): void;
    /**
     * Get dropdown items for branch actions
     */
    getBranchActionDropdownItems(branch: AcaClassPrgBranchResponse): DropdownItem[];
    /**
     * Handle dropdown item click
     */
    onDropdownItemClick(item: DropdownItem, branch: ClassProgramBranch$2): void;
    /**
     * Toggle branch status
     */
    private toggleBranchStatus;
    /**
     * Toggle branch lock
     */
    private toggleBranchLock;
    /**
     * Delete branch
     */
    private deleteBranch;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytClassProgramBranchListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideLytClassProgramBranchListComponent, "cide-academics-class-program-branch-list", never, {}, {}, never, never, true, never>;
}

interface ProgramClass$2 {
    _id?: string;
    acacpm_class_program_id_sygms?: string | ICoreSygms;
    acacpm_alise_title?: string;
    acacpm_academic_year_id_acayr?: string;
    acacpm_entity_id_syen?: string;
    acacpm_education_board_id_edbrd?: string;
    acacpm_isactive?: boolean;
}
interface BranchMaster {
    _id: string;
    sygms_name?: string;
    sygms_title?: string;
    value: string;
    label: string;
}
declare class CideLytClassProgramBranchFormComponent implements OnInit, OnDestroy {
    private destroyRef;
    private fb;
    private router;
    private route;
    private location;
    private appState;
    private notificationService;
    private confirmationService;
    private classProgramBranchService;
    private programClassService;
    private generalMasterService;
    private rightsService;
    branchId: _angular_core.WritableSignal<string | null>;
    isEditMode: _angular_core.Signal<boolean>;
    isViewMode: _angular_core.WritableSignal<boolean>;
    programClasses: _angular_core.WritableSignal<ProgramClass$2[]>;
    branchMasters: _angular_core.WritableSignal<BranchMaster[]>;
    breadcrumbData: _angular_core.WritableSignal<{
        id: string;
        label: string;
        icon?: string;
        url?: string;
    }[]>;
    branchForm: FormGroup<{
        acabrn_name: _angular_forms.FormControl<string | null>;
        acabrn_code: _angular_forms.FormControl<string | null>;
        acabrn_sequence: _angular_forms.FormControl<number | null>;
        acabrn_class_program_id_acacpm: _angular_forms.FormControl<string | null>;
        acabrn_branch_id_sygms: _angular_forms.FormControl<string | null>;
        acabrn_isactive: _angular_forms.FormControl<boolean | null>;
        acabrn_islocked: _angular_forms.FormControl<boolean | null>;
    }>;
    loading: _angular_core.WritableSignal<boolean>;
    error: _angular_core.WritableSignal<string | null>;
    isLoadingData: boolean;
    ngOnInit(): void;
    /**
     * Handle program class change
     */
    onProgramClassChange(programClassId: string): void;
    /**
     * Load program classes
     * Only loads programs that have branchType: true in their configuration
     * (except in edit/view mode where we need to show the current program even if it doesn't have branchType)
     */
    private loadProgramClasses;
    /**
     * Load branch masters filtered by program code
     * The API will:
     * 1. Find general master with type "class_program_type" and code matching programCode
     * 2. Use that master's ID as sygms_id_sygms to get child branches (standard branch names)
     * All done in a single API call
     */
    private loadBranchMastersByProgramCode;
    /**
     * Load branch data
     */
    private loadBranchData;
    /**
     * Get form title
     */
    get formTitle(): string;
    /**
     * Get submit button text
     */
    get submitButtonText(): string;
    /**
     * Handle form submission
     */
    onSubmit(): void;
    /**
     * Save branch
     */
    private saveBranch;
    /**
     * Handle cancel
     */
    onCancel(): void;
    /**
     * Reset form to initial state
     */
    resetForm(): void;
    /**
     * Toggle active status on card click
     */
    onActiveCardClick(): void;
    /**
     * Toggle locked status on card click
     */
    onLockedCardClick(): void;
    /**
     * Update breadcrumb data based on mode
     */
    private updateBreadcrumbData;
    /**
     * Cleanup
     */
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytClassProgramBranchFormComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideLytClassProgramBranchFormComponent, "cide-academics-class-program-branch-form", never, {}, {}, never, never, true, never>;
}

declare class CideLytClassProgramBranchService {
    private http;
    /**
     * Get list of class program branches
     * @param payload - Query parameters for filtering/pagination
     * @returns Observable of class program branch list response
     */
    getClassProgramBranchList(payload: AcaClassPrgBranchListPayload): Observable<classPrgBranchControllerResponse>;
    /**
     * Get class program branch by ID
     * @param payload - Class program branch ID payload
     * @returns Observable of class program branch data
     */
    getClassProgramBranchById(payload: AcaClassPrgBranchGetByIdPayload): Observable<classPrgBranchByIdControllerResponse>;
    /**
     * Create or update class program branch
     * @param data - Class program branch data to save
     * @returns Observable of the save response
     */
    saveClassProgramBranch(data: AcaClassPrgBranchInsertUpdatePayload): Observable<classPrgBranchInsertUpdateControllerResponse>;
    /**
     * Delete class program branch
     * @param payload - Class program branch delete payload
     * @returns Observable of the delete response
     */
    deleteClassProgramBranch(payload: AcaClassPrgBranchDeletePayload): Observable<classPrgBranchDeleteControllerResponse>;
    /**
     * Toggle class program branch status (active/inactive)
     * @param payload - Class program branch toggle status payload
     * @returns Observable of the toggle status response
     */
    toggleClassProgramBranchStatus(payload: AcaClassPrgBranchToggleStatusPayload): Observable<classPrgBranchToggleStatusControllerResponse>;
    /**
     * Toggle class program branch lock
     * @param payload - Class program branch toggle lock payload
     * @returns Observable of the toggle lock response
     */
    toggleClassProgramBranchLock(payload: AcaClassPrgBranchToggleLockPayload): Observable<classPrgBranchToggleLockControllerResponse>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytClassProgramBranchService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytClassProgramBranchService>;
}

/**
 * Interface for class program configuration
 * This matches the configuration structure stored in general master's sygms_configuration field
 */
interface ClassProgramConfiguration {
    semesterType?: boolean;
    termType?: boolean;
    branchType?: boolean;
    termLevelUpTo?: number;
    termAdmissionLevelUpTo?: number;
    termProgramLevelOneConnected?: boolean;
    getAdmission?: boolean;
    programCategory?: string;
    [key: string]: unknown;
}

interface ProgramClass$1 {
    _id?: string;
    acacpm_alise_title?: string;
    acacpm_class_program_id_sygms?: {
        sygms_configuration?: ClassProgramConfiguration;
    };
}
interface ClassProgramTerm$1 {
    _id?: string;
    acapt_name?: string;
    acapt_code?: string;
}
interface ClassProgramBranch$1 {
    _id?: string;
    acabrn_name?: string;
    acabrn_code?: string;
}
declare class ProgramTermSectionCreateComponent implements OnInit, OnDestroy {
    private destroyRef;
    private fb;
    private router;
    private route;
    private appState;
    private notificationService;
    private confirmationService;
    private classProgramMasterService;
    private classProgramBranchService;
    private classProgramTermService;
    private programTermSectionService;
    private componentContextService;
    private rightsService;
    private classProgramConfigService;
    programTermSectionForm: FormGroup;
    activeTab: _angular_core.WritableSignal<string>;
    loading: _angular_core.WritableSignal<boolean>;
    error: _angular_core.WritableSignal<string | null>;
    programTermSectionId: _angular_core.WritableSignal<string>;
    isEditMode: _angular_core.WritableSignal<boolean>;
    isViewMode: _angular_core.WritableSignal<boolean>;
    programClasses: _angular_core.WritableSignal<ProgramClass$1[]>;
    selectedProgramClass: _angular_core.WritableSignal<ProgramClass$1 | null>;
    classProgramBranches: _angular_core.WritableSignal<ClassProgramBranch$1[]>;
    classProgramTerms: _angular_core.WritableSignal<ClassProgramTerm$1[]>;
    programClassOptions: _angular_core.WritableSignal<SelectOption$1[]>;
    classProgramBranchOptions: _angular_core.WritableSignal<SelectOption$1[]>;
    classProgramTermOptions: _angular_core.WritableSignal<(SelectOption$1 & {
        _id: string;
        acapt_name: string;
        acapt_parent_class_prog_term_acapt?: string;
    })[]>;
    programClassLoading: _angular_core.WritableSignal<boolean>;
    classProgramBranchLoading: _angular_core.WritableSignal<boolean>;
    classProgramTermLoading: _angular_core.WritableSignal<boolean>;
    showBranchDropdown: _angular_core.Signal<boolean | undefined>;
    showTermDropdown: _angular_core.Signal<boolean>;
    acacpmId: _angular_core.WritableSignal<string | null>;
    acabrnId: _angular_core.WritableSignal<string | null>;
    acaptParentId: _angular_core.WritableSignal<string | null>;
    hasParentTermInEditMode: _angular_core.WritableSignal<boolean>;
    breadcrumbData: _angular_core.WritableSignal<{
        id: string;
        label: string;
        icon?: string;
        url?: string;
    }[]>;
    constructor();
    canCreate: _angular_core.Signal<boolean>;
    canEdit: _angular_core.Signal<boolean>;
    ngOnInit(): void;
    /**
     * Update breadcrumb data based on mode
     */
    private updateBreadcrumbData;
    /**
     * Initialize component
     */
    private initializeComponent;
    /**
     * Setup listener for program class selection changes
     */
    private setupProgramClassChangeListener;
    /**
     * Load term details from API and set class program
     */
    private loadTermDetailsAndSetClassProgram;
    /**
     * Check route parameters for pre-selecting fields
     */
    private checkRouteParams;
    /**
     * Load program term section for viewing
     */
    private loadProgramTermSectionForView;
    /**
     * Load program term section for editing
     */
    private loadProgramTermSectionForEdit;
    /**
     * Load dropdown options
     */
    private loadDropdownOptions;
    /**
     * Load program classes from service
     */
    private loadProgramClasses;
    /**
     * Load branches for a specific program class
     */
    private loadBranchesForProgramClass;
    /**
     * Auto-select term for program when termType=true, termProgramLevelOneConnected=true, and termLevelUpTo <= 1
     */
    private autoSelectTermForProgram;
    /**
     * Load terms for a specific program class and branch
     */
    private loadTermsForProgramClassAndBranch;
    /**
     * Tab configuration
     */
    programTermSectionTabs(): {
        id: string;
        label: string;
        icon: string;
    }[];
    onTabChange(tab: TabItem): void;
    onSubmit(): void;
    /**
     * Mark all form controls as touched to trigger validation display
     */
    private markFormGroupTouched;
    resetForm(): void;
    /**
     * Go back to program term section list
     */
    goBackToProgramTermSectionList(): void;
    /**
     * Cancel form and navigate back to listing page
     */
    cancelForm(): void;
    /**
     * Get page title based on mode
     */
    getPageTitle(): string;
    /**
     * Cleanup when component is destroyed
     */
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgramTermSectionCreateComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgramTermSectionCreateComponent, "cide-academics-program-term-section-create", never, {}, {}, never, never, true, never>;
}

type ProgramTermSection = AcaPrgTrmSectionResponse;
interface ProgramClass {
    _id?: string;
    acacpm_code?: string;
    acacpm_alise_title?: string;
    acacpm_name?: string;
    acacpm_description?: string;
    acacpm_class_program_id_sygms?: any;
}
interface ClassProgramBranch {
    _id?: string;
    acabrn_name?: string;
    acabrn_code?: string;
}
interface ClassProgramTerm {
    _id?: string;
    acapt_code?: string;
    acapt_name?: string;
    acapt_class_program_id_acacpm?: string | {
        _id?: string;
    };
    acapt_class_program_branch_id_acabrn?: string | {
        _id?: string;
    };
    acapt_parent_class_prog_term_acapt?: string | {
        _id?: string;
    };
    children?: ClassProgramTerm[];
    level?: number;
    isExpanded?: boolean;
    hasChildren?: boolean;
}
declare class ProgramTermSectionListComponent implements OnInit {
    private destroyRef;
    private router;
    private route;
    private appState;
    private notificationService;
    private confirmationService;
    private programTermSectionService;
    private classProgramMasterService;
    private classProgramBranchService;
    private classProgramTermService;
    private rightsService;
    programTermSectionDetailsRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    programTermSectionStatusRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    actionsDropdownRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    programClassRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    termSpecializationRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    classProgramTermRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    parentClassProgramTermRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    templateRenderers: _angular_core.Signal<Record<string, TemplateRef<TemplateContext<Record<string, unknown>>>>>;
    Math: Math;
    programTermSections: _angular_core.WritableSignal<AcaPrgTrmSectionResponse[]>;
    loading: _angular_core.WritableSignal<boolean>;
    error: _angular_core.WritableSignal<string | null>;
    selectedItems: _angular_core.WritableSignal<string[]>;
    searchTerm: _angular_core.WritableSignal<string>;
    classProgramMasters: _angular_core.WritableSignal<ProgramClass[]>;
    classProgramMastersLoading: _angular_core.WritableSignal<boolean>;
    selectedClassProgram: _angular_core.WritableSignal<ProgramClass | null>;
    classProgramBranches: _angular_core.WritableSignal<ClassProgramBranch[]>;
    classProgramBranchesLoading: _angular_core.WritableSignal<boolean>;
    selectedProgramClassId: _angular_core.WritableSignal<string | null>;
    selectedBranchId: _angular_core.WritableSignal<string | null>;
    classProgramTerms: _angular_core.WritableSignal<ClassProgramTerm[]>;
    classProgramTermsLoading: _angular_core.WritableSignal<boolean>;
    selectedTermId: _angular_core.WritableSignal<string | null>;
    breadcrumbData: _angular_core.WritableSignal<{
        id: string;
        label: string;
        icon?: string;
        url?: string;
    }[]>;
    classProgramMastersOptions: _angular_core.Signal<{
        displayLabel: string;
        _id?: string;
        acacpm_code?: string;
        acacpm_alise_title?: string;
        acacpm_name?: string;
        acacpm_description?: string;
        acacpm_class_program_id_sygms?: any;
    }[]>;
    classProgramBranchesOptions: _angular_core.Signal<ClassProgramBranch[]>;
    classProgramTermOptions: _angular_core.Signal<{
        value: string;
        label: string;
        _id: string;
        acapt_name: string;
        acapt_parent_class_prog_term_acapt: string;
    }[]>;
    showBranchDropdown: _angular_core.Signal<any>;
    showTermDropdown: _angular_core.Signal<boolean>;
    filteredProgramTermSections: _angular_core.Signal<AcaPrgTrmSectionResponse[]>;
    gridConfig: _angular_core.WritableSignal<GridConfiguration<AcaPrgTrmSectionResponse>>;
    /**
     * Get action dropdown items
     */
    getActionDropdownItems(programTermSection: ProgramTermSection): DropdownItem[];
    /**
     * Handle dropdown item click
     */
    onDropdownItemClick(item: DropdownItem, programTermSection: ProgramTermSection): void;
    canCreate: _angular_core.Signal<boolean>;
    canEdit: _angular_core.Signal<boolean>;
    canDelete: _angular_core.Signal<boolean>;
    canView: _angular_core.Signal<boolean>;
    ngOnInit(): void;
    /**
     * Initialize breadcrumb data for list view
     */
    private initializeBreadcrumbData;
    /**
     * Load program term sections data
     */
    private loadProgramTermSections;
    /**
     * Normalize sections to ensure class program and term object structures are preserved for grouping
     */
    private normalizeSectionsForGrouping;
    /**
     * Update grid data
     */
    private updateGridData;
    /**
     * Handle grid events
     */
    onGridEvent(event: GridEvent<ProgramTermSection>): void;
    /**
     * Create new program term section
     */
    createProgramTermSection(): void;
    /**
     * View program term section details
     */
    viewProgramTermSection(programTermSection: ProgramTermSection): void;
    /**
     * Edit program term section
     */
    editProgramTermSection(programTermSection: ProgramTermSection): void;
    /**
     * Delete program term section
     */
    deleteProgramTermSection(programTermSection: ProgramTermSection): void;
    /**
     * Toggle program term section status
     */
    toggleProgramTermSectionStatus(programTermSection: ProgramTermSection): void;
    /**
     * Refresh data
     */
    refreshData(): void;
    /**
     * Load class program masters
     */
    private loadClassProgramMasters;
    /**
     * Handle class program selection change
     */
    onClassProgramChange(programClassId: string | number | string[] | null): void;
    /**
     * Load class program branches
     */
    private loadClassProgramBranches;
    /**
     * Handle branch selection change
     */
    onBranchChange(branchId: string | number | string[] | null): void;
    /**
     * Auto-select term for program when termType=true, termProgramLevelOneConnected=true, and termLevelUpTo <= 1
     */
    private autoSelectTermForProgram;
    /**
     * Load class program terms (simple list for dropdown)
     */
    private loadClassProgramTerms;
    /**
     * Handle program term selection change
     */
    onTermChange(termId: string | number | string[] | null): void;
    /**
     * Handle class program master search
     */
    onClassProgramMasterSearch(event: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgramTermSectionListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgramTermSectionListComponent, "cide-academics-program-term-section-list", never, {}, {}, never, never, true, never>;
}

declare class CideLytProgramTermSectionService {
    private http;
    /**
     * Get list of program term sections
     * @param payload - Query parameters for filtering/pagination
     * @returns Observable of program term section list response
     */
    getProgramTermSectionList(payload: MPrgTrmSection): Observable<prgTrmSectionControllerResponse>;
    /**
     * Get program term section by ID
     * @param payload - Program term section ID payload
     * @returns Observable of program term section data
     */
    getProgramTermSectionById(payload: MPrgTrmSectionGetByIdPayload): Observable<prgTrmSectionByIdControllerResponse>;
    /**
     * Create or update program term section
     * @param data - Program term section data to save
     * @returns Observable of the save response
     */
    saveProgramTermSection(data: MPrgTrmSectionInsertUpdatePayload): Observable<prgTrmSectionInsertUpdateControllerResponse>;
    /**
     * Delete program term section
     * @param payload - Program term section delete payload
     * @returns Observable of the delete response
     */
    deleteProgramTermSection(payload: MPrgTrmSectionDeletePayload): Observable<prgTrmSectionDeleteControllerResponse>;
    /**
     * Toggle program term section status (active/inactive)
     * @param payload - Program term section toggle status payload
     * @returns Observable of the toggle status response
     */
    toggleProgramTermSectionStatus(payload: MPrgTrmSectionToggleStatusPayload): Observable<prgTrmSectionToggleStatusControllerResponse>;
    /**
     * Toggle program term section lock status
     * @param payload - Program term section toggle lock payload
     * @returns Observable of the toggle lock response
     */
    toggleProgramTermSectionLock(payload: MPrgTrmSectionToggleLockPayload): Observable<prgTrmSectionToggleLockControllerResponse>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytProgramTermSectionService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytProgramTermSectionService>;
}

declare class CideLytEducationBoardService implements IEducationBoardService {
    private http;
    private get educationBoardUrl();
    private getBaseUrl;
    getEducationBoardList(payload?: EducationBoardSearchParams): Observable<educationBoardListControllerResponse>;
    getEducationBoardById(id: string): Observable<educationBoardByIdControllerResponse>;
    saveUpdateEducationBoard(data: AcademicsEducationBoard): Observable<educationBoardByIdControllerResponse>;
    deleteEducationBoard(id: string): Observable<educationBoardDeleteControllerResponse>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytEducationBoardService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytEducationBoardService>;
}

declare class EducationBoardListComponent implements OnInit {
    readonly shared_wrapper_setup_param: CideLytSharedWrapperSetupParam;
    private readonly destroyRef;
    private readonly educationBoardService;
    private readonly router;
    private readonly notificationService;
    private readonly confirmationService;
    private readonly rightsService;
    readonly boardDetailsRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    readonly typeRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    readonly locationRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    readonly statusRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    readonly actionsDropdownRendererTemplate: _angular_core.Signal<TemplateRef<TemplateContext<Record<string, unknown>>>>;
    readonly educationBoards: _angular_core.WritableSignal<AcademicsEducationBoard[]>;
    readonly loading: _angular_core.WritableSignal<boolean>;
    readonly canEdit: _angular_core.Signal<boolean>;
    readonly canDelete: _angular_core.Signal<boolean>;
    readonly canCreate: _angular_core.Signal<boolean>;
    createBoard(): void;
    readonly gridConfig: _angular_core.Signal<GridConfiguration<AcademicsEducationBoard>>;
    ngOnInit(): void;
    loadEducationBoards(): void;
    templateRenderers: _angular_core.Signal<Record<string, TemplateRef<TemplateContext<Record<string, unknown>>>>>;
    onGridEvent(event: GridEvent<AcademicsEducationBoard>): void;
    getActionDropdownItems(row: AcademicsEducationBoard): DropdownItem[];
    onDropdownItemClick(item: DropdownItem, row: AcademicsEducationBoard): void;
    confirmDelete(row: AcademicsEducationBoard): void;
    get dropdownConfig(): Record<string, any>;
    deleteBoard(id: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EducationBoardListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EducationBoardListComponent, "cide-academics-education-board-list", never, {}, {}, never, never, true, never>;
}

declare class EducationBoardFormComponent implements OnInit {
    shared_wrapper_setup_param: CideLytSharedWrapperSetupParam;
    private fb;
    private destroyRef;
    private educationBoardService;
    private generalMasterService;
    private router;
    private route;
    private notificationService;
    private pinCodeService;
    private countryServiceShared;
    boardForm: FormGroup;
    loading: _angular_core.WritableSignal<boolean>;
    isEditMode: _angular_core.WritableSignal<boolean>;
    boardId: string | null;
    activeTab: _angular_core.WritableSignal<string>;
    tabs: _angular_core.WritableSignal<{
        id: string;
        label: string;
    }[]>;
    typeOptions: _angular_core.WritableSignal<ICoreSygms[]>;
    categoryOptions: _angular_core.WritableSignal<ICoreSygms[]>;
    gradingSystemOptions: _angular_core.WritableSignal<ICoreSygms[]>;
    udiseOptions: _angular_core.WritableSignal<ICoreSygms[]>;
    affiliationOptions: _angular_core.WritableSignal<ICoreSygms[]>;
    rollNoOptions: _angular_core.WritableSignal<ICoreSygms[]>;
    regNoOptions: _angular_core.WritableSignal<ICoreSygms[]>;
    gradeScaleOptions: _angular_core.WritableSignal<ICoreSygms[]>;
    countryOptions: _angular_core.WritableSignal<SelectOption$1[]>;
    postalCodes: _angular_core.WritableSignal<SelectOption$1[]>;
    loadingOptions: _angular_core.WritableSignal<{
        countries: boolean;
        pinCodes: boolean;
    }>;
    private pinCodeDataMap;
    constructor();
    ngOnInit(): void;
    initForm(): void;
    loadDropdownOptions(): void;
    onCountrySearch(event: selectSearchType): void;
    onPostalCodeSearch(event: selectSearchType): void;
    onPostalCodeSelection(event: any): void;
    private processPostalCodeSelection;
    loadBoard(id: string): void;
    private getId;
    onTabChange(tab: {
        id: string;
        label: string;
    }): void;
    onSubmit(): void;
    cancel(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EducationBoardFormComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EducationBoardFormComponent, "cide-academics-education-board-form", never, {}, {}, never, never, true, never>;
}

interface SelectOption {
    value: string;
    label: string;
}
interface ProgramSectionSelectorValues {
    classProgramId?: string | null;
    branchId?: string | null;
    termId?: string | null;
    sectionId?: string | null;
}
declare class CideLytProgramSectionSelectorComponent implements OnInit, OnDestroy {
    readonly formGroup: _angular_core.InputSignal<FormGroup<any>>;
    readonly classProgramControlName: _angular_core.InputSignal<string>;
    readonly branchControlName: _angular_core.InputSignal<string>;
    readonly termControlName: _angular_core.InputSignal<string>;
    readonly sectionControlName: _angular_core.InputSignal<string>;
    readonly academicYearId: _angular_core.InputSignal<string | null>;
    readonly entityId: _angular_core.InputSignal<string | null>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly showLabels: _angular_core.InputSignal<boolean>;
    readonly gridCols: _angular_core.InputSignal<string>;
    readonly showAllPrograms: _angular_core.InputSignal<boolean>;
    readonly includeInactive: _angular_core.InputSignal<boolean>;
    readonly valuesChange: _angular_core.OutputEmitterRef<ProgramSectionSelectorValues>;
    private readonly destroyRef;
    private readonly http;
    private readonly classProgramService;
    private readonly branchService;
    private readonly sectionService;
    private readonly notificationService;
    readonly classProgramMasters: _angular_core.WritableSignal<AcaClassProgramMasterResponse[]>;
    readonly classProgramBranches: _angular_core.WritableSignal<SelectOption[]>;
    readonly classProgramTerms: _angular_core.WritableSignal<SelectOption[]>;
    readonly programTermSections: _angular_core.WritableSignal<SelectOption[]>;
    readonly classProgramMastersLoading: _angular_core.WritableSignal<boolean>;
    readonly classProgramBranchesLoading: _angular_core.WritableSignal<boolean>;
    readonly classProgramTermsLoading: _angular_core.WritableSignal<boolean>;
    readonly programTermSectionsLoading: _angular_core.WritableSignal<boolean>;
    readonly selectedClassProgram: _angular_core.WritableSignal<AcaClassProgramMasterResponse | null>;
    readonly hasSections: _angular_core.WritableSignal<boolean>;
    private isProcessingInitialValues;
    getClassProgramControl(): FormControl;
    getBranchControl(): FormControl;
    getTermControl(): FormControl;
    getSectionControl(): FormControl;
    readonly classProgramOptions: _angular_core.Signal<{
        value: string;
        label: string;
    }[]>;
    readonly showBranchDropdown: _angular_core.Signal<boolean>;
    readonly showTermDropdown: _angular_core.Signal<boolean>;
    private emitValuesChange;
    ngOnInit(): void;
    private handleInitialValues;
    ngOnDestroy(): void;
    private setupFormListeners;
    private loadClassProgramMasters;
    onClassProgramSearch(event: selectSearchType): void;
    onClassProgramChange(classProgramId: string | null | undefined): void;
    private loadClassProgramBranches;
    onBranchChange(branchId: string | null | undefined): void;
    private loadClassProgramTerms;
    onTermChange(termId: string | null | undefined): void;
    private loadProgramTermSections;
    onSectionChange(sectionId: string | null | undefined): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytProgramSectionSelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideLytProgramSectionSelectorComponent, "cide-lyt-program-section-selector", never, { "formGroup": { "alias": "formGroup"; "required": true; "isSignal": true; }; "classProgramControlName": { "alias": "classProgramControlName"; "required": false; "isSignal": true; }; "branchControlName": { "alias": "branchControlName"; "required": false; "isSignal": true; }; "termControlName": { "alias": "termControlName"; "required": false; "isSignal": true; }; "sectionControlName": { "alias": "sectionControlName"; "required": false; "isSignal": true; }; "academicYearId": { "alias": "academicYearId"; "required": false; "isSignal": true; }; "entityId": { "alias": "entityId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showLabels": { "alias": "showLabels"; "required": false; "isSignal": true; }; "gridCols": { "alias": "gridCols"; "required": false; "isSignal": true; }; "showAllPrograms": { "alias": "showAllPrograms"; "required": false; "isSignal": true; }; "includeInactive": { "alias": "includeInactive"; "required": false; "isSignal": true; }; }, { "valuesChange": "valuesChange"; }, never, never, true, never>;
}

export { AcademicYearCreateComponent, AcademicYearListComponent, CideLytAcademicYearMappingService, CideLytAcademicYearService, CideLytClassProgramBranchFormComponent, CideLytClassProgramBranchListComponent, CideLytClassProgramBranchService, CideLytEducationBoardService, CideLytProgramSectionSelectorComponent, CideLytProgramTermSectionService, EducationBoardFormComponent, EducationBoardListComponent, ProgramTermSectionCreateComponent, ProgramTermSectionListComponent, academicsRoutes };