carriera-intern-components 1.1.199 → 1.1.721

package/index.d.ts

@@ -1,5 +1,2552 @@
+import * as _angular_forms from '@angular/forms';
+import { ValidationErrors, ValidatorFn, ControlValueAccessor, NgControl, FormGroup, FormControl, UntypedFormGroup } from '@angular/forms';
+import * as _angular_core from '@angular/core';
+import { OnInit, ElementRef, AfterViewInit, ChangeDetectorRef, OnChanges, OnDestroy, AfterViewChecked, EventEmitter, SimpleChanges, TemplateRef } from '@angular/core';
+import { NgbTooltip, NgbPopover, NgbDropdown } from '@ng-bootstrap/ng-bootstrap';
+import * as carriera_intern_components from 'carriera-intern-components';
+import { ImageTransform, ImageCroppedEvent, LoadedImage } from 'ngx-image-cropper';
+import { SafeUrl, DomSanitizer } from '@angular/platform-browser';
+import { AnimationItem } from 'lottie-web';
+import * as rxjs from 'rxjs';
+import { Subject } from 'rxjs';
+import { Clipboard } from '@angular/cdk/clipboard';
+
+type FlexibleValidatorFn = (control: any) => ValidationErrors | null;
 /**
- * Generated bundle index. Do not edit.
+ * Creates a validator that ignores validation rules when the control is autofilled.
+ * This can be used by components to create form controls with autofill support.
+ * @param validators - Array of validators to apply when not autofilled
+ * @returns A validator function that bypasses validation for autofilled controls
  */
-/// <amd-module name="carriera-intern-components" />
-export * from './public-api';
+declare function ignoreWhenAutofilled(...validators: FlexibleValidatorFn[]): ValidatorFn;
+
+declare const INPUT_CHARACTER_SETS: {
+    readonly DIGITS: readonly ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+    readonly FRENCH_LETTERS: readonly ["ç", "é", "â", "ê", "î", "ô", "û", "à", "è", "ì", "ò", "ù", "ë", "ï", "ü", "æ", "œ", "ÿ"];
+    readonly LETTERS: readonly ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
+    readonly BASIC_PUNCTUATION: readonly [".", ",", "!", "?", ";", ":"];
+    readonly COMMON_SYMBOLS: readonly ["@", "#", "$", "%", "&", "*", "+", "-", "=", "_", "|", "~", "`", "^", "<", ">", "/", "|", "~", "`", "^", "<", ">", "\\"];
+    readonly BRACKETS: readonly ["(", ")", "[", "]", "{", "}"];
+    readonly QUOTES: readonly ["\"", "'", "`"];
+    readonly WHITESPACE: readonly [" ", "\t"];
+    readonly DBA_SPECIAL: readonly ["!", "#", "'", "$", "&", "%", "(", ")", "*", "+", ",", "-", ".", "/", ":", ";", "=", ">", "?", "[", "]", "\\", "^"];
+    readonly ALPHANUMERIC: ("0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z")[];
+    readonly ALPHANUMERIC_WITH_SPACES: string[];
+    readonly EMAIL_SPECIAL: readonly ["@", ".", "-", "_", "+"];
+    readonly EMAIL_CHARACTERS: ("0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "." | "@" | "+" | "-" | "_")[];
+    readonly SPECIAL_EXCEPT_NAME_FRIENDLY: ("." | "," | "!" | "?" | ";" | ":" | "@" | "#" | "$" | "%" | "&" | "*" | "+" | "-" | "=" | "_" | "|" | "~" | "`" | "^" | "<" | ">" | "/" | "\\" | "(" | ")" | "[" | "]" | "{" | "}" | "\"" | "'")[];
+    readonly NAME_CHARACTER_EXCLUSIONS: ("0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "," | "!" | "?" | ";" | ":" | "@" | "#" | "$" | "%" | "&" | "*" | "+" | "-" | "=" | "_" | "|" | "~" | "`" | "^" | "<" | ">" | "/" | "\\" | "(" | ")" | "[" | "]" | "{" | "}" | "\"" | "'")[];
+    readonly SPECIAL: ("." | "," | "!" | "?" | ";" | ":" | "@" | "#" | "$" | "%" | "&" | "*" | "+" | "-" | "=" | "_" | "|" | "~" | "`" | "^" | "<" | ">" | "/" | "\\" | "(" | ")" | "[" | "]" | "{" | "}" | "\"" | "'")[];
+};
+
+interface Driver$1 {
+    id: number;
+    firstName?: string | null;
+    lastName?: string | null;
+    fullName?: string | null;
+    owner?: boolean | null;
+    avatarFile?: AvatarFile | null;
+    colorFlag?: ColorFlag | null;
+    avatarUrl?: string | null;
+    avatarColor?: AvatarColor | null;
+    [key: string]: any;
+}
+type AvatarFile = {
+    fileId: number;
+    fileName: string;
+    url: string;
+    fileSize: number;
+    [key: string]: any;
+};
+type ColorFlag = {
+    id: number;
+    name: AvatarColor;
+};
+declare const colors: readonly ["Blue", "Green", "Red", "Yellow", "Purple", "Gold", "Light Green", "Orange", "Light Blue", "Pink", "Brown", "Gray", "Lime", "Navy", "Azure", "Magenta"];
+type AvatarColor = (typeof colors)[number];
+declare const sizes$1: readonly [18, 22, 32, 74, 160, 28];
+type Size = (typeof sizes$1)[number];
+
+type DropdownOption = {
+    id?: number;
+    [key: string]: any;
+};
+type Dispatch = {
+    id: number;
+    dispatchBoardId: number;
+    dispatcherId: number;
+    truck: Truck;
+    trailer?: Trailer | null;
+    driver: Driver;
+    coDriver?: Driver | null;
+    payType: string;
+    status?: Status | null;
+    numberOfSingleLtlLoads?: number;
+    currentLocationCoordinates?: {
+        latitude: number;
+        longitude: number;
+    };
+};
+type DispatchBoard = {
+    teamBoard: boolean;
+    id: number;
+    dispatcher: string | null;
+    count: number;
+    dispatches: Dispatch[];
+};
+type Driver = {
+    id: number;
+    firstName: string;
+    lastName: string;
+    owner?: boolean | null;
+    avatarFile?: AvatarFile | null;
+    colorFlag?: ColorFlag | null;
+    status?: number;
+    address: string | null;
+    payType: {
+        name: string;
+        id: number;
+    };
+    [key: string]: any;
+};
+type Truck = {
+    id: number;
+    truckNumber: string;
+    status: number;
+    owner: string;
+    color: TruckColor;
+    truckType: TruckType;
+    truckMakeName?: string | null;
+    model?: string | null;
+    year: number;
+};
+type TruckColor = {
+    id: number;
+    companyId?: number | null;
+    name: string;
+    code: string;
+};
+type TruckType = {
+    id: number;
+    companyId?: number | null;
+    truckNumber?: string | null;
+    name: string;
+    logoName: string;
+};
+type Trailer = {
+    id: number;
+    trailerNumber: string;
+    status: number;
+    owner: string | null;
+    trailerType: TrailerType;
+    trailerMakeName?: string | null;
+    model?: string | null;
+    year: number;
+};
+type TrailerType = {
+    id: number;
+    companyId?: number | null;
+    name: string;
+    logoName: string;
+    hasVolume?: boolean | null;
+};
+type Status = {
+    statusValue: {
+        name: string;
+        id: number;
+    };
+    statusString: string;
+    statusCheckInNumber: string;
+};
+type Broker = {
+    id?: number;
+    businessName?: string | null;
+    availableCredit?: number | null;
+    creditLimit?: number | null;
+    availableCreditType?: any | null;
+    payTerm?: any | null;
+    dnu?: boolean;
+    ban?: boolean;
+    status?: number;
+    loadsCount?: number;
+    revenue?: number | null;
+    fraudCheck?: boolean;
+};
+type DepartmentContactsPair = {
+    department?: Department$1;
+    contacts?: Contact$1[];
+};
+type Department$1 = {
+    id?: number;
+    name?: string | null;
+    count?: number;
+    companyUsers?: any | null;
+};
+type Contact$1 = {
+    id?: number;
+    brokerId?: number;
+    shipperId?: number;
+    phone?: string | null;
+    contactName?: string | null;
+    extensionPhone?: string | null;
+    department?: Department$1;
+};
+type Shipper = {
+    id?: number;
+    businessName?: string | null;
+    status?: number | null;
+    address?: Address | null;
+    longitude?: number | null;
+    latitude?: number | null;
+    receivingFrom?: string | null;
+    receivingTo?: string | null;
+    shippingFrom?: string | null;
+    shippingTo?: string | null;
+    receivingOpenTwentyFourHours?: boolean;
+    shippingOpenTwentyFourHours?: boolean;
+    pickupCount?: number;
+    deliveryCount?: number;
+};
+type Address = {
+    city?: string | null;
+    state?: string | null;
+    county?: string | null;
+    address?: string | null;
+    street?: string | null;
+    streetNumber?: string | null;
+    country?: string | null;
+    zipCode?: string | null;
+    stateShortName?: string | null;
+    addressUnit?: string | null;
+};
+type Bank = {
+    id?: number;
+    name?: string | null;
+    logoName?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+};
+type Dispatcher = {
+    id: number;
+    userId: number | null;
+    fullName: string;
+    avatarFile: AvatarFile | null;
+    departmentId: number | null;
+    colorFlag?: ColorFlag | null;
+};
+type TruckOption = {
+    id: number;
+    companyId?: number | null;
+    name: string;
+    logoName: string;
+};
+type TrailerOption = {
+    id: number;
+    companyId?: number | null;
+    name: string;
+    logoName: string;
+    hasVolume?: boolean | null;
+};
+type Hazardous = {
+    id?: number;
+    class?: number;
+    division?: number;
+    group?: string;
+    description?: string;
+    notes?: string;
+    logoName?: string;
+};
+type State = {
+    id?: number;
+    countryType?: {
+        name: string;
+        id: number;
+    };
+    stateShortName?: string;
+    stateName?: string;
+    counter?: number | null;
+};
+type Owner = {
+    id?: number;
+    name?: string | null;
+    ein?: string | null;
+};
+type FuelCard = {
+    id?: number;
+    number?: string | null;
+    brand?: string | null;
+    account?: string | null;
+};
+type PMOption = {
+    id?: number;
+    title?: string | null;
+    months?: number | null;
+    logoName?: string | null;
+};
+type ColorOption = {
+    id?: number;
+    companyId?: number | null;
+    name?: string | null;
+    code?: string | null;
+    hoverCode?: string | null;
+};
+type MakeOption = {
+    id?: number;
+    companyId?: number | null;
+    name?: string | null;
+    logoName?: string | null;
+};
+type TollOption = {
+    groupName?: string | null;
+    tollTransponders?: TollTransponderOption[] | null;
+};
+type TollTransponderOption = {
+    name?: string | null;
+    id?: number;
+};
+type Franchise = {
+    id: number;
+    businessName: string;
+    count: number;
+    fuelStopStores: FuelStopStore[];
+    isFranchise: boolean;
+    [key: string]: any;
+};
+type FuelStopStore = {
+    id: number;
+    companyId: number;
+    businessName: string;
+    store: string;
+    address: Address;
+    [key: string]: any;
+};
+type Provider = {
+    id: number;
+    name: string;
+};
+type SplitDriver = {
+    id: number;
+    firstName: string;
+    lastName: string;
+    owner?: any | null;
+    avatarFile?: AvatarFile | null;
+    colorFlag?: ColorFlag | null;
+    status?: number;
+    pendingLoadsCount?: number;
+    dispatchStatus?: Status | null;
+    payType?: {
+        name: string;
+        id: number;
+    };
+    payTypeValue?: string;
+    [key: string]: any;
+};
+type SplitDriverBoard = {
+    id: number;
+    dispatcherName: string | null;
+    isTeamBoard: boolean;
+    drivers?: SplitDriver[];
+};
+type SplitTruck = {
+    id: number;
+    truckNumber: string;
+    truckType: TruckType;
+    color?: TruckColor | null;
+    status?: number;
+    pendingLoadsCount?: number;
+    dispatchStatus?: Status | null;
+    location?: Address | null;
+    [key: string]: any;
+};
+type SplitTruckBoard = {
+    id: number;
+    dispatcherName: string | null;
+    isTeamBoard: boolean;
+    trucks?: SplitTruck[];
+};
+type SplitTrailer = {
+    id: number;
+    trailerNumber: string;
+    trailerType: TrailerType;
+    color?: TruckColor | null;
+    status?: number;
+    pendingLoadsCount?: number;
+    dispatchStatus?: Status | null;
+    location?: Address | null;
+    [key: string]: any;
+};
+type SplitTrailerBoard = {
+    id: number;
+    dispatcherName: string | null;
+    isTeamBoard: boolean;
+    trailers?: SplitTrailer[];
+};
+
+interface CaiInputConfig {
+    type?: 'text' | 'password' | 'number' | 'account';
+    name?: string;
+    required?: boolean;
+    alignment?: 'left' | 'right';
+    inverse?: boolean;
+    reveal?: number;
+    icon?: string | null;
+    iconColor?: string;
+    dropdown?: boolean | DropdownType;
+    dropdownAutocomplete?: boolean;
+    fullState?: boolean;
+    search?: boolean;
+    useOutsideSearch?: boolean;
+    add?: boolean;
+    subcontent?: string;
+    textTransform?: 'capitalize' | 'uppercase' | 'lowercase';
+    textTransformExceptions?: string[];
+    isNumberFormattingDisabled?: boolean;
+    textColor?: 'positive';
+    isAddress?: boolean;
+    isEdit?: boolean;
+    writeAddValue?: boolean;
+    placeholderBehavior?: 'dynamic' | 'fade' | 'static' | 'hidden';
+    errorBehavior?: 'dynamic' | 'static' | 'floating' | 'hidden';
+    label?: string;
+    mask?: string;
+    min?: number;
+    max?: number;
+    step?: number | 'automatic';
+    disableDecimals?: boolean;
+    prefix?: string;
+    withButtons?: boolean;
+    autocomplete?: string;
+    inTable?: boolean;
+    disabled?: boolean;
+    passwordRequirements?: boolean;
+    canOpenModal?: boolean;
+    noSeparator?: boolean;
+    squareAvatar?: boolean;
+    optionValue?: string;
+    optionLabel?: string;
+    removable?: boolean;
+    isRemovableWhenDisabled?: boolean;
+    autofocus?: boolean;
+    size?: (typeof sizes)[number];
+    customErrors?: CustomError[];
+    disabledCharacters?: string[];
+    enabledCharacters?: string[];
+    spacesAllowed?: number;
+    placeholderColor?: string;
+    strikethrough?: boolean;
+    hasRemoveModal?: boolean;
+    hasNoClearButton?: boolean;
+    hasResetButton?: boolean;
+    placeholder?: string;
+    hasStroke?: boolean;
+}
+type CustomError = {
+    name: string;
+    message: string | null;
+};
+declare const DropdownTypes: readonly ["multiple", "dispatch", "ftl-dispatch", "broker", "contact", "shipper", "bank", "dispatcher", "truck", "trailer", "subcontent", "hazardous", "state", "owner", "fuelcard", "pm", "color", "make", "toll", "fuel-stop-transaction", "provider", "split-driver", "split-truck", "split-trailer"];
+declare const sizes: readonly [22, 26];
+type DropdownType = (typeof DropdownTypes)[number];
+type DropdownArrays = DropdownOption[] | Broker[] | DispatchBoard[] | DepartmentContactsPair[] | Shipper[] | Dispatch[] | Bank[] | Dispatcher[] | TruckOption[] | TrailerOption[] | Hazardous[] | State[] | Owner[] | FuelCard[] | PMOption[] | ColorOption[] | MakeOption[] | TollOption[] | Franchise[] | Provider[] | SplitDriverBoard[] | SplitTruckBoard[] | SplitTrailerBoard[];
+type DropdownOptions = DropdownOption | Broker | Contact$1 | Shipper | Dispatch | Bank | Dispatcher | TruckOption | TrailerOption | Hazardous | State | Owner | FuelCard | PMOption | ColorOption | MakeOption | TollTransponderOption | FuelStopStore | Provider | SplitDriver | SplitTruck | SplitTrailer;
+type DropdownKeys = DropdownOption[keyof DropdownOption] | Dispatch[keyof Dispatch] | Broker[keyof Broker] | Contact$1[keyof Contact$1] | Shipper[keyof Shipper] | Bank[keyof Bank] | Dispatcher[keyof Dispatcher] | TruckOption[keyof TruckOption] | TrailerOption[keyof TrailerOption] | Hazardous[keyof Hazardous] | State[keyof State] | Owner[keyof Owner] | FuelCard[keyof FuelCard] | PMOption[keyof PMOption] | ColorOption[keyof ColorOption] | MakeOption[keyof MakeOption] | TollTransponderOption[keyof TollTransponderOption] | FuelStopStore[keyof FuelStopStore] | Provider[keyof Provider] | SplitDriver[keyof SplitDriver] | SplitTruck[keyof SplitTruck] | SplitTrailer[keyof SplitTrailer];
+type DropdownGroups = Franchise;
+type GroupedNavigationState = {
+    groupIndex: number | null;
+    optionIndex: number | null;
+};
+type KeyboardNavigationState = {
+    singleIndex: number | null;
+    groupedNavigationState: GroupedNavigationState | null;
+};
+
+interface PmItem {
+    id?: number;
+    logoName?: string | null;
+    title?: string | null;
+}
+
+declare class PmComponent implements ControlValueAccessor {
+    ngControl: NgControl | null;
+    /**
+     * List of PM items passed from the parent component.
+     * Used to render all available PM options.
+     */
+    items: _angular_core.InputSignal<PmItem[]>;
+    /**
+     * Event emitted when the "Add new" button is clicked.
+     * The parent component can listen to this and perform appropriate actions.
+     */
+    onAdd: _angular_core.OutputEmitterRef<void>;
+    onSelectionChange: _angular_core.OutputEmitterRef<PmItem | null>;
+    /**
+     * The currently selected PM item.
+     * Used to track and display the selected item's title and logo.
+     */
+    selectedPmItem: _angular_core.WritableSignal<PmItem | null>;
+    /**
+     * Disabled state for forms integration. Strongly depends on isHidden flag.
+     */
+    disabled: _angular_core.WritableSignal<boolean>;
+    /**
+   * Custom tooltip message for PM items.
+   */
+    customTooltipMessage: _angular_core.InputSignal<string>;
+    /**
+ * Custom flag for showing/hiding the PM component.
+ */
+    isHidden: _angular_core.InputSignal<boolean>;
+    /**
+     * Holder for incoming value from writeValue to resolve against items.
+     */
+    private _incomingValue;
+    onChange: (value: number | null) => void;
+    onTouched: () => void;
+    constructor(ngControl: NgControl | null);
+    /**
+     * Boolean signal indicating whether the PM popover is currently visible.
+     * Used to apply conditional styling or behavior when the popover is shown or hidden.
+     */
+    showPmPopover: _angular_core.WritableSignal<boolean>;
+    /**
+     * Called when the "Add new" button is clicked.
+     * Emits the `onAdd` event to notify the parent component.
+     */
+    onAddItem(): void;
+    /**
+     * Opens the tooltip when hovering over a PM item.
+     */
+    onShowTooltip(tooltip: NgbTooltip): void;
+    /**
+     * Closes the tooltip when the mouse leaves a PM item.
+     */
+    onHideTooltip(tooltip: NgbTooltip): void;
+    /**
+     * Called when the PM popover becomes visible.
+     */
+    onPmShown(): void;
+    /**
+     * Called when the PM popover is hidden.
+     */
+    onPmHidden(): void;
+    /**
+     * Called when a PM item is clicked.
+     * Sets the `selectedPmItem` with the clicked item's data.
+     */
+    onSelectedItem(item: PmItem): void;
+    /**
+     * Clears the selected PM item.
+     * Resets id, title and logoName.
+     */
+    onClear(): void;
+    writeValue(value: number | string | null): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PmComponent, [{ optional: true; self: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PmComponent, "cai-pm", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "customTooltipMessage": { "alias": "customTooltipMessage"; "required": false; "isSignal": true; }; "isHidden": { "alias": "isHidden"; "required": false; "isSignal": true; }; }, { "onAdd": "onAdd"; "onSelectionChange": "onSelectionChange"; }, never, never, true, never>;
+}
+
+declare class PasswordDirective implements OnInit {
+    private el;
+    /**
+     * Input property to enable or disable the password masking behavior.
+     */
+    appPassword: _angular_core.InputSignal<boolean>;
+    /**
+     * Input property to hide or show the password
+     */
+    visible: _angular_core.InputSignal<boolean>;
+    /**
+     * Input property to specify the type of the password
+     */
+    account: _angular_core.InputSignal<boolean>;
+    /**
+     * Input property to specify how many characters from the end of the
+     * password should be revealed. Defaults to 0 (fully masked).
+     */
+    reveal: _angular_core.InputSignal<number>;
+    appMask: _angular_core.InputSignal<string>;
+    max: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Stores the actual, unmasked password value,
+     * while the input element displays a masked version.
+     */
+    private realValue;
+    constructor(el: ElementRef<HTMLInputElement>);
+    /**
+     * Lifecycle hook called after Angular initializes the directive's data-bound properties.
+     * If password masking is enabled, it sets up the initial masking.
+     */
+    ngOnInit(): void;
+    /**
+     * Sets up the initial state for password masking.
+     * It reads the initial value from the input (if any) as the `realValue`
+     * and then updates the input's display to show the masked version.
+     */
+    private setupPasswordMasking;
+    /**
+     * HostListener for the 'input' event on the host element.
+     * This is the core logic for synchronizing `realValue` with user input
+     * on the masked field. It infers changes to `realValue`
+     * based on `event.data`, cursor position, and the difference in length
+     * between the input's current display value and the previous `realValue`.
+     * @param event - The InputEvent object.
+     */
+    onInput(event: InputEvent): void;
+    /**
+     * HostListener for the 'cut' event.
+     * Prevents default cut behavior to operate on `realValue`.
+     * It copies the corresponding part of `realValue` to the clipboard
+     * and updates `realValue` and the display.
+     * @param event - The ClipboardEvent object.
+     */
+    onCut(event: ClipboardEvent): void;
+    /**
+     * HostListener for the 'copy' event.
+     * Prevents default copy behavior to ensure the unmasked `realValue` segment is copied.
+     * @param event - The ClipboardEvent object.
+     */
+    onCopy(event: ClipboardEvent): void;
+    /**
+     * Updates the input element's display value with a masked version of `realValue`.
+     * Uses '•' for masked characters. Respects the `reveal` input to show
+     * a specified number of characters from the end of the password.
+     * This method is responsible for creating the visual masking.
+     */
+    private updateDisplayValue;
+    /**
+     * Sets the cursor position within the input field.
+     * This is crucial after `updateDisplayValue` changes the entire input value,
+     * to maintain a natural cursor behavior for the user.
+     * Uses `setTimeout` to ensure the operation occurs after Angular's view update.
+     * @param position - The desired cursor position.
+     */
+    private setCursorPosition;
+    /**
+     * Dispatches a custom event named 'realValueChange' from the host element.
+     * The event's `detail` property contains the unmasked `realValue`.
+     * This allows parent components (like your `InputComponent`) to listen for
+     * changes to the actual password.
+     */
+    private dispatchRealValueChange;
+    /**
+     * Public method to get the current unmasked "real" password value.
+     * @returns The real password value as a string.
+     */
+    getRealValue(): string;
+    /**
+     * Public method to set the "real" password value from outside the directive
+     * (e.g., when the parent form control's value is changed programmatically).
+     * It updates the internal `realValue` and then refreshes the masked display.
+     * @param value - The new real password value to set.
+     */
+    setRealValue(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PasswordDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PasswordDirective, "[appPassword]", never, { "appPassword": { "alias": "appPassword"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "account": { "alias": "account"; "required": false; "isSignal": true; }; "reveal": { "alias": "reveal"; "required": false; "isSignal": true; }; "appMask": { "alias": "appMask"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NumberFormatDirective implements OnInit {
+    private el;
+    /**
+     * Input property to enable or disable the number formatting.
+     * Defaults to true, meaning formatting is active by default.
+     */
+    appNumberFormat: _angular_core.InputSignal<boolean>;
+    /**
+     *
+     */
+    max: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Input property to enable or disable the number formatting.
+     * Defaults to true, meaning formatting is active by default.
+     */
+    isNumberFormattingDisabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Input property to enable or disable the number formatting.
+     * Defaults to true, meaning formatting is active by default.
+     */
+    disableDecimals: _angular_core.InputSignal<boolean>;
+    prefix: _angular_core.InputSignal<string>;
+    /**
+     * Stores the unformatted, "real" numeric value of the input.
+     * This is the value that should be used for calculations or form submissions,
+     * as opposed to the formatted display value.
+     */
+    private realValue;
+    constructor(el: ElementRef<HTMLInputElement>);
+    /**
+     * Lifecycle hook that is called after Angular has initialized all data-bound
+     * properties of a directive.
+     * If number formatting is enabled, it sets up the initial formatting.
+     */
+    ngOnInit(): void;
+    /**
+     * Initializes the number formatting on the input element.
+     * It extracts the initial numeric value from the input's current value
+     * and then updates the display with the formatted version.
+     */
+    private setupNumberFormatting;
+    /**
+     * HostListener for the 'input' event on the host element.
+     * This triggers whenever the user types or pastes content into the input.
+     * It extracts the numeric value from the current input, updates the
+     * display with the formatted number, restores the cursor position,
+     * and dispatches a 'realValueChange' event with the unformatted numeric value.
+     * @param event - The InputEvent object.
+     */
+    onInput(event: InputEvent): void;
+    /**
+     * HostListener for the 'cut' event.
+     * Prevents the default cut behavior to manually handle the value change.
+     * It reconstructs the value after the cut, extracts the numeric part,
+     * updates the display, sets the cursor, and dispatches the real value.
+     * @param event - The ClipboardEvent object.
+     */
+    onCut(event: ClipboardEvent): void;
+    /**
+     * HostListener for the 'copy' event.
+     * Prevents the default copy behavior if there's a selection to ensure
+     * that the copied text is the unformatted numeric value of the selection,
+     * rather than the potentially formatted display text.
+     * @param event - The ClipboardEvent object.
+     */
+    onCopy(event: ClipboardEvent): void;
+    /**
+     * HostListener for the 'keydown' event.
+     * Filters key presses to allow only digits, a single decimal point,
+     * and control keys (Backspace, Arrows, Tab, etc.).
+     * This helps maintain a valid numeric input format before the 'input' event fires.
+     * @param event - The KeyboardEvent object.
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * Extracts a clean numeric string from a given value.
+     * It removes any non-digit characters except for a single decimal point.
+     * It also ensures that there's only one decimal point and limits
+     * the decimal part to two digits.
+     * @param value - The string value to clean.
+     * @returns A string representing the extracted numeric value.
+     */
+    private extractNumericValue;
+    /**
+     * Updates the input element's display value with the formatted version
+     * of the current `realValue`.
+     * It uses the `NumberFormatPipe` for formatting.
+     */
+    private updateDisplayValue;
+    /**
+     * Sets the cursor position to the end of the input field.
+     * This is typically called after the input value is reformatted.
+     */
+    private setCursorToEnd;
+    /**
+     * Calculates the correct cursor position after formatting.
+     * Accounts for added or removed thousand separators and prefix.
+     * @param oldCursorPos - The cursor position before formatting
+     * @param oldValue - The value before formatting
+     * @param newValue - The value after formatting
+     * @returns The new cursor position
+     */
+    private calculateCursorPosition;
+    /**
+     * Dispatches a custom event named 'realValueChange' from the host element.
+     * The event's `detail` property contains the unformatted `realValue`.
+     * This allows parent components or other directives to listen for changes
+     * to the underlying numeric value.
+     */
+    private dispatchRealValueChange;
+    /**
+     * Public method to get the current unformatted "real" numeric value.
+     * @returns The real numeric value as a string.
+     */
+    getRealValue(): string;
+    /**
+     * Public method to set the "real" numeric value from outside the directive.
+     * It extracts the numeric part from the provided value and updates the
+     * input's display with the formatted version.
+     * @param value - The new value to set (can be formatted or unformatted).
+     */
+    setRealValue(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberFormatDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NumberFormatDirective, "[appNumberFormat]", never, { "appNumberFormat": { "alias": "appNumberFormat"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "isNumberFormattingDisabled": { "alias": "isNumberFormattingDisabled"; "required": false; "isSignal": true; }; "disableDecimals": { "alias": "disableDecimals"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MaskDirective implements OnInit {
+    private el;
+    /**
+     * The mask pattern to apply.
+     * Placeholders:
+     * '0' - Digit (0-9)
+     * 'a' - Letter (a-z, A-Z)
+     * '*' - Alphanumeric (0-9, a-z, A-Z)
+     * @example '(000) 000-0000' for a phone number.
+     */
+    appMask: _angular_core.InputSignal<string>;
+    reveal: _angular_core.InputSignal<number>;
+    /**
+     * Stores the unmasked, "real" value of the input, containing only
+     * the characters entered by the user that fit the mask placeholders.
+     */
+    private realValue;
+    constructor(el: ElementRef<HTMLInputElement>);
+    ngOnInit(): void;
+    /**
+     * HostListener for the 'input' event. This is the primary handler for
+     * formatting the value as the user types or pastes.
+     */
+    onInput(event: InputEvent): void;
+    /**
+     * HostListener for the 'paste' event. It intercepts pasted content,
+     * cleans it, and integrates it into the masked value.
+     */
+    onPaste(event: ClipboardEvent): void;
+    /**
+     * HostListener for the 'copy' event. Ensures that copying a selection
+     * from the input copies the unmasked, "real" value.
+     */
+    onCopy(event: ClipboardEvent): void;
+    /**
+     * HostListener for the 'cut' event. Ensures cutting a selection removes
+     * the corresponding part from the real value and reformats the input.
+     */
+    onCut(event: ClipboardEvent): void;
+    /**
+     * HostListener for the 'keydown' event. It validates key presses against
+     * the mask pattern, preventing invalid characters from being entered.
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * The core formatting logic. It takes a value, extracts the valid user
+     * input, applies the mask, updates the display, and dispatches the change.
+     * @param value The current value from the input field.
+     */
+    private formatValue;
+    /**
+     * Sets the cursor position to the end of the input field.
+     */
+    private setCursorToEnd;
+    /**
+     * Calculates the correct cursor position after formatting.
+     * Accounts for mask characters that are automatically inserted.
+     * @param oldCursorPos - The cursor position before formatting
+     * @param oldValue - The value before formatting
+     * @returns The new cursor position
+     */
+    private calculateCursorPosition;
+    private dispatchRealValueChange;
+    /**
+     * Public method to get the current unmasked "real" value.
+     * @returns The real value as a string.
+     */
+    getRealValue(): string;
+    /**
+     * Public method to set the "real" value from outside the directive.
+     * @param value The new value to set.
+     */
+    setRealValue(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaskDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MaskDirective, "[appMask]", never, { "appMask": { "alias": "appMask"; "required": false; "isSignal": true; }; "reveal": { "alias": "reveal"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type CastableType = 'dispatch' | 'dispatchBoard' | 'broker' | 'contact' | 'shipper' | 'bank' | 'dispatcher' | 'dropdownOption' | 'truckOption' | 'trailerOption' | 'hazardous' | 'state' | 'owner' | 'fuelCard' | 'pmOption' | 'colorOption' | 'make' | 'tollOption' | 'tollTransponderOption' | 'fuelStopStore' | 'franchise' | 'provider' | 'splitDriver' | 'splitTruck' | 'splitTrailer' | 'splitDriverBoard' | 'splitTruckBoard' | 'splitTrailerBoard';
+type CastableTypeMap = {
+    dispatch: Dispatch;
+    dispatchBoard: DispatchBoard;
+    broker: Broker;
+    contact: Contact$1;
+    shipper: Shipper;
+    bank: Bank;
+    dispatcher: Dispatcher;
+    dropdownOption: DropdownOption;
+    truckOption: TruckType;
+    trailerOption: TrailerType;
+    hazardous: Hazardous;
+    state: State;
+    owner: Owner;
+    fuelCard: FuelCard;
+    pmOption: PMOption;
+    colorOption: ColorOption;
+    make: MakeOption;
+    tollOption: TollOption;
+    tollTransponderOption: TollTransponderOption;
+    fuelStopStore: FuelStopStore;
+    franchise: Franchise;
+    provider: Provider;
+    splitDriver: SplitDriver;
+    splitTruck: SplitTruck;
+    splitTrailer: SplitTrailer;
+    splitDriverBoard: SplitDriverBoard;
+    splitTruckBoard: SplitTruckBoard;
+    splitTrailerBoard: SplitTrailerBoard;
+};
+
+declare class InputComponent implements ControlValueAccessor, AfterViewInit, OnInit {
+    ngControl: NgControl | null;
+    private cdr;
+    inputRef: ElementRef<HTMLInputElement>;
+    containerRef: ElementRef<HTMLInputElement>;
+    dropdown: NgbPopover;
+    closeTooltip: NgbPopover;
+    PasswordDirective: PasswordDirective;
+    NumberFormatDirective: NumberFormatDirective;
+    MaskDirective: MaskDirective;
+    id: _angular_core.InputSignal<string>;
+    config: _angular_core.InputSignal<CaiInputConfig>;
+    options: _angular_core.InputSignal<DropdownArrays>;
+    preselectedOptions: _angular_core.InputSignal<DropdownArrays | null>;
+    isLoading: _angular_core.InputSignal<boolean>;
+    hideValidation: _angular_core.InputSignal<boolean>;
+    showNoResults: _angular_core.InputSignal<boolean>;
+    preselectedUnit: _angular_core.InputSignal<string | null>;
+    unassignedCount: _angular_core.InputSignal<number>;
+    openGroup: _angular_core.WritableSignal<number | null>;
+    isDropdownOpen: _angular_core.WritableSignal<boolean>;
+    closing: _angular_core.WritableSignal<boolean>;
+    canTooltipBeVisible: _angular_core.WritableSignal<boolean>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    value: _angular_core.WritableSignal<string>;
+    searchValue: _angular_core.WritableSignal<string>;
+    visible: _angular_core.WritableSignal<boolean>;
+    selectedOption: _angular_core.WritableSignal<DropdownOptions | null>;
+    multipleSelectedOptions: _angular_core.WritableSignal<DropdownOptions[]>;
+    focused: _angular_core.WritableSignal<boolean>;
+    hovered: _angular_core.WritableSignal<boolean>;
+    isAdding: _angular_core.WritableSignal<boolean>;
+    isAutofilled: _angular_core.WritableSignal<boolean>;
+    isFocusedWithMouseClick: _angular_core.WritableSignal<boolean>;
+    foldedBoards: _angular_core.WritableSignal<number[]>;
+    randomAutocomplete: _angular_core.WritableSignal<string>;
+    keyboardNavigationState: _angular_core.WritableSignal<KeyboardNavigationState>;
+    dropdownOptions: _angular_core.Signal<DropdownOptions[]>;
+    hasText: _angular_core.Signal<boolean>;
+    containerWidth: _angular_core.WritableSignal<number>;
+    step: _angular_core.Signal<number>;
+    isGroupedDropdown: _angular_core.Signal<boolean>;
+    onBlur: _angular_core.OutputEmitterRef<void>;
+    onFocused: _angular_core.OutputEmitterRef<void>;
+    onReset: _angular_core.OutputEmitterRef<void>;
+    onValueChange: _angular_core.OutputEmitterRef<string | number | null>;
+    onOptionAdded: _angular_core.OutputEmitterRef<string>;
+    onAdd: _angular_core.OutputEmitterRef<void>;
+    onSelectionChange: _angular_core.OutputEmitterRef<any>;
+    onSelectedObject: _angular_core.OutputEmitterRef<DropdownOptions | null>;
+    onSelectedGroup: _angular_core.OutputEmitterRef<carriera_intern_components.Franchise | null>;
+    onClear: _angular_core.OutputEmitterRef<void>;
+    onAutofill: _angular_core.OutputEmitterRef<void>;
+    onScrolledToBottom: _angular_core.OutputEmitterRef<void>;
+    onScrolledToBottomGroup: _angular_core.OutputEmitterRef<void>;
+    onSearch: _angular_core.OutputEmitterRef<string>;
+    onValueAdded: _angular_core.OutputEmitterRef<string | number | null>;
+    onRemove: _angular_core.OutputEmitterRef<void>;
+    onHoverRemove: _angular_core.OutputEmitterRef<boolean>;
+    dropdownPopperOptions: (options?: Partial<Record<string, unknown>>) => Partial<Record<string, unknown>>;
+    constructor(ngControl: NgControl | null, cdr: ChangeDetectorRef);
+    onAutofilled(): void;
+    clearAutofillFlag(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private setupAutofillDetection;
+    private updateContainerWidth;
+    onInput(event: Event): void;
+    onRealValueChange(event: CustomEvent): void;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    dispatchOnChange(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Writes a new value to the element. (ControlValueAccessor)
+     */
+    writeValue(value: any): void;
+    /**
+     * Increments the value of a number input by the current step.
+     */
+    increment(event?: MouseEvent): void;
+    /**
+     * Decrements the value of a number input by the current step.
+     */
+    decrement(event?: MouseEvent): void;
+    /**
+     * Toggles the visibility of the password input.
+     * @param event - The MouseEvent that triggered the toggle.
+     */
+    toggleVisibility(event?: MouseEvent): void;
+    /**
+     * Sets the value in the actual HTML input element or updates the
+     * "real" value in the associated directive.
+     */
+    setValue(): void;
+    /**
+     * Focuses the input element.
+     * Prevents the default action of the mouse event to avoid unintended behaviors
+     * like double focus or focus loss.
+     * @param event - The MouseEvent that initiated the focus action.
+     */
+    focus(event?: MouseEvent): void;
+    /**
+     * Called when the input element receives focus (focus event).
+     */
+    onFocus(event: FocusEvent): void;
+    /**
+     * Called when the input element loses focus (blur event).
+     */
+    dispatchOnBlur(): void;
+    toggleHovered(value: boolean): void;
+    /**
+     * Resets the input field's value to an empty string.
+     */
+    reset(event?: MouseEvent): void;
+    onClearHover(value: boolean): void;
+    closeDropdown(addNew?: boolean): void;
+    openDropdown(): void;
+    randomizeAutocomplete(): string;
+    /**
+     * Type guard that checks if a given property exists on an object.
+     * @param obj The object to check.
+     * @param prop The property to check for.
+     * @returns `true` if `prop` exists on `obj`, `false` otherwise.
+     */
+    hasProperty<T extends object>(obj: T, prop: PropertyKey): prop is keyof T;
+    /**
+     * Stops event propagation to prevent parent popover from closing
+     * @param event - The event to stop
+     */
+    stopEventPropagation(event: Event): void;
+    handleMultipleSelection(option: DropdownOptions, optionValue: keyof DropdownOptions): void;
+    /**
+     * Handles when an option is selected from the dropdown.
+     * @param option - The selected option.
+     * @param event - The MouseEvent that initiated the selection action.
+     */
+    handleOption(option: DropdownOptions, event?: MouseEvent): void;
+    isSelectedOption(option: DropdownOptions): boolean;
+    /**
+     * Adds a new option to the dropdown.
+     * @param option - The option to add.
+     */
+    addOption(): void;
+    /**
+     * Handles when the user clicks on the "ADD NEW" button in the dropdown.
+     * It sets the `isAdding` signal to `true`, closes the dropdown, and focuses the input.
+     * @param event - The MouseEvent that initiated the action.
+     */
+    handleAddingOption(event?: MouseEvent): void;
+    fold(boardId: number, event?: MouseEvent, group?: DropdownGroups): void;
+    /**
+     * Type-safe casting method for templates.
+     * Usage in template: cast(value, 'dispatch') or cast(value, 'broker'), etc.
+     * @param value - The value to cast
+     * @param type - The type string (e.g., 'dispatch', 'broker', 'contact')
+     * @returns The casted value or null
+     */
+    cast<T extends CastableType>(value: unknown, type: T): CastableTypeMap[T] | null;
+    /**
+     * Handles infinite scroll event when dropdown is scrolled to bottom
+     * Emits an event that parent components can listen to for loading more data
+     */
+    onDropdownScrolledToBottom(isGroup?: boolean): void;
+    onDropdownBackgroundClick(event: MouseEvent): void;
+    onDropdownIconClick(event: MouseEvent): void;
+    acceptSelection(event: KeyboardEvent): void;
+    handleArrowKeys(event: KeyboardEvent): void;
+    handleFirstAndLastSelection(event: KeyboardEvent): void;
+    startKeyboardNavigation(): void;
+    setKeyboardNavigationState(singleIndex: number | null, groupedNavigationState: GroupedNavigationState | null): void;
+    handleDropdownKeyboardNavigation(event: KeyboardEvent): void;
+    handleNumberKeyboardNavigation(event: KeyboardEvent): void;
+    handlePasswordKeyboardNavigation(event: KeyboardEvent): void;
+    handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputComponent, "cai-input", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "preselectedOptions": { "alias": "preselectedOptions"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "hideValidation": { "alias": "hideValidation"; "required": false; "isSignal": true; }; "showNoResults": { "alias": "showNoResults"; "required": false; "isSignal": true; }; "preselectedUnit": { "alias": "preselectedUnit"; "required": false; "isSignal": true; }; "unassignedCount": { "alias": "unassignedCount"; "required": false; "isSignal": true; }; }, { "onBlur": "onBlur"; "onFocused": "onFocused"; "onReset": "onReset"; "onValueChange": "onValueChange"; "onOptionAdded": "onOptionAdded"; "onAdd": "onAdd"; "onSelectionChange": "onSelectionChange"; "onSelectedObject": "onSelectedObject"; "onSelectedGroup": "onSelectedGroup"; "onClear": "onClear"; "onAutofill": "onAutofill"; "onScrolledToBottom": "onScrolledToBottom"; "onScrolledToBottomGroup": "onScrolledToBottomGroup"; "onSearch": "onSearch"; "onValueAdded": "onValueAdded"; "onRemove": "onRemove"; "onHoverRemove": "onHoverRemove"; }, never, never, true, never>;
+}
+
+declare const supportedFileTypes: readonly ["mp4", "mov", "avi", "pdf", "jpg", "jpeg", "png", "gif"];
+type FileExtension = (typeof supportedFileTypes)[number];
+interface AppFile {
+    fileId?: number;
+    fileName: string;
+    baseName: string;
+    type: FileExtension;
+    size: number;
+    imagePreviewUrl?: string;
+    pageCount?: number;
+    file: File | null;
+    tags: number[];
+    tagChanged: boolean;
+    fileNameChanged: boolean;
+}
+
+interface FileResponse {
+    fileId?: number;
+    fileName?: string | null;
+    url?: string | null;
+    fileSize?: number | null;
+    tags?: Array<string> | null;
+    tagGeneratedByUser?: boolean;
+    updatedAt?: string | null;
+    companyUserId?: number | null;
+}
+
+interface DocumentTag {
+    tagId: number;
+    tagName: string;
+}
+
+declare enum DropZoneVariant {
+    DOCUMENT = "document",
+    VIDEO = "video",
+    PROFILE = "profile",
+    COVER = "cover",
+    LOGO = "logo"
+}
+
+/**
+ * A component that provides a user interface for file uploading via
+ * drag-and-drop or a file input dialog. It displays previews of the
+ * selected files in a carousel.
+ */
+declare class DropZoneComponent implements OnChanges, OnDestroy, AfterViewChecked {
+    private sanitizer;
+    zoomValue: _angular_core.WritableSignal<number>;
+    smallView: _angular_core.WritableSignal<boolean>;
+    cropHeight: _angular_core.WritableSignal<number>;
+    cropWidth: _angular_core.WritableSignal<number>;
+    driver: _angular_core.WritableSignal<Driver$1>;
+    transform: ImageTransform;
+    imageChangedEvent: Event | null;
+    croppedImage: SafeUrl | null;
+    showCropper: _angular_core.WritableSignal<boolean>;
+    isCropperReady: _angular_core.WritableSignal<boolean>;
+    originalImageWidth: number;
+    originalImageHeight: number;
+    private cropperResultFile;
+    private cropperPreviewUrl;
+    deletedDocs: _angular_core.WritableSignal<number[]>;
+    dragMode: _angular_core.WritableSignal<boolean>;
+    onDragover: _angular_core.WritableSignal<boolean>;
+    invalidFileSize: _angular_core.WritableSignal<boolean>;
+    isLoadingSkeleton: _angular_core.WritableSignal<boolean>;
+    skeletonCount: _angular_core.WritableSignal<number>;
+    private lottieAnimation;
+    temporaryImageFile: AppFile | null;
+    drawerViewportWidth: _angular_core.WritableSignal<number>;
+    private drawerRo;
+    private drawerEl;
+    crop: _angular_core.InputSignal<boolean>;
+    size: _angular_core.InputSignal<string | undefined>;
+    rounded: _angular_core.InputSignal<boolean>;
+    deletedFileIds: _angular_core.InputSignal<number[]>;
+    maxCountFiles: _angular_core.InputSignal<number>;
+    isDetailsSlider: _angular_core.InputSignal<boolean>;
+    isDrawerMode: _angular_core.InputSignal<boolean>;
+    isCoverDetails: _angular_core.InputSignal<boolean>;
+    maxFileSize: _angular_core.InputSignal<number>;
+    isDocumentsMode: _angular_core.InputSignal<boolean>;
+    documentsDropZoneOpen: _angular_core.InputSignal<boolean>;
+    files: FileResponse[];
+    dropZoneVariant: typeof DropZoneVariant;
+    onDeletedFileIds: EventEmitter<number[]>;
+    onDocsChange: EventEmitter<AppFile[]>;
+    onDocumentPreviewClick: EventEmitter<{
+        fileId: number;
+    }>;
+    onDocumentFileNameChange: EventEmitter<{
+        fileId?: number;
+        newFileName: string;
+    }>;
+    onCropPendingChange: EventEmitter<boolean>;
+    onDocumentDropZoneOpenChange: EventEmitter<boolean>;
+    inputRange: ElementRef<HTMLInputElement>;
+    dropZoneContainer: ElementRef<HTMLElement>;
+    docsViewport?: ElementRef<HTMLElement>;
+    coverUrl: string;
+    profileUrl: string;
+    logoUrl: string;
+    /**
+     * A input that holds an FormGroup object that is used to update the form validity when the crop mode is closed.
+     */
+    parentForm: _angular_core.InputSignal<FormGroup<any> | null>;
+    /**
+      * A signal that holds an array of `AppFile` objects representing the files
+      * that have been selected or dropped by the user.
+   
+      */
+    variant: _angular_core.InputSignal<string>;
+    /**
+     * Input that holds an array of `DocumentTag` objects representing the tags for the documents.
+     */
+    documentTags: _angular_core.InputSignal<DocumentTag[]>;
+    /**
+     * Injects the DocumentService for file processing tasks like
+     * thumbnail generation and PDF page counting.
+     * @private
+     */
+    private documentService;
+    /**
+     * An array of file extensions that should be excluded from the supported list.
+     * @defaultValue `[]` (an empty array)
+     * @type {FileExtension[]}
+     */
+    excludedFileTypes: _angular_core.InputSignal<("mp4" | "mov" | "avi" | "pdf" | "jpg" | "jpeg" | "png" | "gif")[]>;
+    /**
+     * The base array of all file extensions that are generally allowed.
+     * Supported file types will be derived from this list, after excluding
+     * any types specified in `excludedFileTypes`.
+     *
+     * @defaultValue `['avi', 'mov', 'mp4', 'pdf', 'gif', 'png', 'jpg', 'jpeg']`
+     * @type {FileExtension[]}
+     */
+    fileTypes: _angular_core.InputSignal<("mp4" | "mov" | "avi" | "pdf" | "jpg" | "jpeg" | "png" | "gif")[]>;
+    constructor(sanitizer: DomSanitizer);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewChecked(): void;
+    private clampDrawerIndex;
+    private setDrawerRo;
+    private clearDrawerRo;
+    emitDocs(): void;
+    animationCreated(animation: AnimationItem): void;
+    private playDropAnimation;
+    private stopDropAnimation;
+    getTagIds(tags: string[]): number[];
+    populateDocs(currentFiles: FileResponse[] | AppFile[]): Promise<void>;
+    fetchFileAsFile(fileResponse: FileResponse): Promise<File | null>;
+    updateRangeBackground(input: HTMLInputElement): void;
+    cropDimensions(): void;
+    private setImagePreviewUrl;
+    ratioHelper(): number;
+    onZoomChange(event: Event): void;
+    fileChangeEvent(event: Event): void;
+    imageCropped(event: ImageCroppedEvent): void;
+    private setCropperFile;
+    private createFileFromBlob;
+    private setCropperFileFromObjectUrl;
+    private updateCropperPreviewUrl;
+    private clearCropperPreviewUrl;
+    imageLoaded(image: LoadedImage): void;
+    cropperReady(): void;
+    loadImageFailed(): void;
+    onTransformChange(event: ImageTransform): void;
+    cancelCrop(): void;
+    submitCrop(initial?: boolean): void;
+    /**
+     * A computed signal that derives the list of currently supported file extensions.
+     * It filters the base `fileTypes` array, removing any extensions present
+     * in the `excludedFileTypes` input.
+     */
+    supportedFileTypes: _angular_core.Signal<("mp4" | "mov" | "avi" | "pdf" | "jpg" | "jpeg" | "png" | "gif")[]>;
+    /**
+     * A signal that holds an array of `AppFile` objects representing the files
+     * that have been selected or dropped by the user.
+     */
+    docs: _angular_core.WritableSignal<AppFile[]>;
+    /**
+     * A signal that acts as a boolean flag. It is set to `true` when the user
+     * attempts to upload a file with an unsupported extension.
+     */
+    unsupported: _angular_core.WritableSignal<boolean>;
+    /**
+     * Handles the 'change' event from the hidden file input. It extracts the
+     * selected files and passes them to the `processFiles` method.
+     * @param event The `Event` object from the file input element.
+     */
+    onInput(event: Event): void;
+    onDrop(event: DragEvent): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDragEnter(event: DragEvent): void;
+    onDocumentDragEnter(event: DragEvent): void;
+    onDocumentDragOver(event: DragEvent): void;
+    onWindowDragLeave(event: DragEvent): void;
+    onDocumentDrop(event: DragEvent): void;
+    /**
+     * Resets the drag state when drag operation ends.
+     */
+    private resetDragState;
+    skeletonItems: _angular_core.Signal<unknown[]>;
+    /**
+     * Asynchronously processes a list of files. For each file, it validates
+     * the extension against `supportedFileTypes`. If valid, it generates a
+     * thumbnail, counts pages for PDFs, creates an `AppFile` object, and adds
+     * it to the `docs` signal. If any file is unsupported, the `unsupported`
+     * flag is set.
+     * @param files The `FileList` object to be processed.
+     */
+    processFiles(files: FileList): Promise<void>;
+    /**
+     * Handles the download action for a specific file.
+     * Note: This is a placeholder and currently only logs the file name.
+     * @param fileName The name of the file to be downloaded.
+     */
+    handleDownload(fileName: string): void;
+    /**
+     * A ViewChild reference to the native `<input type='file'>` element.
+     * Used to programmatically trigger the file selection dialog.
+     */
+    inputRef: ElementRef<HTMLInputElement>;
+    /**
+     * Resets the component's state after an unsupported file type error
+     * by setting the `unsupported` signal to `false`.
+     */
+    cancel(): void;
+    /**
+     * Programmatically triggers a click on the hidden file input element,
+     * which opens the system's file selection dialog.
+     */
+    handleClickToAdd(): void;
+    /**
+     * Deletes a file from the preview list. It filters the `docs` array to
+     * remove the specified file and adjusts the carousel position.
+     * @param fileName The name of the file to be deleted.
+     */
+    handleDelete(fileName: string): void;
+    /**
+     * A signal that stores the current index for the file preview carousel.
+     * This determines which part of the carousel is visible.
+     */
+    carouselIndex: _angular_core.WritableSignal<number>;
+    /**
+     * A computed signal that calculates the CSS `translateX` value for the
+     * carousel container. This creates the sliding effect based on the
+     * `carouselIndex`.
+     */
+    carouselTransform: _angular_core.Signal<string>;
+    /**
+     * Navigates the carousel one step to the left by decrementing the
+     * `carouselIndex`. The index will not go below 0.
+     */
+    carouselLeft(): void;
+    /**
+     * Navigates the carousel one step to the right by incrementing the
+     * `carouselIndex`. The index will not exceed the maximum possible value
+     * based on the number of documents.
+     */
+    carouselRight(): void;
+    carouselVisibleCount(): number;
+    isCarouselAtEnd(): boolean;
+    handleTagChange(event: {
+        fileName: string;
+        tag: DocumentTag | null;
+    }): void;
+    handleFileNameChange(event: {
+        fileId?: number;
+        newFileName: string;
+    }): void;
+    setInvalid(): void;
+    resetInput(): void;
+    clearInvalid(): void;
+    handleDocumentPreviewClick(event: {
+        fileId: number;
+    }): void;
+    downloadAllFiles(): void;
+    onCancel(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropZoneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropZoneComponent, "cai-drop-zone", never, { "crop": { "alias": "crop"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "deletedFileIds": { "alias": "deletedFileIds"; "required": false; "isSignal": true; }; "maxCountFiles": { "alias": "maxCountFiles"; "required": false; "isSignal": true; }; "isDetailsSlider": { "alias": "isDetailsSlider"; "required": false; "isSignal": true; }; "isDrawerMode": { "alias": "isDrawerMode"; "required": false; "isSignal": true; }; "isCoverDetails": { "alias": "isCoverDetails"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "isDocumentsMode": { "alias": "isDocumentsMode"; "required": false; "isSignal": true; }; "documentsDropZoneOpen": { "alias": "documentsDropZoneOpen"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; }; "parentForm": { "alias": "parentForm"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "documentTags": { "alias": "documentTags"; "required": false; "isSignal": true; }; "excludedFileTypes": { "alias": "excludedFileTypes"; "required": false; "isSignal": true; }; "fileTypes": { "alias": "fileTypes"; "required": false; "isSignal": true; }; }, { "onDeletedFileIds": "onDeletedFileIds"; "onDocsChange": "onDocsChange"; "onDocumentPreviewClick": "onDocumentPreviewClick"; "onDocumentFileNameChange": "onDocumentFileNameChange"; "onCropPendingChange": "onCropPendingChange"; "onDocumentDropZoneOpenChange": "onDocumentDropZoneOpenChange"; }, never, never, true, never>;
+}
+
+declare enum eGeneralActions {
+    ADD = "Add",
+    ADD_LOWERCASE = "add",
+    ADD_NEW_ITEM = "Add New Item",
+    UPDATE = "Update",
+    UPDATE_LOWERCASE = "update",
+    DELETE = "Delete",
+    DELETE_LOWERCASE = "delete",
+    EDIT = "Edit",
+    EDIT_LOWERCASE = "edit",
+    EDIT_UPPERCASE = "EDIT",
+    SAVE = "Save",
+    SAVE_LOWERCASE = "save",
+    CANCEL = "Cancel",
+    CANCEL_LOWERCASE = "cancel",
+    ENTER = "Enter",
+    ESCAPE = "Escape",
+    CONFIRM = "Confirm",
+    CONFIRM_LOWERCASE = "confirm",
+    SET = "Set",
+    SET_LOWERCASE = "set",
+    REMOVE = "Remove",
+    REMOVE_LOWERCASE = "remove",
+    SELECT = "Select",
+    SELECT_LOWERCASE = "select",
+    SEARCH = "Search",
+    SEARCH_LOWERCASE = "search",
+    SELECT_ALL = "Select All",
+    SELECT_REMAINING = "Select Remaining",
+    CLEAR_SELECTED = "Clear Selected",
+    ACTIVATE = "Activate",
+    ACTIVATE_LOWERCASE = "activate",
+    DEACTIVATE = "deactivate",
+    DEACTIVATE_LOWERCASE = "deactivate",
+    CLOSE = "Close",
+    CLOSE_LOWERCASE = "close",
+    CLOSE_UPPERCASE = "CLOSE",
+    OPEN = "Open",
+    OPEN_LOWERCASE = "open",
+    NEXT = "Next",
+    NEXT_LOWERCASE = "next",
+    PREVIOUS = "Previous",
+    PREVIOUS_LOWERCASE = "previous",
+    CLEAR = "Clear",
+    CLEAR_LOWERCASE = "clear",
+    CLEAR_ALL = "Clear All",
+    SHOW_MORE = "show more",
+    OPEN_MODAL = "open-modal",
+    EXPAND = "Expand",
+    EXPAND_LOWERCASE = "expand",
+    EXPAND_UPPERCASE = "EXPAND",
+    COLLAPSE = "Collapse",
+    COLLAPSE_LOWERCASE = "collapse",
+    COLLAPSE_UPPERCASE = "COLLAPSE",
+    SORT_BY = "Sort By",
+    COPY = "Copy",
+    COPIED = "Copied"
+}
+
+interface ScrollChange {
+    indx: number;
+    scrollOffset: number;
+    cycleSize: number;
+    type: string;
+}
+
+declare class CalendarDateTimePickerService {
+    index$: Subject<ScrollChange>;
+    indexAuto$: Subject<number>;
+    scrollToDate: Subject<string>;
+    dateChanged: Subject<any>;
+    selectedIndex: number;
+    scrolledIndexChange: rxjs.Observable<ScrollChange>;
+    scrollToAutoIndex: rxjs.Observable<number>;
+    private scrolledScroll;
+    constructor();
+    set setAutoIndex(number: number);
+    set scrolledScrollItem(name: string);
+    get selectedScroll(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarDateTimePickerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CalendarDateTimePickerService>;
+}
+
+interface IMultipleInput {
+    id?: number;
+    value: string | number;
+    second_value?: string | number;
+    logoName?: string;
+    isImg?: boolean;
+    isSvg?: boolean;
+    folder?: string;
+    subFolder?: string;
+    logoType?: string;
+    isOwner?: boolean;
+    isProgressBar?: boolean;
+    isCounter?: boolean;
+}
+interface ICaInputDateTimePicker {
+    name: string;
+    isIconHidden?: boolean;
+    customClass?: string;
+    isDisabled?: boolean;
+    isFutureDateDisabled?: boolean;
+    expiredDateInvalid?: boolean;
+    isFromDate?: boolean;
+}
+interface ICaInputWithDropdown {
+    withText: boolean;
+    svg: boolean;
+    image: boolean;
+    iconsPath?: string;
+    activeItemIconKey?: string;
+    url?: string;
+    nameInitialsInsteadUrl?: string;
+    template?: string;
+    color?: string;
+    class?: string;
+    remove?: boolean;
+}
+interface ICaInput {
+    id?: number;
+    name: string;
+    type: string;
+    label?: string;
+    labelInInput?: boolean;
+    placeholder?: string;
+    placeholderIcon?: string;
+    placeholderIconRightSide?: string;
+    isPlaceHolderIconRightSideDynamicColor?: boolean;
+    placeholderIconFolllowTextOnRightSide?: string;
+    placeholderIconColor?: string;
+    placeholderWithLabel?: boolean;
+    placeholderText?: string;
+    placeholderInsteadOfLabel?: boolean;
+    inputCursorOnRightSide?: boolean;
+    isRequired?: boolean;
+    isDisabled?: boolean;
+    pattern?: string;
+    autocomplete?: string;
+    showCount?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    minValue?: number;
+    maxValue?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    mask?: string;
+    textTransform?: 'capitalize' | 'uppercase' | 'lowercase' | 'capitalizedcase';
+    textAlign?: string | 'center';
+    blackInput?: boolean;
+    blueInput?: boolean;
+    incorrectInput?: boolean;
+    dangerMark?: boolean;
+    autoFocus?: boolean;
+    hideClear?: boolean;
+    hideRequiredCheck?: boolean;
+    hideErrorMessage?: boolean;
+    hideDangerMark?: boolean;
+    hideDropdownArrow?: boolean;
+    requiredLabel?: boolean;
+    errorInsideInput?: boolean;
+    removeInput?: boolean;
+    readOnly?: boolean;
+    thousandSeparator?: boolean;
+    priceSeparator?: boolean;
+    priceSeparatorLimitation?: number;
+    loadingSpinner?: {
+        size?: string;
+        color?: string;
+        isLoading?: boolean;
+    };
+    addressFlag?: string;
+    customClass?: string;
+    isIconInput?: boolean;
+    isValidIcon?: boolean;
+    inputIcon?: string;
+    multipleInputValues?: {
+        options: IMultipleInput[];
+        customClass: string;
+    };
+    multipleLabel?: {
+        labels: string[];
+        searchLabels?: string[];
+        customClass: string;
+    };
+    isInputBackgroundRemoved?: boolean;
+    isBlueText?: boolean;
+    commands?: {
+        active?: boolean;
+        type?: string;
+        firstCommand?: {
+            popup?: {
+                name?: string;
+                backgroundColor?: string;
+            };
+            name?: string;
+            svg?: string;
+        };
+        secondCommand?: {
+            popup?: {
+                name?: string;
+                backgroundColor?: string;
+            };
+            name?: string;
+            svg?: string;
+        };
+        thirdCommand?: {
+            popup?: {
+                name?: string;
+                backgroundColor?: string;
+            };
+            name?: string;
+            svg?: string;
+        };
+        setTimeout?: number;
+        blueCommands?: boolean;
+    };
+    defaultValue?: string;
+    isDropdown?: boolean;
+    dropdownWidthClass?: string;
+    dropdownImageInput?: ICaInputWithDropdown | null;
+    isInvalidSearchInDropdown?: boolean;
+    selectedDropdown?: boolean;
+    mergeDropdownBodyWithInput?: boolean;
+    hideAllItemsInInputDropdown?: boolean;
+    isBlueDropdown?: boolean;
+    isItemSelected?: boolean;
+    isDisplayingCustomPeriodRange?: boolean;
+    isUsingCustomPeriodRange?: boolean;
+    isDispatchLocationDropdown?: boolean;
+    dropdownLabel?: boolean;
+    dropdownLabelNew?: boolean;
+    multiselectDropdown?: boolean;
+    multiSelectDropdownActive?: boolean;
+    multiSelectItemRange?: boolean;
+    isFromDate?: boolean;
+    hideColorValidations?: boolean;
+    expiredDateInvalid?: boolean;
+    isFutureDateDisabled?: boolean;
+    fixedPlacholder?: string;
+    statusStyle?: boolean;
+    isIconHidden?: boolean;
+    isRemovedIconMovedOnLeft?: boolean;
+    removeLeadingZero?: boolean;
+    negativeLeadingZero?: boolean;
+    isHoverRow?: boolean;
+    minutesGapFive?: boolean;
+    updateAsTouchedOnEdit?: boolean;
+    transparentInput?: boolean;
+    preventTyping?: boolean;
+}
+
+interface CaiDateTimeConfig extends ICaInput {
+    inTable?: boolean;
+    isBilling?: boolean;
+    inverse?: boolean;
+    hasStroke?: boolean;
+    size?: number;
+    customErrors?: CustomError[];
+}
+
+type InputChangeValue = string | number | Date;
+declare class CaiInputDatetimePickerComponent implements AfterViewInit, ControlValueAccessor, OnDestroy {
+    superControl: NgControl;
+    private calendarService;
+    id: string;
+    inputConfig: CaiDateTimeConfig;
+    formFormat?: string;
+    clearInputEvent: EventEmitter<boolean>;
+    blurInputEvent: EventEmitter<boolean>;
+    dateTimePopover: NgbPopover;
+    t2: NgbPopover;
+    showDateInput: boolean;
+    dateTimeInputDate: Date;
+    dateTimeIntDate: Date;
+    selectionInput: number;
+    private dateTimeMainTimer;
+    private focusBlur;
+    private timeoutCleaner;
+    private justEnteredDatePicker;
+    eGeneralActions: typeof eGeneralActions;
+    isTouchedInput: boolean;
+    isFocusInput: boolean;
+    preventBlur: boolean;
+    valueAfterWriteValue: string;
+    newInputChanged: boolean;
+    isDisabled: _angular_core.Signal<boolean | undefined>;
+    selectLastOneForSelectionEmitter: EventEmitter<boolean>;
+    selectLastOneAfterMouseUpEmitter: EventEmitter<boolean>;
+    onDatePasteEmitter: EventEmitter<ClipboardEvent>;
+    onFocusEmitter: EventEmitter<FocusEvent>;
+    changeSelectionEmmiter: EventEmitter<{
+        e: KeyboardEvent;
+        noPreventDefault: boolean;
+    }>;
+    setSelectionEmmiter: EventEmitter<{
+        preventDefault: () => void;
+        stopPropagation: () => void;
+        target: any;
+    }>;
+    span1: ElementRef;
+    span2: ElementRef;
+    span3: ElementRef;
+    holder1: ElementRef;
+    closeTooltip: NgbTooltip;
+    private destroy$;
+    constructor(superControl: NgControl, calendarService: CalendarDateTimePickerService);
+    ngOnInit(): void;
+    registerOnChange(fn: any): void;
+    isPopoverShown: boolean;
+    onChange(_: InputChangeValue): void;
+    onTouched: () => void;
+    writeValue(obj: InputChangeValue): void;
+    registerOnTouched(fn: () => void): void;
+    blurInput(): void;
+    preventInput(event: Event): void;
+    ngAfterViewInit(): void;
+    get getSuperControl(): _angular_forms.AbstractControl<any, any, any> | null;
+    get isRequired(): boolean | undefined;
+    onDatePaste(event: ClipboardEvent): void;
+    private processPastedDate;
+    changeSelection(e: any, noPreventDefault?: boolean): void;
+    changeSelectionTwo(event: KeyboardEvent, noPreventDefault?: boolean): void;
+    private isNumber;
+    private isNavigationKey;
+    onFocus(event?: FocusEvent): void;
+    closePopover(date: Date): void;
+    handleFocusInput(e: Event): void;
+    setSpanSelection(element: Node): void;
+    setSelection(event: {
+        preventDefault: () => void;
+        stopPropagation: () => void;
+        target: any;
+    }): void;
+    blurOnDateTime(): void;
+    onEditableFocus(event: FocusEvent): void;
+    onPopoverClick(event?: MouseEvent): void;
+    onPopoverShown(): void;
+    onPopoverHidden(): void;
+    setTimeDateInput(date: InputChangeValue, hasValue?: boolean): void;
+    private markAsTouched;
+    handleKeyboardInputs(e: KeyboardEvent, isRestart?: boolean): void;
+    selectSpanByTabIndex(indx: number, changeTab?: boolean): void;
+    private handleNavigationKey;
+    private handleDatePickerInput;
+    private setDateTimeModel;
+    private moveSelectionRightOrTab;
+    private formatCurrentField;
+    setIsFocusInput(value: boolean): void;
+    private moveSelectionLeft;
+    private updateMonth;
+    private updateDate;
+    private updateYear;
+    private padValue;
+    private handleTimePickerInput;
+    private updateHours;
+    private updateMinutes;
+    private toggleAMPM;
+    clearInput(event?: Event): void;
+    resetDateTimeInputs(): void;
+    setTimePickerTime(): void;
+    handleCloseTooltip(): void;
+    openPopover(event?: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CaiInputDatetimePickerComponent, [{ self: true; }, null]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CaiInputDatetimePickerComponent, "cai-input-datetime-picker", never, { "id": { "alias": "id"; "required": false; }; "inputConfig": { "alias": "inputConfig"; "required": false; }; "formFormat": { "alias": "formFormat"; "required": false; }; }, { "clearInputEvent": "clear"; "blurInputEvent": "blurInput"; "selectLastOneForSelectionEmitter": "selectLastOneForSelectionEmitter"; "selectLastOneAfterMouseUpEmitter": "selectLastOneAfterMouseUpEmitter"; "onDatePasteEmitter": "onDatePasteEmitter"; "onFocusEmitter": "onFocusEmitter"; "changeSelectionEmmiter": "changeSelectionEmmiter"; "setSelectionEmmiter": "setSelectionEmmiter"; }, never, never, true, never>;
+}
+
+/**
+ * Represents a user avatar component.
+ */
+declare class AvatarComponent {
+    /**
+     * The driver object containing information to display in the avatar.
+     * This input is required.
+     * @type {Driver}
+     */
+    driver: _angular_core.InputSignal<Driver$1>;
+    /**
+     * The size of the avatar in pixels.
+     * @type {Size}
+     */
+    size: _angular_core.InputSignal<18 | 22 | 32 | 74 | 160 | 28>;
+    /**
+     * Whether the avatar should be rounded or not.
+     * @type {boolean}
+     */
+    rounded: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether the owner element should be dark or light
+     * @type {boolean}
+     */
+    inverse: _angular_core.InputSignal<boolean>;
+    /**
+     * The tooltip to display when hovering over the avatar.
+     * @type {string}
+     */
+    tooltip: _angular_core.InputSignal<string | null>;
+    /**
+     * The size to apply when hovering over the avatar.
+     * @type {number}
+     */
+    customHoverSize: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Whether the avatar should be hovered or not.
+     * @type {boolean}
+     */
+    hover: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "cai-avatar", never, { "driver": { "alias": "driver"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "inverse": { "alias": "inverse"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "customHoverSize": { "alias": "customHoverSize"; "required": false; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare enum eAlignment {
+    LEFT = "left",
+    RIGHT = "right"
+}
+
+declare class CopyComponent {
+    private clipboard;
+    value: _angular_core.InputSignal<string | undefined>;
+    alignment: _angular_core.InputSignal<eAlignment>;
+    copyTooltip: _angular_core.InputSignal<string | undefined>;
+    copyArea: _angular_core.InputSignal<"icon" | "full">;
+    icon: _angular_core.InputSignal<string | null>;
+    iconSize: _angular_core.InputSignal<number>;
+    iconColor: _angular_core.InputSignal<string | null>;
+    tooltipClass: _angular_core.InputSignal<string | null>;
+    tooltipPlacement: _angular_core.InputSignal<"top" | "bottom">;
+    inverse: _angular_core.InputSignal<boolean>;
+    hasNoIcon: _angular_core.InputSignal<boolean>;
+    copied: _angular_core.WritableSignal<boolean>;
+    eGeneralActions: typeof eGeneralActions;
+    eAlignment: typeof eAlignment;
+    constructor(clipboard: Clipboard);
+    onCopy(event: MouseEvent): void;
+    resetCopied(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopyComponent, "cai-copy", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "copyTooltip": { "alias": "copyTooltip"; "required": false; "isSignal": true; }; "copyArea": { "alias": "copyArea"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "tooltipClass": { "alias": "tooltipClass"; "required": false; "isSignal": true; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; "isSignal": true; }; "inverse": { "alias": "inverse"; "required": false; "isSignal": true; }; "hasNoIcon": { "alias": "hasNoIcon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface LongLat {
+    latitude?: number;
+    longitude?: number;
+}
+
+interface AddressEntity {
+    city?: string | null;
+    state?: string | null;
+    county?: string | null;
+    address?: string | null;
+    street?: string | null;
+    streetNumber?: string | null;
+    country?: string | null;
+    zipCode?: string | null;
+    stateShortName?: string | null;
+    addressUnit?: string | null;
+}
+interface AddressData {
+    address?: AddressEntity;
+    longLat?: LongLat | null;
+    valid?: boolean;
+    isParking?: boolean;
+}
+
+interface AddressList {
+    id?: number;
+    name?: string;
+    address?: string;
+    parkingAddress?: any;
+}
+
+declare class InputAddressComponent implements OnInit, ControlValueAccessor, OnDestroy, OnChanges {
+    superControl: NgControl;
+    private ref;
+    inputComponent: InputComponent;
+    private destroy$;
+    private controlSubscription$;
+    private baseConfig;
+    id: _angular_core.InputSignal<string>;
+    config: _angular_core.InputSignal<CaiInputConfig>;
+    type: _angular_core.InputSignal<string>;
+    required: _angular_core.InputSignal<boolean>;
+    isInTable: _angular_core.InputSignal<boolean>;
+    isFormLoaded: _angular_core.InputSignal<boolean>;
+    set activeAddress(value: AddressList | null);
+    set receivedAddressData(value: AddressData | null);
+    set receivedAddressList(value: {
+        addresses: string[];
+    } | null);
+    set parkingList(value: any[]);
+    selectedAddress: _angular_core.OutputEmitterRef<any>;
+    sentAddressData: _angular_core.OutputEmitterRef<any>;
+    sentAddressValue: _angular_core.OutputEmitterRef<any>;
+    onClear: _angular_core.OutputEmitterRef<void>;
+    _receivedAddressList: {
+        addresses: string[];
+    } | null;
+    _activeAddress: AddressList | null;
+    private searchLayers;
+    currentAddressData: AddressData | null;
+    addressList: AddressList[];
+    allowValidation: boolean;
+    requestSent: boolean;
+    closedBorder: boolean;
+    chosenFromDropdown: boolean;
+    _parkingList: any[];
+    isParkingAddressSelected: boolean;
+    inputConfig: _angular_core.WritableSignal<CaiInputConfig>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    constructor(superControl: NgControl, ref: ChangeDetectorRef);
+    writeValue(_: any): void;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    get getSuperControl(): FormControl;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private initializeAddressInput;
+    private checkSearchLayers;
+    private filterParkingByCity;
+    private checkAddressValidation;
+    onBlur(): void;
+    hideValidation(): any;
+    initChangesListener(): void;
+    onSelectDropdown(name: string | null): void;
+    onClearInputEvent(): void;
+    getAddressData(address: string): void;
+    emitOnClear(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputAddressComponent, [{ self: true; }, null]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputAddressComponent, "cai-input-address", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "isInTable": { "alias": "isInTable"; "required": false; "isSignal": true; }; "isFormLoaded": { "alias": "isFormLoaded"; "required": false; "isSignal": true; }; "activeAddress": { "alias": "activeAddress"; "required": false; }; "receivedAddressData": { "alias": "receivedAddressData"; "required": false; }; "receivedAddressList": { "alias": "receivedAddressList"; "required": false; }; "parkingList": { "alias": "parkingList"; "required": false; }; }, { "selectedAddress": "selectedAddress"; "sentAddressData": "sentAddressData"; "sentAddressValue": "sentAddressValue"; "onClear": "onClear"; }, never, never, true, never>;
+}
+
+interface SelectedBusinessField {
+    label?: string;
+    id?: number;
+    name?: string;
+    address?: string;
+    phone?: string;
+    email?: string;
+    isFavorite?: boolean;
+    isRequired?: boolean;
+    isDisabled?: boolean;
+}
+
+declare class SelectedBusinessFieldComponent {
+    business: _angular_core.InputSignal<SelectedBusinessField>;
+    onAction: _angular_core.OutputEmitterRef<eGeneralActions>;
+    eGeneralActions: typeof eGeneralActions;
+    eAlignment: typeof eAlignment;
+    handleAction(action: eGeneralActions): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectedBusinessFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectedBusinessFieldComponent, "cai-selected-business-field", never, { "business": { "alias": "business"; "required": false; "isSignal": true; }; }, { "onAction": "onAction"; }, never, never, true, never>;
+}
+
+interface IReview {
+    ratingId: number | null;
+    thumb: string | null;
+    reviewId: number;
+    comment: string;
+    isEdited: boolean;
+    companyUser: CompanyUser;
+    companyUserId: number;
+    isItCurrentCompanyUser: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CompanyUser {
+    id: number;
+    userId: number;
+    fullName: string;
+    avatarFile: AvatarTest;
+    departmentId: number;
+}
+interface AvatarTest {
+    driver: Driver$1;
+    size: Size;
+    rounded: boolean;
+    inverse: boolean;
+}
+
+declare enum ReviewType {
+    Modal = "Modal",
+    Table = "Table",
+    Details = "Details"
+}
+
+declare enum FilterType {
+    LIKES = "likes",
+    DISLIKES = "dislikes",
+    REVIEWS = "reviews",
+    ALL = "all",
+    RATING = "rating"
+}
+
+declare class ReviewModalComponent implements OnInit, OnChanges {
+    ReviewType: typeof ReviewType;
+    FilterType: typeof FilterType;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ratingReviews: IReview[];
+    modaltype: string;
+    titleInput: string;
+    reviewDeleted: EventEmitter<void>;
+    activeLikes: _angular_core.WritableSignal<boolean>;
+    activeDislikes: _angular_core.WritableSignal<boolean>;
+    activeReviews: _angular_core.WritableSignal<boolean>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    addingReview: _angular_core.WritableSignal<boolean>;
+    presentReviews: IReview[];
+    testReview: IReview;
+    countLikes: number;
+    countDislikes: number;
+    countReviews: number;
+    hasPersonalReview: boolean;
+    currentActiveFilter: string;
+    onReturnMost(): string;
+    /**
+     * Adds a new empty review to the `presentReviews` list and sets `addingReview` to `true`.
+     * This review is marked as "personal" and pre-filled with basic user data.
+     */
+    onAddReview(): void;
+    onEditedReview(ev: {
+        review: IReview;
+        edited: boolean;
+    }): void;
+    onGetReview(ev: {
+        review: IReview;
+    }): void;
+    handleSearch(event: string | number | null): void;
+    handleClear(event: void): void;
+    /**
+     * Initializes review data when the component is initialized or when the `reviews` input changes.
+     * It copies the original reviews array, resets counters, calculates new counts, and
+     * sets the `disabled` signal if a personal review already exists.
+     * @private
+     */
+    private initializeReviewsData;
+    /**
+     * Resets the counts for likes, dislikes, and written reviews to zero.
+     * @private
+     */
+    private resetCounts;
+    /**
+     * Iterates through the `reviews` array and calculates the total number of likes,
+     * dislikes, and written reviews (those with a non-empty `value`).
+     * @private
+     */
+    private calculateReviewCounts;
+    onSwitchActive(value: string): void;
+    /**
+     * Changes the displayed reviews in `presentReviews` based on the selected type.
+     * It filters the original `reviews` array to show only likes, dislikes,
+     * written reviews, or all reviews.
+     * @param type The type of reviews to display: 'likes', 'dislikes', 'reviews' (only written), or 'all'.
+     */
+    onChangePresentReviews(type: FilterType): void;
+    /**
+     * Updates the value and edit time of an existing review in the `presentReviews` list.
+     * Sets the `edited` flag to `true` for the modified review.
+     * @param updatedData An object containing the review's ID, the new text value, and the new edit time.
+     */
+    onChangeValue(updatedData: {
+        id: number;
+        value: string;
+        newTime: string;
+    }): void;
+    /**
+     * Initiates the review deletion process.
+     * Currently, it logs a message to the console and emits the `reviewDeleted` event.
+     * The logic for actual removal from `presentReviews` is commented out.
+     * @param id The ID of the review to be deleted.
+     */
+    onDeleteReview(id: number): void;
+    onCheckPersonal(): void;
+    onSelectFilter(type: FilterType): void;
+    onCancelFilter(event: MouseEvent, type: FilterType): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReviewModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ReviewModalComponent, "cai-review-modal", never, { "ratingReviews": { "alias": "ratingReviews"; "required": false; }; "modaltype": { "alias": "modaltype"; "required": false; }; "titleInput": { "alias": "titleInput"; "required": false; }; }, { "reviewDeleted": "reviewDeleted"; }, never, never, true, never>;
+}
+
+declare class RatingReviewComponent {
+    FilterType: typeof FilterType;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ratingReviews: IReview[];
+    inCard: boolean;
+    modaltype: string;
+    countLikes: number;
+    countDislikes: number;
+    countReviews: number;
+    titleInput: string;
+    show: _angular_core.WritableSignal<boolean>;
+    onReturnMost(): string;
+    /**
+     * Initializes review data when the component is initialized or when the `reviews` input changes.
+     * It copies the original reviews array, resets counters, calculates new counts, and
+     * sets the `disabled` signal if a personal review already exists.
+     * @private
+     */
+    private initializeReviewsData;
+    /**
+     * Resets the counts for likes, dislikes, and written reviews to zero.
+     * @private
+     */
+    private resetCounts;
+    /**
+     * Iterates through the `reviews` array and calculates the total number of likes,
+     * dislikes, and written reviews (those with a non-empty `value`).
+     * @private
+     */
+    private calculateReviewCounts;
+    handleOpen(): void;
+    handleClose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RatingReviewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RatingReviewComponent, "cai-rating-review", never, { "ratingReviews": { "alias": "ratingReviews"; "required": true; }; "inCard": { "alias": "inCard"; "required": false; }; "modaltype": { "alias": "modaltype"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+interface Contact {
+    id?: number | null;
+    brokerId?: number | null;
+    shipperId?: number | null;
+    email?: string | null;
+    phone?: string | null;
+    contactName?: string | null;
+    fullName?: string | null;
+    extensionPhone?: string | null;
+    department?: Department | null;
+}
+interface Department {
+    id?: number | null;
+    name?: string | null;
+    count?: number | null;
+    companyUsers?: any | null;
+}
+
+declare class ListContactDropdownComponent {
+    dropdown: NgbPopover;
+    id: _angular_core.InputSignal<string>;
+    contacts: _angular_core.InputSignal<Contact[]>;
+    onAdd: _angular_core.OutputEmitterRef<void>;
+    onDelete: _angular_core.OutputEmitterRef<void>;
+    onEdit: _angular_core.OutputEmitterRef<void>;
+    onOpen: _angular_core.OutputEmitterRef<void>;
+    onClose: _angular_core.OutputEmitterRef<void>;
+    closing: _angular_core.WritableSignal<boolean>;
+    open: _angular_core.WritableSignal<boolean>;
+    selectedIds: _angular_core.WritableSignal<{
+        departmentId: number;
+        contactId: number[];
+    }[]>;
+    form: UntypedFormGroup;
+    selectedContactIds(): number[];
+    closeDropdown(): void;
+    openDropdown(): void;
+    isDepartmentOpen(departmentId: number | null | undefined): boolean;
+    isContactOpen(contactId: number | null | undefined): boolean;
+    handleOpenDropdown(): void;
+    handleCloseDropdown(): void;
+    emitOnAdd(event: Event): void;
+    emitOnEdit(event: Event): void;
+    emitOnDelete(event: Event): void;
+    handleContactClick(contactId: number): void;
+    handleDepartmentClick(departmentId: number): void;
+    handleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListContactDropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListContactDropdownComponent, "cai-list-contact-dropdown", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "contacts": { "alias": "contacts"; "required": false; "isSignal": true; }; }, { "onAdd": "onAdd"; "onDelete": "onDelete"; "onEdit": "onEdit"; "onOpen": "onOpen"; "onClose": "onClose"; }, never, never, true, never>;
+}
+
+interface ITabOptionConfig {
+    splitPart: string;
+    splitPartSide: 'left' | 'right';
+}
+
+interface ITabOption {
+    id: number;
+    name: string;
+}
+
+declare class TabOptionDropdownComponent {
+    dropdown: NgbDropdown;
+    containerRef: ElementRef<HTMLDivElement>;
+    inputRef: ElementRef<HTMLInputElement>;
+    selectedOption: _angular_core.InputSignal<ITabOption | null>;
+    count: _angular_core.InputSignal<number>;
+    isLoading: _angular_core.InputSignal<boolean>;
+    options: _angular_core.InputSignal<ITabOption[]>;
+    config: _angular_core.InputSignal<ITabOptionConfig>;
+    onSelectionChange: _angular_core.OutputEmitterRef<ITabOption>;
+    searchValue: _angular_core.WritableSignal<string>;
+    closing: _angular_core.WritableSignal<boolean>;
+    containerWidth: _angular_core.WritableSignal<number>;
+    private updateContainerWidth;
+    private closeDropdown;
+    handleFocus(): void;
+    handleClick(): void;
+    handleBlur(): void;
+    handleOption(event: MouseEvent, option: ITabOption): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabOptionDropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabOptionDropdownComponent, "cai-tab-option-dropdown", never, { "selectedOption": { "alias": "selectedOption"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "onSelectionChange": "onSelectionChange"; }, never, never, true, never>;
+}
+
+interface IIntervalDropdownOption {
+    id: number;
+    name: string;
+    value: string;
+    custom?: boolean;
+    startDate?: string;
+    endDate?: string;
+}
+
+declare class IntervalDropdownComponent implements AfterViewInit {
+    dropdown: NgbPopover;
+    containerRef: ElementRef<HTMLDivElement>;
+    containerWidth: _angular_core.WritableSignal<number>;
+    selectedOption: _angular_core.InputSignal<IIntervalDropdownOption | null>;
+    options: _angular_core.InputSignal<IIntervalDropdownOption[]>;
+    companyDays: _angular_core.InputSignal<number | null>;
+    custom: _angular_core.WritableSignal<boolean>;
+    open: _angular_core.WritableSignal<boolean>;
+    onClose: _angular_core.OutputEmitterRef<void>;
+    onOpen: _angular_core.OutputEmitterRef<void>;
+    onSelectionChange: _angular_core.OutputEmitterRef<IIntervalDropdownOption>;
+    form: UntypedFormGroup;
+    private updateContainerWidth;
+    ngAfterViewInit(): void;
+    handleOpenDropdown(): void;
+    handleCloseDropdown(): void;
+    handleClick(): void;
+    closeDropdown(): void;
+    openDropdown(): void;
+    handleOption(event: MouseEvent, option: IIntervalDropdownOption): void;
+    handleClearAll(event: MouseEvent): void;
+    handleSet(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IntervalDropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IntervalDropdownComponent, "cai-interval-dropdown", never, { "selectedOption": { "alias": "selectedOption"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "companyDays": { "alias": "companyDays"; "required": false; "isSignal": true; }; }, { "onClose": "onClose"; "onOpen": "onOpen"; "onSelectionChange": "onSelectionChange"; }, never, never, true, never>;
+}
+
+declare enum eScrollState {
+    START = "start",
+    SCROLLING = "scrolling",
+    END = "end",
+    NOT_NEEDED = "not_needed"
+}
+
+declare class StickyScrollbarComponent implements AfterViewInit {
+    scrollContainer: ElementRef<HTMLDivElement>;
+    scrollThumb: ElementRef<HTMLDivElement>;
+    /**
+     * Input to hide the scrollbar thumb with opacity
+     * @default false
+     */
+    hideThumb: boolean;
+    /**
+     * Hide the scrollbar track completely
+     */
+    set hideTrack(value: boolean);
+    get hideTrack(): boolean;
+    private _hideTrack;
+    /**
+     * Keep scrollbar fixed at bottom of viewport even when table scrolls out of view
+     * @default false
+     */
+    set alwaysVisible(value: boolean);
+    get alwaysVisible(): boolean;
+    private _alwaysVisible;
+    /**
+     * Offset for the sticky position from the bottom (in pixels)
+     * @default 0
+     */
+    set stickyOffset(value: number);
+    get stickyOffset(): number;
+    private _stickyOffset;
+    /**
+     * Output to emit scroll state changes (start, scrolling, end)
+     */
+    scrollStateChange: EventEmitter<eScrollState>;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly ngZone;
+    private readonly cdr;
+    isDragging: boolean;
+    isContainerInView: _angular_core.WritableSignal<boolean>;
+    private dragStartX;
+    private scrollStartLeft;
+    private currentScrollState?;
+    private intersectionObserver?;
+    private removeMouseMoveListener?;
+    private removeMouseUpListener?;
+    private removeMouseLeaveListener?;
+    private removeScrollListener?;
+    private isInitialized;
+    private lastTrackVisible?;
+    private lastThumbWidth;
+    private lastThumbPosition;
+    ngAfterViewInit(): void;
+    private setupScrollListener;
+    private handleScroll;
+    private setupGlobalMouseListeners;
+    private teardownAlwaysVisibleTracking;
+    private reconcileAlwaysVisibleTracking;
+    private updateScrollbar;
+    private setupResizeObserver;
+    private setupAlwaysVisibleTracking;
+    private updateFixedTrackPosition;
+    private updateScrollState;
+    private calculateScrollState;
+    onThumbMouseDown(event: MouseEvent): void;
+    private onThumbDrag;
+    onThumbMouseUp(): void;
+    refresh(): void;
+    scrollToEnd(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StickyScrollbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StickyScrollbarComponent, "ca-sticky-scrollbar", never, { "hideThumb": { "alias": "hideThumb"; "required": false; }; "hideTrack": { "alias": "hideTrack"; "required": false; }; "alwaysVisible": { "alias": "alwaysVisible"; "required": false; }; "stickyOffset": { "alias": "stickyOffset"; "required": false; }; }, { "scrollStateChange": "scrollStateChange"; }, never, ["*"], true, never>;
+}
+
+interface IDispatchDropdownOption {
+    id?: number;
+    [key: string]: any;
+}
+
+interface IDispatchDropdownConfig {
+    hasPagination?: boolean;
+    placeholder?: string;
+    hasNoAdd?: boolean;
+    hasNoAddNew?: boolean;
+    optionLabel?: string;
+    isGrouped?: boolean;
+    groupLabel?: string;
+    groupOptions?: string;
+}
+
+declare class DispatchDropdownComponent {
+    dropdown: NgbDropdown;
+    containerRef: ElementRef<HTMLDivElement>;
+    inputRef: ElementRef<HTMLInputElement>;
+    selectedOption: _angular_core.InputSignal<IDispatchDropdownOption | null>;
+    options: _angular_core.InputSignal<IDispatchDropdownOption[]>;
+    config: _angular_core.InputSignal<IDispatchDropdownConfig>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    data: _angular_core.InputSignal<unknown>;
+    isLocked: _angular_core.InputSignal<boolean>;
+    hasNoRemoveButton: _angular_core.InputSignal<boolean>;
+    isDisabled: _angular_core.InputSignal<boolean>;
+    disabledTooltip: _angular_core.InputSignal<string>;
+    contentTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    optionTemplateLeft: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    optionTemplateRight: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    noContentTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    hideDropdownMenu: _angular_core.InputSignal<boolean>;
+    onSelectionChange: _angular_core.OutputEmitterRef<IDispatchDropdownOption | null>;
+    onRemove: _angular_core.OutputEmitterRef<void>;
+    onAddNew: _angular_core.OutputEmitterRef<number | null>;
+    onSearch: _angular_core.OutputEmitterRef<string>;
+    onToggleDropdown: _angular_core.OutputEmitterRef<boolean>;
+    onBlur: _angular_core.OutputEmitterRef<void>;
+    searchValue: _angular_core.WritableSignal<string>;
+    closing: _angular_core.WritableSignal<boolean>;
+    containerWidth: _angular_core.WritableSignal<number>;
+    dropdownOpen: _angular_core.WritableSignal<boolean>;
+    collapsedGroups: _angular_core.WritableSignal<string[]>;
+    private closeTimeout;
+    groupMaxHeightStyle: _angular_core.Signal<string>;
+    maxHeightStyle: _angular_core.Signal<string>;
+    containerHeightStyle: _angular_core.Signal<string>;
+    filteredOptions: _angular_core.Signal<IDispatchDropdownOption[]>;
+    filteredGroupedOptions: _angular_core.Signal<{
+        groupName: any;
+        highlightedGroupName: any;
+        highlightedOptions: any;
+        isCollapsed: boolean;
+        isRelevant: any;
+        id?: number;
+    }[]>;
+    highlightedOptions: _angular_core.Signal<{
+        highlighted: any;
+        id?: number;
+    }[]>;
+    private updateContainerWidth;
+    private closeDropdown;
+    handleOpenChange(event: boolean): void;
+    handleFocus(): void;
+    handleClick($event?: MouseEvent): void;
+    handleBlur(): void;
+    handleKeydown(event: KeyboardEvent): void;
+    handleOption(event: MouseEvent, option: IDispatchDropdownOption): void;
+    handlePrimaryButtonClick(event: MouseEvent): void;
+    handleSearch(event: Event): void;
+    handleAddNew(id: number | null): void;
+    toggleGroup(event: MouseEvent, groupName?: string): void;
+    stopEventPropagationAndPreventDefault(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DispatchDropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DispatchDropdownComponent, "cai-dispatch-dropdown", never, { "selectedOption": { "alias": "selectedOption"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "isLocked": { "alias": "isLocked"; "required": false; "isSignal": true; }; "hasNoRemoveButton": { "alias": "hasNoRemoveButton"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "disabledTooltip": { "alias": "disabledTooltip"; "required": false; "isSignal": true; }; "contentTemplate": { "alias": "contentTemplate"; "required": false; "isSignal": true; }; "optionTemplateLeft": { "alias": "optionTemplateLeft"; "required": false; "isSignal": true; }; "optionTemplateRight": { "alias": "optionTemplateRight"; "required": false; "isSignal": true; }; "noContentTemplate": { "alias": "noContentTemplate"; "required": false; "isSignal": true; }; "hideDropdownMenu": { "alias": "hideDropdownMenu"; "required": false; "isSignal": true; }; }, { "onSelectionChange": "onSelectionChange"; "onRemove": "onRemove"; "onAddNew": "onAddNew"; "onSearch": "onSearch"; "onToggleDropdown": "onToggleDropdown"; "onBlur": "onBlur"; }, never, never, true, never>;
+}
+
+interface ITextAreaConfig {
+    name?: string;
+    max?: number;
+}
+
+/**
+ * This component is a text area component that integrates with Angular forms.
+ */
+declare class TextAreaComponent implements ControlValueAccessor {
+    ngControl: NgControl | null;
+    cancelTooltip: NgbTooltip;
+    textArea: ElementRef<HTMLTextAreaElement>;
+    /**
+     * Configuration object for the text area's behavior and appearance.
+     */
+    config: _angular_core.InputSignal<ITextAreaConfig>;
+    /**
+     * Holds the internal value of the text area.
+     */
+    value: _angular_core.WritableSignal<string>;
+    /**
+     * Internal signal to track the disabled state of the text area.
+     */
+    disabled: _angular_core.WritableSignal<boolean>;
+    /**
+     * A signal that indicates whether the text area is focused.
+     */
+    focused: _angular_core.WritableSignal<boolean>;
+    onBlur: _angular_core.OutputEmitterRef<void>;
+    onFocused: _angular_core.OutputEmitterRef<void>;
+    onValueChange: _angular_core.OutputEmitterRef<string | null>;
+    onClearEvent: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Constructor for the TextAreaComponent.
+     * It injects NgControl to integrate with Angular's forms API.
+     * @param ngControl - Optional NgControl instance for form integration.
+     */
+    constructor(ngControl: NgControl | null);
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    /**
+     * Writes a new value to the element. (ControlValueAccessor)
+     */
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Handles the native 'input' event from the HTMLTextAreaElement.
+     * Updates the component's internal value and notifies Angular forms.
+     * @param event - The input event object.
+     */
+    onInput(event: Event): void;
+    /**
+     * Dispatches the onChange event with the provided value.
+     * @param value - The value to pass to onChange
+     */
+    dispatchOnChange(value: any): void;
+    /**
+     * Sets the value in the actual HTML text area element.
+     */
+    setValue(): void;
+    /**
+     * Focuses the text area element.
+     */
+    focus(event?: MouseEvent): void;
+    /**
+     * Called when the text area receives focus.
+     */
+    onFocus(): void;
+    /**
+     * Called when the text area loses focus.
+     */
+    dispatchOnBlur(): void;
+    /**
+     * Resets the text area value to an empty string.
+     */
+    reset(event?: MouseEvent): void;
+    /**
+     * Handles the clear button click.
+     */
+    onClear(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextAreaComponent, [{ optional: true; self: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextAreaComponent, "cai-text-area", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "onBlur": "onBlur"; "onFocused": "onFocused"; "onValueChange": "onValueChange"; "onClearEvent": "onClearEvent"; }, never, never, true, never>;
+}
+
+interface ILastStatusData {
+    hours: number;
+    minutes: number;
+    days?: number;
+    seconds?: number;
+}
+
+declare class DispatchLocationComponent implements OnInit, OnDestroy {
+    dispatchDropdown: DispatchDropdownComponent;
+    id: _angular_core.InputSignal<string>;
+    locationData: _angular_core.InputSignal<AddressEntity | null>;
+    highlightedLocationString: _angular_core.InputSignal<string>;
+    lastStatusData: _angular_core.InputSignal<ILastStatusData | null>;
+    isParking: _angular_core.InputSignal<boolean>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    parkingName: _angular_core.InputSignal<string>;
+    showParkingIcon: _angular_core.Signal<boolean>;
+    set receivedAddressData(value: AddressData | null);
+    set receivedAddressList(value: {
+        addresses?: string[];
+    } | null);
+    set parkingList(value: any[]);
+    selectedAddress: _angular_core.OutputEmitterRef<any>;
+    sentAddressData: _angular_core.OutputEmitterRef<any>;
+    sentAddressValue: _angular_core.OutputEmitterRef<any>;
+    onClear: _angular_core.OutputEmitterRef<void>;
+    onToggleDropdown: _angular_core.OutputEmitterRef<boolean>;
+    onBlur: _angular_core.OutputEmitterRef<void>;
+    config: IDispatchDropdownConfig;
+    options: AddressList[];
+    addressList: AddressList[];
+    currentAddressData: AddressData | null;
+    isParkingAddressSelected: boolean;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    hideDropdownMenu: _angular_core.WritableSignal<boolean>;
+    private _parkingList;
+    private searchLayers;
+    private destroy$;
+    private searchSubject$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initSearchListener;
+    private filterParkingByCity;
+    focus(): void;
+    handleSearch(event: string): void;
+    handleAddressSelect(selectedOption: any): void;
+    handleToggleDropdown(event: boolean): void;
+    handleBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DispatchLocationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DispatchLocationComponent, "cai-dispatch-location", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "locationData": { "alias": "locationData"; "required": false; "isSignal": true; }; "highlightedLocationString": { "alias": "highlightedLocationString"; "required": false; "isSignal": true; }; "lastStatusData": { "alias": "lastStatusData"; "required": false; "isSignal": true; }; "isParking": { "alias": "isParking"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "parkingName": { "alias": "parkingName"; "required": false; "isSignal": true; }; "receivedAddressData": { "alias": "receivedAddressData"; "required": false; }; "receivedAddressList": { "alias": "receivedAddressList"; "required": false; }; "parkingList": { "alias": "parkingList"; "required": false; }; }, { "selectedAddress": "selectedAddress"; "sentAddressData": "sentAddressData"; "sentAddressValue": "sentAddressValue"; "onClear": "onClear"; "onToggleDropdown": "onToggleDropdown"; "onBlur": "onBlur"; }, never, never, true, never>;
+}
+
+declare class CounterComponent implements ControlValueAccessor, OnDestroy {
+    ngControl: NgControl | null;
+    inputRef: ElementRef<HTMLInputElement>;
+    min: _angular_core.InputSignal<number | null>;
+    max: _angular_core.InputSignal<number | null>;
+    value: _angular_core.WritableSignal<number | null>;
+    keyPressed: _angular_core.WritableSignal<"up" | "down" | null>;
+    private keyPressedTimeout;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    /**
+     * Constructor for the CounterComponent.
+     * It injects NgControl to integrate with Angular's forms API.
+     * If NgControl is present, it sets this component as the value accessor
+     * for the form control.
+     * @param ngControl - Optional NgControl instance for form integration.
+     */
+    constructor(ngControl: NgControl | null);
+    /**
+     * Handles input changes from the input element.
+     * @param event - The input event.
+     */
+    onInput(event: Event): void;
+    /**
+     * Handles blur event on the input element.
+     */
+    onBlur(): void;
+    /**
+     * Increments or decrements the value.
+     * @param step - The amount to increment (positive) or decrement (negative).
+     */
+    increment(step: number): void;
+    /**
+     * Updates the input element's value to match the internal value.
+     */
+    private updateInputValue;
+    /**
+     * Writes a new value to the element.
+     * @param value - The new value.
+     */
+    writeValue(value: any): void;
+    /**
+     * Registers a callback function that is called when the control's value changes.
+     * @param fn - The callback function.
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Registers a callback function that is called when the control is touched.
+     * @param fn - The callback function.
+     */
+    registerOnTouched(fn: any): void;
+    focus(event: PointerEvent): void;
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * Applies a temporary key-pressed class effect to the specified arrow.
+     * @param direction - The arrow direction ('up' or 'down').
+     */
+    private flashKeyPressed;
+    /**
+     * Cleanup timeouts when component is destroyed.
+     */
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CounterComponent, [{ optional: true; self: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CounterComponent, "cai-counter", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AvatarComponent, CaiInputDatetimePickerComponent, CopyComponent, CounterComponent, DispatchDropdownComponent, DispatchLocationComponent, DropZoneComponent, DropdownTypes, INPUT_CHARACTER_SETS, InputAddressComponent, InputComponent, IntervalDropdownComponent, ListContactDropdownComponent, PmComponent, RatingReviewComponent, ReviewModalComponent, SelectedBusinessFieldComponent, StickyScrollbarComponent, TabOptionDropdownComponent, TextAreaComponent, eScrollState, ignoreWhenAutofilled, sizes };
+export type { Address, Bank, Broker, CaiDateTimeConfig, CaiInputConfig, ColorOption, Contact$1 as Contact, CustomError, Department$1 as Department, DepartmentContactsPair, Dispatch, DispatchBoard, Dispatcher, Driver, DropdownArrays, DropdownGroups, DropdownKeys, DropdownOption, DropdownOptions, DropdownType, Franchise, FuelCard, FuelStopStore, GroupedNavigationState, Hazardous, ICaInput, ICaInputDateTimePicker, ICaInputWithDropdown, IDispatchDropdownConfig, IDispatchDropdownOption, IIntervalDropdownOption, IMultipleInput, ITabOption, ITabOptionConfig, ITextAreaConfig, InputChangeValue, KeyboardNavigationState, MakeOption, Owner, PMOption, Provider, Shipper, SplitDriver, SplitDriverBoard, SplitTrailer, SplitTrailerBoard, SplitTruck, SplitTruckBoard, State, Status, TollOption, TollTransponderOption, Trailer, TrailerOption, TrailerType, Truck, TruckColor, TruckOption, TruckType };