import * as i0 from '@angular/core';
import { OnChanges, SimpleChanges, OnInit, EventEmitter, AfterViewInit, TemplateRef, ChangeDetectorRef, NgZone, OnDestroy, ElementRef, PipeTransform, QueryList, Renderer2, RendererFactory2, Injector } from '@angular/core';
import * as i1 from '@angular/common';
import { DatePipe } from '@angular/common';
import { NgbPopover, NgbTooltip, NgbActiveModal } from '@ng-bootstrap/ng-bootstrap';
import * as _angular_forms from '@angular/forms';
import { UntypedFormGroup, UntypedFormBuilder, AbstractControl, NgControl, ControlValueAccessor, FormControl, UntypedFormArray, ValidatorFn } from '@angular/forms';
import { Options } from '@popperjs/core/lib/popper';
import * as rxjs from 'rxjs';
import { Subject, Observable, BehaviorSubject } from 'rxjs';
import { Options as Options$1, ChangeContext } from '@angular-slider/ngx-slider';
import { NgxMaskService } from 'ngx-mask';
import { DomSanitizer, SafeHtml, SafeResourceUrl } from '@angular/platform-browser';
import { GoogleMap, MapAdvancedMarker } from '@angular/google-maps';
import { CdkDragDrop, CdkDrag } from '@angular/cdk/drag-drop';
import { CropperPosition } from 'ngx-image-cropper';
import { ChartTypeRegistry, ChartOptions } from 'chart.js';
import { HttpClient } from '@angular/common/http';
import { PDFDocumentProxy } from 'ng2-pdf-viewer';
import { Clipboard } from '@angular/cdk/clipboard';
import { CaiInputConfig } from 'carriera-intern-components';

declare class CaProfileImageComponent implements OnChanges {
    indx: number;
    avatarImg: string | undefined;
    avatarColor: {
        background?: string;
        color?: string;
    };
    private imageColor;
    private backgroundColors;
    textShortName: string | undefined;
    name: string | number;
    isRound: boolean;
    size: string | number;
    height: string | number;
    fontSize: string | number;
    isHoverEffect: boolean;
    isCursorPointer: boolean;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    getProfileImageColors(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaProfileImageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaProfileImageComponent, "app-ca-profile-image", never, { "indx": { "alias": "indx"; "required": false; }; "avatarImg": { "alias": "avatarImg"; "required": false; }; "avatarColor": { "alias": "avatarColor"; "required": false; }; "textShortName": { "alias": "textShortName"; "required": false; }; "name": { "alias": "name"; "required": false; }; "isRound": { "alias": "isRound"; "required": false; }; "size": { "alias": "size"; "required": false; }; "height": { "alias": "height"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "isHoverEffect": { "alias": "isHoverEffect"; "required": false; }; "isCursorPointer": { "alias": "isCursorPointer"; "required": false; }; }, {}, never, never, true, never>;
}

declare enum ePosition {
    TOP = "top",
    BOTTOM = "bottom",
    LEFT = "left",
    RIGHT = "right",
    BOTTOM_LEFT = "bottom-left",
    BOTTOM_RIGHT = "bottom-right",
    TABLE_CARDS_DROPDOWN_MENU = "right-top bottom-right right-bottom top-right",
    BOTTOM_END = "bottom-end"
}

declare enum eDropdownMenu$1 {
    EDIT = "Edit",
    VIEW_DETAILS = "View Details",
    SHARE = "Share",
    PRINT = "Print",
    DELETE = "Delete",
    UNASSIGN = "Unassign",
    EDIT_TYPE = "edit",
    VIEW_DETAILS_TYPE = "view-details",
    SHARE_TYPE = "share",
    PRINT_TYPE = "print",
    DELETE_TYPE = "delete",
    UNASSIGN_TYPE = "unassign",
    REGULAR = "regular"
}

declare enum eFilterColor {
    YELLOW = "#F89B2E",
    GREEN = "#50AC25",
    RED = "#DF3C3C",
    BLUE = "#3B73ED",
    PURPLE = "#9E47EC",
    ORANGE = "#FF7043",
    BROWN = "#865E3A",
    DARK_BLUE = "#5755DF",
    LIGHT_GREEN = "#259F94",
    PINK = "#DF3D85",
    GOLD = "#CF961D",
    DEFAULT = "#F89B2E"
}

declare enum eLoadStatus {
    Booked = 1,
    Assigned = 2,
    Unassigned = 3,
    Loaded = 4,
    Offloaded = 5,
    CheckedIn = 6,
    Dispatched = 7,
    Invoiced = 8,
    InvoicedFactoring = 9,
    InvoicedHold = 10,
    Delivered = 11,
    LoadCancelled = 12,
    Paid = 13,
    PaidFactoring = 14,
    RevisedPaidFactoring = 15,
    ShortPaid = 16,
    ShortPaidFactoring = 17,
    RevisedShortPaidFactoring = 18,
    Claim = 19,
    ClaimFactoring = 20,
    RevisedClaimFactoring = 21,
    Unpaid = 22,
    UnpaidFactoring = 23,
    RevisedUnpaidFactoring = 24,
    Tonu = 25,
    TonuInvoiced = 26,
    TonuInvoicedFactoring = 27,
    TonuPaid = 28,
    TonuPaidFactoring = 29,
    TonuClaim = 30,
    TonuClaimFactoring = 31,
    TonuShortPaid = 32,
    TonuShortPaidFactoring = 33,
    TonuUnpaid = 34,
    TonuUnpaidFactoring = 35,
    Hold = 36,
    HoldFactoring = 37,
    Revised = 38,
    RevisedFactoring = 39,
    RevisedPaid = 40,
    RevisedClaim = 41,
    RevisedShortPaid = 42,
    RevisedUnpaid = 43,
    Cancelled = 44,
    Split = 45,
    Loading = 46,
    Offloading = 47,
    ArrivedPickup = 48,
    ArrivedDelivery = 49,
    CheckedInPickup = 50,
    CheckedInDelivery = 51,
    RepairDispatched = 52,
    RepairLoaded = 53,
    RepairOffloaded = 54,
    InvoicedHoldFactoring = 55,
    Preassigned = 56
}

declare enum eTrailerName {
    FLAT_BED = "Flat Bed",
    STEP_DECK = "Step Deck",
    LOW_BOY_RGN = "Low Boy / RGN",
    CHASSIS = "Chassis",
    CONESTOGA = "Conestoga",
    SIDE_KIT = "Side Kit",
    CONTAINER = "Container",
    REEFER = "Reefer",
    DRY_VAN = "Dry Van",
    END_DUMP = "End Dump",
    BOTTOM_DUMP = "Bottom Dump",
    HOPPER = "Hopper",
    TANKER = "Tanker",
    PNEUMATIC_TANKER = "Pneumatic Tanker",
    CAR_HAULER = "Car Hauler",
    CAR_HAULER_STINGER = "Car Hauler Stinger"
}

declare enum eTruckNameString {
    SEMI_TRUCK = "Semi Truck",
    SEMI_SLEEPER = "Semi Sleeper",
    BOX_TRUCK = "Box Truck",
    REEFER_TRUCK = "Reefer Truck",
    CARGO_VAN = "Cargo Van",
    DUMP_TRUCK = "Dump Truck",
    CEMENT_TRUCK = "Cement Truck",
    GARBAGE_TRUCK = "Garbage Truck",
    CAR_HAULER = "Car Hauler",
    TOW_TRUCK = "Tow Truck",
    SPOTTER = "Spotter"
}

declare enum eStyleProperty {
    WIDTH_PX = "width.px",
    HEIGHT_PX = "height.px"
}

declare enum eStringPlaceholder {
    EMPTY = "",
    WHITESPACE = " ",
    DASH = "-",
    DASH_WITH_SPACES = " - ",
    COMMA_WHITESPACE = ", ",
    DOT = ".",
    FORWARD_SLASH = "/",
    NA = "N/A",
    NONE = "None",
    ASTERISK = "*",
    HASH_SIGN = "#",
    YES = "Yes",
    YES_UPPERCASE = "YES",
    YES_LOWERCASE = "yes",
    NO = "No",
    NO_UPPERCASE = "NO",
    NO_LOWERCASE = "no",
    GI_LOWERCASE = "gi"
}

declare enum eLoadFilter {
    SET = "Set",
    CLEAR = "Clear",
    TIME_FILTER = "timeFilter",
    STATUS_FILTER = "statusFilter",
    USER_FILTER = "userFilter",
    MONEY_FILTER = "moneyFilter",
    LOAD_TYPE_FILTER = "loadTypeFilter",
    PENDING = "pending",
    ACTIVE = "active",
    CLOSED = "closed",
    FTL = "ftl",
    LTL = "ltl",
    ALL = "all",
    DISPATCH_DATA_UPDATE = "dispatch-data-update"
}

declare enum eGeneralActions {
    ADD = "Add",
    ADD_LOWERCASE = "add",
    ADD_NEW = "Add New",
    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"
}

declare enum eUnit {
    DOLLAR_SIGN = "$",
    PERCENTAGE_SIGN = "%",
    MILE = "mi",
    GALLON = "gal.",
    DAYS = "days",
    HOURS = "hours",
    DAYS_SHORT = "d",
    HOURS_SHORT = "h",
    MINUTES_SHORT = "m",
    PX = "px",
    POUNDS = "lbs",
    FT = "ft"
}

declare enum eColor {
    BLACK = "#424242",
    TOTAL_BLACK = "#000000",
    LIGHT_GREY = "#CCCCCC",
    DARK_GREY = "#2F2F2F",
    WHITE = "#FFFFFF",
    BLUE = "#3B73ED",
    RED = "#DF3C3C"
}

declare enum eStyling {
    PX = "px",
    WIDTH = "width",
    MAX_WIDTH = "max-width",
    MIN_WIDTH = "min-width",
    HEIGHT = "height",
    MAX_HEIGHT = "max-height",
    MIN_HEIGHT = "min-height",
    TEXT_CONTENT = "textContent"
}

declare enum eCommonElement {
    LIST = "List",
    LIST_LOWERCASE = "list",
    CARD = "Card",
    CARD_LOWERCASE = "card",
    MAP = "Map",
    MAP_LOWERCASE = "map"
}

declare enum eSharedString {
    ONGOING = "Ongoing",
    COMMON = "Common",
    COMMON_LOWERCASE = "common",
    USER = "User",
    USER_LOWERCASE = "user",
    TRUCK = "truck",
    TRUCK_CAPITALIZED = "Truck",
    TRAILER = "trailer",
    DRIVER = "driver",
    MILES = "Miles",
    CDL = "cdl",
    DRUG_ALCOHOL = "drug-alcohol",
    MEDICAL = "medical",
    MVR = "mvr",
    GENERAL = "general",
    DETAILS = "details",
    BUSINESS = "business",
    SMALL = "small",
    HEIGHT = "height",
    DSC = "dsc",
    ASC = "asc",
    ASCENDING = "Ascending",
    DESCENDING = "Descending",
    DATA_IMAGE_JPG_BASE64 = "data:image/jpg;base64,",
    PICKUP = "Pickup",
    DELIVERY = "Delivery",
    FUEL = "Fuel",
    DEADHEAD = "DeadHead",
    REPAIR = "Repair",
    TOWING = "Towing",
    PARKING = "Parking",
    SPLIT_LOCATION = "SplitLocation",
    ADDRESS = "address",
    PO_BOX_ADDRESS = "poBoxAddress",
    PO_BOX = "poBox",
    INVITED = "Invited",
    TEMPLATE = "Template",
    PENDING = "Pending",
    ACTIVE = "Active",
    CLOSED = "Closed",
    DATE = "Date",
    COMMENT = "Comment",
    HUNDRED_PERCENT = "100%",
    RESULTS = "Results",
    PARKING_LOWERCASE = "parking",
    UNIT_NO = "unitNo",
    TYPE = "type",
    CLOSE = "Close",
    IGNITION = "IGNITION",
    CURRENT_LOCATION = "currentLocation"
}

declare enum eAnimationState {
    DEFAULT = "default",
    ROTATED = "rotated"
}

declare enum eDateTimeFormats {
    SHORT_FORMAT = "short-format",
    MONTH_FORMAT = "month-format",
    DIFFERENCE_DAYS = "difference-days",
    DATE_TIME = "date-time",
    TIME = "time",
    TIME_AGO = "time-ago",
    MM_DD_YY = "MM/dd/YY",
    HH_MM_A = "hh:mm A",
    HH_MM_AA = "hh:mm aa",
    MM_DD_YY_HH_MM_A = "MM/DD/YY, hh:mm A",
    YYYY_MM_DD_HH_MM_SS = "YYYY-MM-DD HH:mm:ss"
}

declare enum eThousandSeparatorFormat {
    REGULAR_FORMAT = "1.0-0",
    DECIMAL_FORMAT = "1.1-1",
    DECIMAL_DOUBLE_FORMAT = "1.2-2"
}

declare enum eGpsMotionStatus {
    MOVING = 1,
    SHORT_STOP = 2,
    EXTENDED_STOP = 3,
    PARKING = 4,
    NO_GPS_DEVICE = 5
}

declare enum eGpsHeadingDirection {
    N = "North",
    NE = "Northeast",
    E = "East",
    SE = "Southeast",
    S = "South",
    SW = "Southwest",
    W = "West",
    NW = "Northwest"
}

declare enum eDispatchStatus {
    Off = 1,
    Available = 2,
    Dispatched = 3,
    DeadHeading = 4,
    Canceled = 5,
    Repair = 6,
    DispatchedRepair = 7,
    LoadedRepair = 8,
    Towing = 9,
    CheckedIn = 10,
    Loaded = 11,
    Empty = 12,
    Offloaded = 13,
    Loading = 14,
    Offloading = 15,
    Break = 16,
    ArrivedPickup = 17,
    ArrivedDelivery = 18,
    CheckedInPickup = 19,
    CheckedInDelivery = 20,
    Split = 21
}

interface IProgressBarColorConfig {
    backColor: string;
    frontColor: string;
}

declare class CaProgressBarV2Component {
    progressPercentage: number;
    text: string | undefined;
    tooltipText: string | undefined;
    customText: string | undefined;
    customTextPrice: string | undefined;
    isTableColumn: boolean;
    isSmallProgressBar: boolean;
    colorConfig: IProgressBarColorConfig | undefined;
    isFocused: boolean;
    isBoldText: boolean;
    eColor: typeof eColor;
    ePosition: typeof ePosition;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<CaProgressBarV2Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaProgressBarV2Component, "app-ca-progress-bar-v2", never, { "progressPercentage": { "alias": "progressPercentage"; "required": false; }; "text": { "alias": "text"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "customText": { "alias": "customText"; "required": false; }; "customTextPrice": { "alias": "customTextPrice"; "required": false; }; "isTableColumn": { "alias": "isTableColumn"; "required": false; }; "isSmallProgressBar": { "alias": "isSmallProgressBar"; "required": false; }; "colorConfig": { "alias": "colorConfig"; "required": false; }; "isFocused": { "alias": "isFocused"; "required": false; }; "isBoldText": { "alias": "isBoldText"; "required": false; }; }, {}, never, never, true, never>;
}

declare class RatingReviewsRoutes {
    static likesButton: string;
    static dislikeButton: string;
    static reviewButton: string;
    static trash: string;
    static pen: string;
    static colaps: string;
    static removeSelectedValue: string;
    static add: string;
    static sortIcon: string;
    static confirm: string;
    static cancel: string;
}

declare enum RatingReviewsTypeEnum {
    All = "All",
    RATING = "RATING",
    REVIEW = "REVIEW"
}

interface IMultipleInput$1 {
    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 ICaInputWithDropdown$1 {
    withText: boolean;
    svg: boolean;
    image: boolean;
    iconsPath?: string;
    activeItemIconKey?: string;
    url?: string;
    nameInitialsInsteadUrl?: string;
    template?: string;
    color?: string;
    class?: string;
    remove?: boolean;
}
interface ICaInput$1 {
    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$1[];
        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$1 | 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;
}

interface RatingReviewModel {
    user: {
        avatarImage: string;
        name: string;
    };
    owner: boolean;
    id?: number;
    createdAt?: Date | null;
    updatedAt?: Date | null;
    comment: string;
    thumb: number;
}

declare class CaRatingReviewComponent implements OnInit {
    private formBuilder;
    ratingReviewList: RatingReviewModel[];
    companyUser: RatingReviewModel;
    isFilter: boolean;
    isSeaarch: boolean;
    isNewReview: boolean;
    ratingReviewData: EventEmitter<{
        data: RatingReviewModel;
        action: string;
    }>;
    likes: number;
    disLikes: number;
    reviews: number;
    filterList: RatingReviewModel[];
    isPopoverOpen: boolean;
    RatingReviewsType: RatingReviewsTypeEnum;
    isLikeClicked: boolean;
    isDisLikesClicked: boolean;
    isReviewsClicked: boolean;
    isSortedByDate: boolean;
    searchForm: UntypedFormGroup;
    constructor(formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    createForm(): void;
    getListDate(): void;
    getSvgPath(propertyName: keyof typeof RatingReviewsRoutes): string;
    get ratingReviewSearch(): ICaInput$1;
    data(event: {
        data: RatingReviewModel;
        action: string;
    }): void;
    checkLikesReviewNumner(): void;
    sortByDate(): void;
    openPopover(t2: NgbPopover): void;
    closePopover(t2: NgbPopover): void;
    removeFilters(): void;
    showFilters(filter: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaRatingReviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaRatingReviewComponent, "lib-ca-rating-review", never, { "ratingReviewList": { "alias": "ratingReviewList"; "required": false; }; "companyUser": { "alias": "companyUser"; "required": false; }; "isFilter": { "alias": "isFilter"; "required": false; }; "isSeaarch": { "alias": "isSeaarch"; "required": false; }; "isNewReview": { "alias": "isNewReview"; "required": false; }; }, { "ratingReviewData": "ratingReviewData"; }, never, never, true, never>;
}

declare class CaAppTooltipV2Component implements AfterViewInit {
    private ngbTooltop;
    template: TemplateRef<void>;
    mainCaTooltip?: string;
    position: string;
    tooltipBackground?: string;
    tooltipColor: string;
    tooltipTextAlign: string;
    tooltipMarginTop: string;
    tooltipMarginRight: string;
    set disableTooltip(isDisabled: boolean);
    set openTooltipDelay(value: number);
    private _openTooltipDelay;
    constructor(ngbTooltop: NgbTooltip);
    ngAfterViewInit(): void;
    private updateDelay;
    private setOpenDelay;
    bindTemplete(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaAppTooltipV2Component, [{ host: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaAppTooltipV2Component, "mainCaTooltip, [mainCaTooltip]", never, { "mainCaTooltip": { "alias": "mainCaTooltip"; "required": false; }; "position": { "alias": "position"; "required": false; }; "tooltipBackground": { "alias": "tooltipBackground"; "required": false; }; "tooltipColor": { "alias": "tooltipColor"; "required": false; }; "tooltipTextAlign": { "alias": "tooltipTextAlign"; "required": false; }; "tooltipMarginTop": { "alias": "tooltipMarginTop"; "required": false; }; "tooltipMarginRight": { "alias": "tooltipMarginRight"; "required": false; }; "disableTooltip": { "alias": "disableTooltip"; "required": false; }; "openTooltipDelay": { "alias": "openTooltipDelay"; "required": false; }; }, {}, never, ["*"], true, never>;
}

interface IDropDownActions {
    id: number;
    data: DropDownData;
    type: string;
}
interface DropDownData {
    id: number;
    title: string;
    mutedStyle: boolean;
    name: string;
    disabled?: boolean;
    hasBorder?: boolean;
    svgClass?: string;
    svgStyle?: {
        height: number;
        width: number;
    };
    svgUrl?: string;
}

declare class CaDetailsDropdownComponent {
    private chnd;
    private ngZone;
    options: DropDownData[];
    id: number;
    customClassDropDown: string;
    hasVericalDots: boolean;
    data: DropDownData;
    leftIcon: boolean;
    placement: string;
    dropDownActions: EventEmitter<IDropDownActions>;
    openModalAction: EventEmitter<string>;
    tooltip: NgbPopover;
    dropDownActive: number;
    subtypeHovered: boolean;
    constructor(chnd: ChangeDetectorRef, ngZone: NgZone);
    toggleDropdown(tooltip: NgbPopover): void;
    /**Function retrun id */
    identity(index: number): number;
    onAction(action: DropDownData, event?: Event): void | boolean;
    dropdownClosed(): void;
    popperOptions: (options: Partial<Options>) => Partial<Options>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaDetailsDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaDetailsDropdownComponent, "app-ca-details-dropdown", never, { "options": { "alias": "options"; "required": false; }; "id": { "alias": "id"; "required": false; }; "customClassDropDown": { "alias": "customClassDropDown"; "required": false; }; "hasVericalDots": { "alias": "hasVericalDots"; "required": false; }; "data": { "alias": "data"; "required": false; }; "leftIcon": { "alias": "leftIcon"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; }, { "dropDownActions": "dropDownActions"; "openModalAction": "openModalAction"; }, never, never, true, never>;
}

interface ArrayStatus {
    id?: number;
    name?: string;
    color?: string;
    hidden?: boolean;
    avatar?: string;
    isSelected?: boolean;
    currentSet?: boolean;
    icon?: string;
    truckNumber?: string;
    trailerNumber?: string;
    trailerType?: TrailerType$1;
    activeIcon?: string;
    image?: string;
    truckType?: TruckType$1;
    stateName?: string;
    stateShortName?: string;
    count?: number;
    logoName?: string | null;
    title?: string | null;
    logo?: string | null;
    subFolder?: string;
    logoType?: string;
}
interface TruckType$1 {
    companyId?: string;
    id?: number;
    logoName?: string;
    name?: string;
}
interface TrailerType$1 {
    companyId?: string;
    id?: number;
    logoName?: string;
    name?: string;
}

interface filterOutput {
    filterType: string;
    action: string;
    queryParams: {};
    subType: string;
}

interface filterOutputWithParams {
    action: string;
    type?: string;
    filterType: string;
    vacation?: boolean;
}

interface UserData {
    name: string;
    id: number;
    avatar?: string;
    icon?: string;
    count: number;
    hidden?: boolean;
    isSelected?: boolean;
    currentSet?: boolean;
}

interface UserGroup {
    label: string;
    isOpen: boolean;
    items: UserData[];
}

declare class TruckassistTableService {
    private setLoadStatusFilterOptions;
    currentLoadStatusFilterOptions: rxjs.Observable<any>;
    private actionAnimation;
    currentActionAnimation: rxjs.Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TruckassistTableService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TruckassistTableService>;
}

declare class CaStatusFilterComponent implements OnInit, OnDestroy {
    private tableService;
    type: string;
    isLegendView: boolean;
    isFilterActive: boolean;
    toDoSubType: string;
    loadStatusOptionsArray: ArrayStatus[];
    private destroy$;
    unselectedVisibleCount: number;
    selectedUser: ArrayStatus[];
    isButtonAvailable: boolean;
    isAscendingSortOrder: boolean;
    eLoadStatus: typeof eLoadStatus;
    filterActiveArray: ArrayStatus[];
    totalFiltersNum: number;
    constructor(tableService: TruckassistTableService);
    ngOnInit(): void;
    onFilterClose(): void;
    setFilterValue(): filterOutput | filterOutputWithParams;
    clearAll(event?: Event): filterOutput | filterOutputWithParams;
    sortItems(): void;
    private watchLoadStatusFilterValueChanges;
    addToSelectedUser(item: ArrayStatus, indx: number): void;
    removeFromSelectedUser(item: ArrayStatus, indx: number): void;
    checkFilterActiveValue(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaStatusFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaStatusFilterComponent, "app-ca-status-filter", never, { "type": { "alias": "type"; "required": false; }; "isLegendView": { "alias": "isLegendView"; "required": false; }; "isFilterActive": { "alias": "isFilterActive"; "required": false; }; "toDoSubType": { "alias": "toDoSubType"; "required": false; }; "loadStatusOptionsArray": { "alias": "loadStatusOptionsArray"; "required": false; }; }, {}, never, never, true, never>;
}

interface TimeFilterItem {
    label: string;
}
interface TimeFilterOptions {
    label: string;
    items: TimeFilterItem[];
}

declare class CaTimeFilterComponent implements OnInit, OnDestroy {
    type: string;
    timeSubType: string;
    isFilterActive: boolean;
    private destroy$;
    selectedTimeValue: string;
    selectedTimeYear: number | null;
    filterActiveTime: string;
    isButtonAvailable: boolean;
    lastYear: number | null;
    last2Years: number | null;
    timeOptionsArray: TimeFilterOptions[];
    ngOnInit(): void;
    private timeFilterInit;
    private timeOptionsInit;
    setTimeValue(mod: string, year?: number): void;
    onFilterClose(): void;
    setFilterValue($event: Event): filterOutput | filterOutputWithParams | undefined;
    clearAll(event?: Event): {
        action: eGeneralActions;
        type: string;
        filterType: string;
    };
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaTimeFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaTimeFilterComponent, "app-ca-time-filter", never, { "type": { "alias": "type"; "required": false; }; "timeSubType": { "alias": "timeSubType"; "required": false; }; "isFilterActive": { "alias": "isFilterActive"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaFiltersSvgRoutes {
    static arrowLeftSvgRoute: string;
    static sortArrowSvgRoute: string;
    static searchIconRoute: string;
    static iconConfirm: string;
    static removeSelectedValue: string;
    static cancelViolation: string;
    static arrowFilter: string;
}

interface userSelected {
    id?: number;
    name?: string;
    count?: number;
    hidden?: boolean;
    isSelected?: boolean;
    avatar?: string;
}

declare class CaDispatcherFilterComponent implements OnInit, OnDestroy {
    private formBuilder;
    type: string;
    isFilterActive: boolean;
    filterTitle: string;
    hasLeftSideIcon: boolean;
    toDoSubType: string;
    unselectedUser: ArrayStatus[];
    isSearchExpanded: boolean;
    private destroy$;
    eLoadStatus: typeof eLoadStatus;
    searchForm: UntypedFormGroup;
    searchInputValue: string;
    unselectedVisibleCount: number;
    caFiltersSvgRoutes: CaFiltersSvgRoutes;
    selectedUser: userSelected[];
    filterActiveArray: ArrayStatus[];
    isAscendingSortOrder: boolean;
    isButtonAvailable: boolean;
    totalFiltersNum: number;
    constructor(formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    get dispatcherSearch(): ICaInput$1;
    getInitials(name: string | undefined): string;
    onFilterClose(): void;
    setFilterValue($event: Event): filterOutput | filterOutputWithParams | undefined;
    clearAll(event?: Event): filterOutput | filterOutputWithParams;
    private createForm;
    addToSelectedUser(item: userSelected, indx: number): void;
    removeFromSelectedUser(item: userSelected, indx: number): void;
    checkFilterActiveValue(): void;
    private watchSearchFormValueChanges;
    sortItems(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaDispatcherFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaDispatcherFilterComponent, "app-ca-dispatcher-filter", never, { "type": { "alias": "type"; "required": false; }; "isFilterActive": { "alias": "isFilterActive"; "required": false; }; "filterTitle": { "alias": "filterTitle"; "required": false; }; "hasLeftSideIcon": { "alias": "hasLeftSideIcon"; "required": false; }; "toDoSubType": { "alias": "toDoSubType"; "required": false; }; "unselectedUser": { "alias": "unselectedUser"; "required": false; }; "isSearchExpanded": { "alias": "isSearchExpanded"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaStateFilterComponent implements OnInit, OnDestroy {
    private formBuilder;
    type: string;
    isFilterActive: boolean;
    isSearchExpanded: boolean;
    usaStates: ArrayStatus[];
    canadaStates: ArrayStatus[];
    private destroy$;
    searchForm: UntypedFormGroup;
    usaSelectedStates: ArrayStatus[];
    canadaSelectedStates: ArrayStatus[];
    searchInputValue: string | null;
    filterUsaActiveArray: ArrayStatus[];
    filterCanadaActiveArray: ArrayStatus[];
    isButtonAvailable: boolean;
    totalFiltersNum: number;
    unselectedVisibleCount: number;
    caFiltersSvgRoutes: CaFiltersSvgRoutes;
    constructor(formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    get stateSearch(): ICaInput$1;
    private createForm;
    private watchSearchFormValueChanges;
    onFilterClose(): void;
    addToSelectedUser(item: {
        id?: number;
        stateName?: string;
        count?: number;
        hidden?: boolean;
        isSelected?: boolean;
    }, indx: number, subType?: string): void;
    checkFilterActiveValue(): void;
    removeFromSelectedUser(item: {
        id?: number;
        stateName?: string;
        count?: number;
        hidden?: boolean;
        isSelected?: boolean;
    }, indx: number, subType?: string): void;
    setFilterValue(): filterOutput | filterOutputWithParams;
    clearAll(event?: Event): filterOutput | filterOutputWithParams;
    getSvgPath(propertyName: keyof typeof CaFiltersSvgRoutes): string;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaStateFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaStateFilterComponent, "app-ca-state-filter", never, { "type": { "alias": "type"; "required": false; }; "isFilterActive": { "alias": "isFilterActive"; "required": false; }; "isSearchExpanded": { "alias": "isSearchExpanded"; "required": false; }; "usaStates": { "alias": "usaStates"; "required": false; }; "canadaStates": { "alias": "canadaStates"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaTruckTypeFilterComponent implements OnInit, OnDestroy {
    private formBuilder;
    type: string;
    isFilterActive: boolean;
    hasLeftSideIcon: boolean;
    truckTypeArray: ArrayStatus[];
    isRepairFilter: boolean;
    isSearchExpanded: boolean;
    private destroy$;
    selectedTruckTypeArray: ArrayStatus[];
    isButtonAvailable: boolean;
    isAscendingSortOrder: boolean;
    filterActiveArray: ArrayStatus[];
    unselectedVisibleCount: number;
    searchForm: UntypedFormGroup;
    searchInputValue: string;
    constructor(formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    get truckTypeSearch(): ICaInput$1;
    private createForm;
    private watchSearchFormValueChanges;
    onFilterClose(): void;
    sortItems(): void;
    addToSelectedUser(item: userSelected, indx: number): void;
    removeFromSelectedUser(item: userSelected, indx: number): void;
    setFilterValue(): filterOutput | filterOutputWithParams | undefined;
    clearAll(event?: Event): filterOutput | filterOutputWithParams;
    checkFilterActiveValue(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaTruckTypeFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaTruckTypeFilterComponent, "app-ca-truck-type-filter", never, { "type": { "alias": "type"; "required": false; }; "isFilterActive": { "alias": "isFilterActive"; "required": false; }; "hasLeftSideIcon": { "alias": "hasLeftSideIcon"; "required": false; }; "truckTypeArray": { "alias": "truckTypeArray"; "required": false; }; "isRepairFilter": { "alias": "isRepairFilter"; "required": false; }; "isSearchExpanded": { "alias": "isSearchExpanded"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaTrailerTypeFilterComponent implements OnInit, OnDestroy {
    private formBuilder;
    type: string;
    isFilterActive: boolean;
    hasLeftSideIcon: boolean;
    trailerTypeArray: ArrayStatus[];
    isSearchExpanded: boolean;
    isRepairFilter: boolean;
    private destroy$;
    selectedTrailerTypeArray: ArrayStatus[];
    isButtonAvailable: boolean;
    isAscendingSortOrder: boolean;
    filterActiveArray: ArrayStatus[];
    unselectedVisibleCount: number;
    searchForm: UntypedFormGroup;
    searchInputValue: string;
    constructor(formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    get trailerTypeSearch(): ICaInput$1;
    private createForm;
    private watchSearchFormValueChanges;
    onFilterClose(): void;
    sortItems(): void;
    addToSelectedUser(item: userSelected, indx: number): void;
    removeFromSelectedUser(item: userSelected, indx: number): void;
    setFilterValue(): filterOutput | filterOutputWithParams;
    clearAll(event?: Event): filterOutput | filterOutputWithParams;
    checkFilterActiveValue(): void;
    getSvgPath(propertyName: keyof typeof CaFiltersSvgRoutes): string;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaTrailerTypeFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaTrailerTypeFilterComponent, "app-ca-trailer-type-filter", never, { "type": { "alias": "type"; "required": false; }; "isFilterActive": { "alias": "isFilterActive"; "required": false; }; "hasLeftSideIcon": { "alias": "hasLeftSideIcon"; "required": false; }; "trailerTypeArray": { "alias": "trailerTypeArray"; "required": false; }; "isSearchExpanded": { "alias": "isSearchExpanded"; "required": false; }; "isRepairFilter": { "alias": "isRepairFilter"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaPmFilterComponent implements OnDestroy {
    type: string;
    isFilterActive: boolean;
    hasLeftSideIcon: boolean;
    pmSubtype: string;
    pmFilterArray: ArrayStatus[];
    private destroy$;
    selectedPmFilterArray: ArrayStatus[];
    isButtonAvailable: boolean;
    isAscendingSortOrder: boolean;
    filterActiveArray: ArrayStatus[];
    unselectedVisibleCount: number;
    sortItems(): void;
    onFilterClose(): void;
    addToSelectedUser(item: userSelected, indx: number): void;
    removeFromSelectedUser(item: userSelected, indx: number): void;
    setFilterValue(): filterOutput | filterOutputWithParams;
    clearAll(event?: Event): filterOutput | filterOutputWithParams;
    checkFilterActiveValue(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaPmFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaPmFilterComponent, "app-ca-pm-filter", never, { "type": { "alias": "type"; "required": false; }; "isFilterActive": { "alias": "isFilterActive"; "required": false; }; "hasLeftSideIcon": { "alias": "hasLeftSideIcon"; "required": false; }; "pmSubtype": { "alias": "pmSubtype"; "required": false; }; "pmFilterArray": { "alias": "pmFilterArray"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaUserFilterComponent implements OnInit, OnDestroy {
    private formBuilder;
    type: string;
    isFilterActive: boolean;
    filterTitle: string;
    hasLeftSideIcon: boolean;
    toDoSubType: string;
    userGroup: UserGroup[];
    isSearchExpanded: boolean;
    private destroy$;
    eLoadStatus: typeof eLoadStatus;
    searchForm: UntypedFormGroup;
    searchInputValue: string;
    unselectedVisibleCount: number;
    caFiltersSvgRoutes: CaFiltersSvgRoutes;
    selectedUserGroup: UserGroup[];
    filterActiveArray: UserGroup[];
    isAscendingSortOrder: boolean;
    isButtonAvailable: boolean;
    hasSelectedUsers: boolean;
    totalFiltersNum: number;
    constructor(formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    get userSearch(): ICaInput$1;
    getInitials(name: string | undefined): string;
    onGroupSwitchState(group: UserGroup): void;
    onCheckboxSelect(event: Event, group: UserGroup): void;
    onFilterClose(): void;
    setFilterValue(event: Event): filterOutput | filterOutputWithParams | undefined;
    clearAll(event?: Event): filterOutput | filterOutputWithParams;
    private createForm;
    handleSelectedUsers(item: UserData, indx: number, indx2: number): void;
    addToSelectedUser(item: UserData, indx: number, indx2: number): void;
    removeFromSelectedUser(item: UserData, indx: number, indx2: number): void;
    checkFilterActiveValue(): void;
    private watchSearchFormValueChanges;
    sortItems(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaUserFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaUserFilterComponent, "app-ca-user-filter", never, { "type": { "alias": "type"; "required": false; }; "isFilterActive": { "alias": "isFilterActive"; "required": false; }; "filterTitle": { "alias": "filterTitle"; "required": false; }; "hasLeftSideIcon": { "alias": "hasLeftSideIcon"; "required": false; }; "toDoSubType": { "alias": "toDoSubType"; "required": false; }; "userGroup": { "alias": "userGroup"; "required": false; }; "isSearchExpanded": { "alias": "isSearchExpanded"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaAutoclosePopoverComponent implements OnInit {
    private eRef;
    isDisabled: boolean;
    customClass: string;
    autoClose: string | boolean;
    placement: string;
    closeFilter: EventEmitter<void>;
    openFilter: EventEmitter<void>;
    tooltip: NgbPopover | null;
    constructor(eRef: ElementRef);
    ngOnInit(): void;
    switchTab(event: Event, t2: NgbPopover): void;
    onFilterClose(): void;
    onFilterShown(): void;
    closeCustomPopover(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaAutoclosePopoverComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaAutoclosePopoverComponent, "[app-ca-autoclose-popover]", never, { "isDisabled": { "alias": "isDisabled"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "autoClose": { "alias": "autoClose"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; }, { "closeFilter": "closeFilter"; "openFilter": "openFilter"; }, never, ["[mainContent]", "[popoverContent]"], true, never>;
}

declare class ThousandSeparatorPipe implements PipeTransform {
    transform(value: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThousandSeparatorPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThousandSeparatorPipe, "thousandSeparator", true>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThousandSeparatorPipe>;
}

declare class CaViolationFilterComponent implements OnInit, OnDestroy {
    private formBuilder;
    private thousandSeparator;
    type: string;
    isFilterActive: boolean;
    toDoSubType: string;
    private destroy$;
    violationFilterForm: UntypedFormGroup;
    minValueRange: string;
    maxValueRange: string;
    minValueSet: string;
    maxValueSet: string;
    minValueDragged: number;
    maxValueDragged: number;
    rangeValue: number;
    rangeDiffNum: number;
    violationSliderData: Options$1;
    constructor(formBuilder: UntypedFormBuilder, thousandSeparator: ThousandSeparatorPipe);
    ngOnInit(): void;
    setMinValueRange(mod: number | ChangeContext): void;
    setMaxValueRange(mod: number | ChangeContext): void;
    onFilterClose(): void;
    private createForm;
    clearAll(event?: Event): filterOutput | filterOutputWithParams | undefined;
    setFilterValue(event: Event | undefined): filterOutput | filterOutputWithParams | undefined;
    getSvgPath(propertyName: keyof typeof CaFiltersSvgRoutes): string;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaViolationFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaViolationFilterComponent, "app-ca-violation-filter", never, { "type": { "alias": "type"; "required": false; }; "isFilterActive": { "alias": "isFilterActive"; "required": false; }; "toDoSubType": { "alias": "toDoSubType"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaCollapsibleFilterComponent {
    isExpanded: boolean;
    filterArray: ArrayStatus[];
    type: string;
    onTagEmit: EventEmitter<Event>;
    selectedFilterArray: ArrayStatus[];
    addToSelectedUser(item: userSelected, event: Event): void;
    removeFromSelectedUser(item: userSelected, event: Event): void;
    onTagClick(event: Event, item: ArrayStatus): void;
    setFilterValue(): filterOutput;
    toggleExpand(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaCollapsibleFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaCollapsibleFilterComponent, "app-ca-collapsible-filter", never, { "isExpanded": { "alias": "isExpanded"; "required": false; }; "filterArray": { "alias": "filterArray"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "onTagEmit": "onTagEmit"; }, never, never, true, never>;
}

interface SortColumn {
    name: string;
    sortName: string;
    isDisabled?: boolean;
    template?: TemplateRef<any>;
}

declare enum eFilterDropdownEnum {
    DISPATCHER = "Dispatcher",
    STATUS = "Status",
    PARKING = "Parking",
    TRAILER_TYPE = "TrailerType",
    TRUCK_TYPE = "TruckType",
    TRAILER = "Trailer",
    TRUCK = "Truck",
    PM = "Pm",
    FUEL_ITEM = "FuelItem",
    FUEL_STOP = "FuelStop",
    TIME_FILTER = "TimeFilter",
    SERVICE = "Service",
    STATE = "State",
    DEPARTMENT = "Department",
    LABEL = "Label",
    LOAD_TYPE = "LoadType"
}

declare enum eFilterTime {
    DAY = "day",
    DAYS = "days",
    WEEK = "week",
    WEEKS = "weeks",
    MONTH = "month",
    MONTHS = "months",
    QUARTER = "quarter",
    QUARTERS = "quarters",
    YEAR = "year",
    YEARS = "years",
    TODAY = "today",
    YESTERDAY = "yesterday",
    THIS_WEEK = "wtd",
    NEXT_WEEK = "next week",
    LAST_WEEK = "last week",
    ONE_WEEK = "1 week",
    ONE_WEEK_FUTURE = "week_future",
    THIS_MONTH = "mtd",
    NEXT_MONTH = "next month",
    LAST_MONTH = "last month",
    ONE_MONTH = "1 month",
    ONE_MONTH_FUTURE = "1 month future",
    THREE_MONTHS = "3 months",
    THREE_MONTHS_FUTURE = "3 months future",
    THIS_QUARTER = "qtd",
    NEXT_QUARTER = "next quarter",
    LAST_QUARTER = "last quarter",
    THIS_YEAR = "ytd",
    ONE_YEAR = "1 year",
    ONE_YEAR_FUTURE = "1 year future",
    LAST_YEAR = "last year",
    YEAR_BEFORE_LAST = "year before last",
    MOMENT_DATE_FORMAT = "MM/DD/YY"
}

declare enum eFilterSortingKey {
    NAME = "name",
    COUNT = "count"
}

interface IFilterDropdownConfiguration {
    icon: string;
    title: string;
    tooltipText: string;
    sortColumns: SortColumn[];
    filterType: eFilterDropdownEnum;
    isSearchActive?: boolean;
    searchTitle?: string;
    formFieldConfig?: ICaInput$1;
    isDisplayCount?: boolean;
}

interface IFilterDropdownList {
    id?: number;
    count?: number;
    name?: string;
    selected?: boolean;
    avatar?: {
        fileId?: number;
        fileName?: string | null;
        url?: string | null;
        fileSize?: number | null;
        tags?: Array<string> | null;
        tagGeneratedByUser?: boolean;
        updatedAt?: string | null;
    };
    icon?: string;
    stateShortName?: string | null;
    initials?: string;
}

interface ITimeOptions {
    label: string;
    items: {
        label: string;
        id: number;
        value: string;
        year?: number | string;
    }[];
}

interface IFilterAction {
    action?: string;
    filterType: eFilterDropdownEnum | 'moneyFilter' | 'locationFilter' | 'statusType';
    type?: string | number;
    queryParams?: {
        fromDate?: string | null;
        toDate?: string | null;
        longValue?: number;
        latValue?: number;
        rangeValue?: number;
        from?: number;
        to?: number;
        moneyArray?: {
            from: number;
            to: number;
        }[];
    };
    selectedIds?: number[];
    selectedStates?: string[];
}

interface IState {
    stateName: string;
    stateShortName: string | null;
    count: number;
}
interface ICountry {
    country: string;
    states: IState[];
    selectedList: IFilterDropdownList[];
    unselectedList: IFilterDropdownList[];
    initalList: IFilterDropdownList[];
}

type FilterDropdownTypes = eFilterDropdownEnum.DISPATCHER | eFilterDropdownEnum.STATUS | eFilterDropdownEnum.TRUCK_TYPE | eFilterDropdownEnum.TRAILER_TYPE | eFilterDropdownEnum.PM | eFilterDropdownEnum.SERVICE | eFilterDropdownEnum.FUEL_ITEM | eFilterDropdownEnum.FUEL_STOP | eFilterDropdownEnum.STATE | eFilterDropdownEnum.TIME_FILTER | eFilterDropdownEnum.LABEL | eFilterDropdownEnum.LOAD_TYPE;

declare enum GoogleMapEnum {
    STROKE_OPACITY = 0.4,
    STROKE_COLOR = "blue",
    STROKE_WEIGHT = 4,
    DARK_MAP = "dark_map"
}

declare enum eMapMarkerString {
    PICKUP = "pickup",
    DELIVERY = "delivery",
    DEADHEAD = "deadhead",
    REPAIR = "repair",
    FUEL = "fuel",
    TOWING = "towing",
    PARKING = "parking",
    REDIRECT_LOCATION = "redirectlocation",
    REDIRECTED_DELIVERY = "redirecteddelivery",
    REDIRECTED_PICKUP = "redirectedpickup",
    SPLIT_LOCATION = "splitlocation",
    CURRENT_LOCATION = "Current Location",
    DARK = "dark",
    LIGHT = "light",
    WHITE = "white",
    SELECTED = "selected",
    CANCELLED = "cancelled",
    CANCELLED_PICKUP = "cancelledpickup",
    CANCELLED_DELIVERY = "cancelleddelivery",
    SPLIT_MARKER_TEXT = "S"
}

declare enum ToolbarFilterStringEnum {
    DEPARTMENT_FILTER = "departmentFilter",
    STATUS_FILTER = "statusFilter",
    PM_FILTER = "pmFilter",
    CATEGORY_FUEL_FILTER = "categoryFuelFilter",
    CATEGORY_REPAIR_FILTER = "categoryRepairFilter",
    SERVICE_FILTER = "serviceFilter",
    TRUCK_FILTER = "truckFilter",
    TRAILER_FILTER = "trailerFilter",
    FUEL_STOP_FILTER = "fuelStopFilter",
    BROKER_FILTER = "brokerFilter",
    DRIVER_FILTER = "driverFilter",
    TRUCK_TYPE_FILTER = "truckTypeFilter",
    TRAILER_TYPE_FILTER = "trailerTypeFilter",
    USER_FILTER = "userFilter",
    MODULE_FILTER = "moduleFilter",
    STATE_FILTER = "stateFilter",
    LABEL_FILTER = "labelFilter",
    TIME_FILTER = "timeFilter",
    TIME_FILTER_DROPDOWN = "timeFilterDropdown",
    INJURY_FILTER = "injuryFilter",
    FATALITY_FILTER = "fatalityFilter",
    VIOLATION_FILTER = "violationFilter",
    VACATION_FILTER = "vacationFilter",
    LOCATION_FILTER = "locationFilter",
    MONEY_FILTER = "moneyFilter",
    MILES_FILTER = "milesFilter",
    PAY_FILTER = "payFilter",
    DISPATCHER_FILTER = "dispatcherFilter",
    FUEL_ITEM_FILTER = "fuelItemFilter",
    PARKING_FILTER = "parkingFilter",
    TAG_FILTER = "tagFilter",
    ACTION_FILTER = "actionFilter",
    MONEY_FILTER_2 = "Money Filter",
    MILES_FILTER_2 = "Miles Filter",
    STATUS_FILTER_2 = "Status Filter",
    TIME_FILTER_2 = "Time Filter",
    DISPATCHER_FILTER_2 = "Dispatcher Filter",
    DRIVER_FILTER_2 = "Driver Filter",
    FUEL_STOP_FILTER_2 = "Fuel Stop Filter",
    BROKER_FILTER_2 = "Broker Filter",
    USER_FILTER_2 = "User Filter",
    MODULE_FILTER_2 = "Module Filter",
    STATE_FILTER_2 = "State / Province Filter",
    TRUCK_TYPE_FILTER_2 = "Truck Type Filter",
    TRAILER_TYPE_FILTER_2 = "Trailer Type Filter",
    TRUCK_UNIT_FILTER_2 = "Truck Unit Filter",
    TRAILER_UNIT_FILTER_2 = "Trailer Unit Filter",
    PM_FILTER_2 = "PM Filter",
    SERVICE_FILTER_2 = "Service Filter",
    FUEL_ITEM_FILTER_2 = "Fuel Item Filter",
    DEPARTMENT_FILTER_2 = "Department Filter",
    PARKING_FILTER_2 = "Parking Filter",
    TAG_FILTER_2 = "Tag Filter",
    ACTION_FILTER_2 = "Action Filter",
    LABEL_FILTER_2 = "Label Filter",
    AREA_FILTER = "Area Filter",
    VIOLATION_FILTER_2 = "Violation Filter",
    LOCATION = "Location",
    IC_ADDRESS = "ic_address",
    PAST = "past",
    FUTURE = "future",
    SHORT = "short",
    DOLLAR = "dollar",
    BROKER_HALF_CIRCLE = "broker-half-circle",
    TIME = "ic_time",
    USER = "user",
    STATE = "state",
    TRUCK = "truck",
    TRAILER = "trailer",
    DEFAULT_PM = "default_pm",
    IC_KEY_REPAIR = "ic_key-repair",
    FUEL = "fuel",
    LABEL = "label",
    MILES = "miles",
    MAIN_TOOLTIP = "mainTooltip",
    CLOSE_FILTER = "Close Filter",
    REMOVE_FILTER = "Remove Filter",
    FILTER_TEXT = "filterText",
    USER_BOX = "userBox",
    SORT_ITEMS = "sortItems",
    CANADA = "canada",
    CANADA_2 = "Canada",
    EMPTY_STRING_PLACEHOLDER = "",
    BOOLEAN = "boolean",
    TEXT = "text",
    SET = "Set",
    CLEAR = "Clear",
    ACTIVE = "active",
    PENDING_STATUS = "pendingStatus",
    ALL = "all",
    MIN_VALUE = "0",
    MAX_VALUE = "5,000",
    MONEY_MAX_VALUE = "20,000",
    VIOLATION_MAX_VALUE = "5",
    FROM = "from",
    TO = "to",
    MONEY_ARRAY = "moneyArray",
    REPAIR_CATEGORY_UPDATE = "repair-category-update",
    PM_TRAILER_DATA_UPDATE = "pm-trailer-data-update"
}

declare enum eMapMarkerStopType {
    DEADHEAD_STOP = 0,
    PICKUP_STOP = 1,
    DELIVERY_STOP = 2,
    SPLIT_LOCATION_STOP = 3,
    CANCELLED_PICKUP_STOP = 4,
    REDIRECTED_PICKUP_STOP = 5,
    CANCELLED_DELIVERY_STOP = 6,
    REDIRECTED_DELIVERY_STOP = 7,
    REDIRECT_LOCATION_STOP = 8,
    CURRENT_LOCATION_STOP = 999
}

type FilterSortingKey = eFilterSortingKey.COUNT | eFilterSortingKey.NAME;

interface ISortEmit {
    sortKey: FilterSortingKey;
    directionMultiplier: 1 | -1;
}

declare class CaTimeFilterDropdownComponent implements OnInit, OnDestroy {
    type: string;
    timeSubType: string;
    isFilterActive: boolean;
    selectedTimeValue: string;
    itemSelected: EventEmitter<Event>;
    private destroy$;
    selectedTimeYear: number | null;
    filterActiveTime: string;
    isButtonAvailable: boolean;
    lastYear: number | null;
    last2Years: number | null;
    timeOptionsArray: ITimeOptions[];
    ngOnInit(): void;
    private timeFilterInit;
    private timeOptionsInit;
    setTimeValue(mod: string, year?: number): void;
    onFilterClose(): void;
    setFilterValue($event: Event): filterOutput | filterOutputWithParams | undefined;
    private convertTimeToDate;
    clearAll(event?: Event): {
        action: eGeneralActions;
        type: string;
        filterType: string;
    };
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaTimeFilterDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaTimeFilterDropdownComponent, "app-ca-time-filter-dropdown", never, { "type": { "alias": "type"; "required": false; }; "timeSubType": { "alias": "timeSubType"; "required": false; }; "isFilterActive": { "alias": "isFilterActive"; "required": false; }; "selectedTimeValue": { "alias": "selectedTimeValue"; "required": false; }; }, { "itemSelected": "itemSelected"; }, never, never, true, never>;
}

declare class CaFilterComponent implements OnDestroy {
    private renderer;
    t2: NgbPopover;
    autoClose: CaAutoclosePopoverComponent;
    caStatusFilter: CaStatusFilterComponent;
    caTimeFilter: CaTimeFilterComponent;
    caTimeFilterDropdown: CaTimeFilterDropdownComponent;
    caDispatcherFilter: CaDispatcherFilterComponent;
    caStateFilter: CaStateFilterComponent;
    caTruckTypeFilter: CaTruckTypeFilterComponent;
    caTrailerTypeFilter: CaTrailerTypeFilterComponent;
    caPmFilter: CaPmFilterComponent;
    caCollapsibleFilter: CaCollapsibleFilterComponent;
    caUserFilter: CaUserFilterComponent;
    caViolationFilter: CaViolationFilterComponent;
    type: string;
    isDisabled: boolean;
    timeSubType: string;
    subType: string;
    unselectedUser: ArrayStatus[];
    userGroup: UserGroup[];
    loadStatusOptionsArray: ArrayStatus[];
    truckTypeArray: ArrayStatus[];
    trailerTypeArray: ArrayStatus[];
    pmFilterArray: ArrayStatus[];
    selectedTimeValue: string;
    isRepairFilter: boolean;
    hasNoLeftIcon: boolean;
    hasLeftSideIcon: boolean;
    hasLargeLeftIcon: boolean;
    isMoneyFilter: boolean;
    isMilesFilter: boolean;
    isButtonFilter: boolean;
    isFuelType: boolean;
    isLoadType: boolean;
    isCollapsibleFilter: boolean;
    filterTitle: string;
    icon: string;
    usaStates: ArrayStatus[];
    canadaStates: ArrayStatus[];
    setFilter: EventEmitter<filterOutput | filterOutputWithParams>;
    clearAll: EventEmitter<filterOutput | filterOutputWithParams>;
    private destroy$;
    isSearchExpanded: boolean;
    isFilterActive: boolean;
    selectedUser: ArrayStatus[];
    isAscendingSortOrder: boolean;
    autoCloseComponent: QueryList<CaAutoclosePopoverComponent>;
    isHoverClosed: boolean;
    isFilterHoveredOver: boolean;
    isAnimated: boolean;
    isFilterActiveColor: boolean;
    filterCount: number;
    hasFilterCount: boolean;
    constructor(renderer: Renderer2);
    ngOnInit(): void;
    getComponentInstance(): CaFilterComponent;
    isNotDropdown(): boolean;
    getFilterCount(): number;
    onFilterClose(): boolean;
    onFilterShown(): void;
    sortItems(): void;
    showSearch(mod?: string): void;
    setFilterValue(event: Event): void;
    setFilterEmit(data: filterOutput | filterOutputWithParams | undefined): void;
    clearAllValues(event?: Event): void;
    clearAllValuesEmit(data: filterOutput | filterOutputWithParams | undefined): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaFilterComponent, "app-ca-filter", never, { "type": { "alias": "type"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "timeSubType": { "alias": "timeSubType"; "required": false; }; "subType": { "alias": "subType"; "required": false; }; "unselectedUser": { "alias": "unselectedUser"; "required": false; }; "userGroup": { "alias": "userGroup"; "required": false; }; "loadStatusOptionsArray": { "alias": "loadStatusOptionsArray"; "required": false; }; "truckTypeArray": { "alias": "truckTypeArray"; "required": false; }; "trailerTypeArray": { "alias": "trailerTypeArray"; "required": false; }; "pmFilterArray": { "alias": "pmFilterArray"; "required": false; }; "selectedTimeValue": { "alias": "selectedTimeValue"; "required": false; }; "isRepairFilter": { "alias": "isRepairFilter"; "required": false; }; "hasNoLeftIcon": { "alias": "hasNoLeftIcon"; "required": false; }; "hasLeftSideIcon": { "alias": "hasLeftSideIcon"; "required": false; }; "hasLargeLeftIcon": { "alias": "hasLargeLeftIcon"; "required": false; }; "isMoneyFilter": { "alias": "isMoneyFilter"; "required": false; }; "isMilesFilter": { "alias": "isMilesFilter"; "required": false; }; "isButtonFilter": { "alias": "isButtonFilter"; "required": false; }; "isFuelType": { "alias": "isFuelType"; "required": false; }; "isLoadType": { "alias": "isLoadType"; "required": false; }; "isCollapsibleFilter": { "alias": "isCollapsibleFilter"; "required": false; }; "filterTitle": { "alias": "filterTitle"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "usaStates": { "alias": "usaStates"; "required": false; }; "canadaStates": { "alias": "canadaStates"; "required": false; }; }, { "setFilter": "setFilter"; "clearAll": "clearAll"; }, never, never, true, never>;
}

declare class CaFilterDropdownComponent {
    activeCount: number;
    type: FilterDropdownTypes;
    config: IFilterDropdownConfiguration;
    bodyTemplate: TemplateRef<any>;
    isFormChanged: boolean;
    appliedFiltersCount: number;
    customTitle: string | false;
    customCancelButton: string | false;
    isDisabled: boolean;
    svgCustomSizeClass: string;
    setFilter: EventEmitter<IFilterAction>;
    handleFiltersClear: EventEmitter<boolean>;
    resetFilterState: EventEmitter<boolean>;
    sorting: EventEmitter<ISortEmit>;
    selectedList: IFilterDropdownList[];
    unselectedList: IFilterDropdownList[];
    activeSortType: SortColumn;
    filterPopoverOpen: NgbPopover | null;
    caFiltersSvgRoutes: typeof CaFiltersSvgRoutes;
    isClosingManually: boolean;
    handleSortClick(event: {
        column: SortColumn;
        sortName: string;
        direction: string;
    }): void;
    openClosePopover(popover: NgbPopover): void;
    applyFilters(): void;
    onFilterClear(): void;
    onClickOutside(): void;
    private sortLists;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaFilterDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaFilterDropdownComponent, "app-ca-filter-dropdown", never, { "activeCount": { "alias": "activeCount"; "required": false; }; "type": { "alias": "type"; "required": false; }; "config": { "alias": "config"; "required": false; }; "bodyTemplate": { "alias": "bodyTemplate"; "required": false; }; "isFormChanged": { "alias": "isFormChanged"; "required": false; }; "appliedFiltersCount": { "alias": "appliedFiltersCount"; "required": false; }; "customTitle": { "alias": "customTitle"; "required": false; }; "customCancelButton": { "alias": "customCancelButton"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "svgCustomSizeClass": { "alias": "svgCustomSizeClass"; "required": false; }; }, { "setFilter": "setFilter"; "handleFiltersClear": "handleFiltersClear"; "resetFilterState": "resetFilterState"; "sorting": "sorting"; }, never, never, true, never>;
}

declare abstract class NewFilterBaseComponent implements OnInit {
    private _entityType;
    set entityType(value: string);
    get entityType(): string;
    setFilter: EventEmitter<IFilterAction>;
    eFilterDropdownEnum: typeof eFilterDropdownEnum;
    config: IFilterDropdownConfiguration;
    constructor();
    ngOnInit(): void;
    protected abstract clearValues(shouldEmit: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NewFilterBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NewFilterBaseComponent, "lib-new-filter-base", never, { "entityType": { "alias": "entityType"; "required": false; }; }, { "setFilter": "setFilter"; }, never, never, true, never>;
}

declare class CaFilterStateDropdownComponent extends NewFilterBaseComponent {
    private formBuilder;
    set states(value: ICountry[]);
    isDisabled: boolean;
    sortKey: keyof IFilterDropdownList;
    directionMultiplier: number;
    caFiltersSvgRoutes: typeof CaFiltersSvgRoutes;
    selectedList: IFilterDropdownList[];
    unselectedList: IFilterDropdownList[];
    searchForm: _angular_forms.UntypedFormGroup;
    stateSearchForm: ICaInput$1;
    selectedCount: number;
    activeCount: number;
    config: IFilterDropdownConfiguration;
    private _states;
    constructor(formBuilder: UntypedFormBuilder);
    get states(): ICountry[];
    calculateSelectedCount(): void;
    selectItem: (item: IFilterDropdownList, countryName: string) => void;
    unSelectItem: (item: IFilterDropdownList, countryName: string) => void;
    clearValues(isEmittingValue: boolean): void;
    passFilterValue(): void;
    sortValues(sorting: ISortEmit): void;
    private emitData;
    private mapInitalStates;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaFilterStateDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaFilterStateDropdownComponent, "app-ca-filter-state-dropdown", never, { "states": { "alias": "states"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaFilterListDropdownComponent extends NewFilterBaseComponent {
    private formBuilder;
    set type(value: FilterDropdownTypes);
    set list(value: IFilterDropdownList[]);
    isDisabled: boolean;
    svgCustomSizeClass: string;
    caFiltersSvgRoutes: typeof CaFiltersSvgRoutes;
    loadStatusEnum: typeof eLoadStatus;
    scrollLimitSize: number;
    previousUnSelectedState: IFilterDropdownList[];
    previousSelectedState: IFilterDropdownList[];
    selectedList: IFilterDropdownList[];
    unselectedList: IFilterDropdownList[];
    searchForm: _angular_forms.UntypedFormGroup;
    sortKey: keyof IFilterDropdownList;
    directionMultiplier: number;
    initialListSize: number;
    selectedCount: number;
    activeCount: number;
    private _type;
    private _list;
    constructor(formBuilder: UntypedFormBuilder);
    get type(): FilterDropdownTypes;
    selectItem: (item: IFilterDropdownList) => void;
    unSelectItem: (item: IFilterDropdownList) => void;
    get truckOrTrailerIconPipe(): PipeTransform;
    clearValues(isEmittingValue: boolean): void;
    passFilterValue(): void;
    sortValues(sorting: ISortEmit): void;
    onResetFilterState(): void;
    private emitData;
    private updateLists;
    private moveItem;
    private calculateSelectedCount;
    private setInitialList;
    private setInitialType;
    private resetInputValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaFilterListDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaFilterListDropdownComponent, "app-ca-filter-list-dropdown", never, { "type": { "alias": "type"; "required": false; }; "list": { "alias": "list"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "svgCustomSizeClass": { "alias": "svgCustomSizeClass"; "required": false; }; }, {}, never, never, true, never>;
}

interface CommandsEvent$1 {
    data?: string | number;
    action?: string;
    mode?: string;
}

interface LabelColor$1 {
    code?: string;
    color?: string;
    createdAt?: string;
    hoverCode?: string;
    name?: string;
    updatedAt?: string;
    colorId?: number;
    count?: number;
    id?: number;
}

declare class CaInputPlaceholderIconComponent$1 {
    inputConfig: ICaInput$1;
    getSuperControl: AbstractControl<any, any> | null;
    isFocusInput: boolean;
    isTouchedInput: boolean;
    selectedDropdownLabelColor: LabelColor$1 | null;
    isEditInput: boolean;
    dateTimePopover: TemplateRef<any>;
    onPopoverShownEmitter: EventEmitter<boolean>;
    onPopoverHiddenEmitter: EventEmitter<boolean>;
    onPlaceholderIconEventEmitter: EventEmitter<Event>;
    t2: NgbPopover;
    ngbMainPopover: NgbPopover;
    constructor();
    onPopoverShown(): void;
    onPopoverHidden(): void;
    onPlaceholderIconEvent(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaInputPlaceholderIconComponent$1, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaInputPlaceholderIconComponent$1, "app-ca-input-placeholder-icon", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "getSuperControl": { "alias": "getSuperControl"; "required": false; }; "isFocusInput": { "alias": "isFocusInput"; "required": false; }; "isTouchedInput": { "alias": "isTouchedInput"; "required": false; }; "selectedDropdownLabelColor": { "alias": "selectedDropdownLabelColor"; "required": false; }; "isEditInput": { "alias": "isEditInput"; "required": false; }; "dateTimePopover": { "alias": "dateTimePopover"; "required": false; }; }, { "onPopoverShownEmitter": "onPopoverShownEmitter"; "onPopoverHiddenEmitter": "onPopoverHiddenEmitter"; "onPlaceholderIconEventEmitter": "onPlaceholderIconEventEmitter"; }, never, never, true, never>;
}

declare class CaInputValidationService {
    constructor();
    /**
     * @param formGroup FormGroup - The form group to touch
     */
    markInvalid(formGroup: UntypedFormGroup): boolean | void;
    /**
     *
     * @param inputName - which return valid pattern, look inputConfig
     * @returns
     */
    getInputRegexPattern(inputName: string): RegExp | undefined | void;
    /**
     * @param formControl
     * @param hasValidation
     * @param validators
     */
    changeValidators(formControl: AbstractControl, hasValidation?: boolean, validators?: any[], reset?: boolean): void;
    /**
     *
     * @param formControl
     * @param hasValidation
     */
    changeValidatorsCheck(formControl: AbstractControl, hasValidation?: boolean): void;
    /**
     *
     * @param formControl
     * @param type
     * @param destroy$
     * @returns
     */
    customInputValidator(formControl: AbstractControl, type: string, destroy$: Subject<void>): rxjs.Subscription;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaInputValidationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CaInputValidationService>;
}

declare class InputSvgRoutes$1 {
    static removeInputSvg: string;
    static xClearSvg: string;
    static xClearCommonSvg: string;
    static confirmSvg: string;
    static dangerSvg: string;
    static eyeVisibleSvg: string;
    static eyeHiddenSvg: string;
    static decrementSvg: string;
    static incrementSvg: string;
    static inputPenSvg: string;
    static inputDropdownArrowSvg: string;
    static dynamicLabelSvg: string;
    static dynamicFocusLabelSvg: string;
    static ownerBadgeBlueSvg: string;
}

type InputChangeValue$1 = string | number | Date;

declare enum InputCommandsType$1 {
    PM_INCREMENT_DECREMENT = "pm-increment-decrement",
    INCREMENT_DECREMENT = "increment-decrement",
    CONFIRM_CANCEL = "confirm-cancel",
    MONTHS = "months"
}

declare enum InputStringEnum$1 {
    PHONE = "phone",
    CAPITALIZE = "capitalize",
    UPPERCASE = "uppercase",
    CAPITALIZED_CASE = "capitalizedcase",
    YEAR = "year",
    MONTHS = "months",
    AXLES = "axles",
    FULL_NAME = "full name",
    EMAIL = "email",
    INVOICE = "invoice",
    ADDRESS = "address",
    PERSONS = "persons",
    VEHICLES = "vehicles",
    PRICE_SEPARATOR = "price-separator",
    BUSINESS_NAME = "business name",
    SHOP_NAME = "shop name",
    FUEL_STOP = "fuel stop",
    PRODUCER_NAME = "producer name",
    TERMINAL_NAME = "terminal name",
    EIN = "ein",
    MC_FF = "mc/ff",
    PHONE_EXTENSION = "phone-extension",
    ACCOUNT_BANK = "account-bank",
    ROUTING_BANK = "routing-bank",
    SSN = "ssn",
    FUEL_CARD = "fuel-card",
    EMPTY_WEIGHT = "empty-weight",
    CREDIT_LIMIT = "credit limit",
    PO_BOX = "po box",
    PRICE = "price",
    TRAILER_VOLUME = "trailer-volume",
    REPAIR_ODOMETER = "repair-odometer",
    USDOT = "usdot",
    IRP = "irp",
    STARTING = "starting",
    CUSTOMER_PAY_TERM = "customer pay term",
    CUSTOMER_CREDIT = "customer credit",
    DEFAULT_BASE = "default base",
    EACH_OCCURRENCE = "each occurrence",
    DAMAGE = "damage",
    PERSONAL_ADVER_INJ = "personal-adver-inj",
    MEDICAL_EXPENSES = "medical expenses",
    BODILY_INJURY = "bodily injury",
    GENERAL_AGGREGATE = "general aggregate",
    PRODUCTS_COMP_OP_AGG = "products-comp-op-agg",
    COMBINED_SINGLE_LIMIT = "combined-single-limit",
    SINGLE_CONVEYANCE = "single-conveyance",
    DEDUCTABLE = "deductable",
    COMPREH_COLLISION = "compreh-collision",
    TRAILER_VALUE_INSURANCE_POLICY = "trailer-value-insurance-policy",
    RENT = "rent",
    SALARY = "salary",
    MILEAGE = "mileage",
    EMPTY_WEIGHT_SPACE = "empty weight",
    QTY = "qty",
    PURCHASE_PRICE = "purchase price",
    FUEL_TANK_SIZE = "fuel tank size",
    DEVICE_NO = "device no",
    WEIGHT = "weight",
    FUEL_PER_MILES = "fuel per miles",
    FUEL_PRICE_MAP = "fuel price map",
    AMOUNT = "amount",
    BOL_NO = "bol no.",
    SEAL_NO = "seal no.",
    PICKUP_NO = "pickup no.",
    CODE = "code",
    MULTI_FROM_FIRST_FROM = "multifromfirstfrom",
    MULTI_FROM_FIRST_TO = "multifromfirstto",
    MULTI_FORM_SECOND_FROM = "multiformsecondfrom",
    MULTI_FORM_SECOND_TO = "multiformsecondto",
    MULTI_FORM_THIRD_FROM = "multiformthirdfrom",
    MULTI_FORM_THIRD_TO = "multiformthirdto",
    ADDRESS_UNIT = "address-unit",
    DEPARTMENT = "department",
    VEHICLE_UNIT = "vehicle-unit",
    FIRST_NAME = "first name",
    LAST_NAME = "last name",
    BANK_NAME = "bank name",
    VIN_NUMBER = "vin-number",
    INSURANCE_POLICY = "insurance-policy",
    IFTA = "ifta",
    TRUCK_TRAILER_MODEL = "truck-trailer-model",
    LICENSE_PLATE = "license plate",
    DESCRIPTION = "description",
    ALLOW_ALL = "allow all",
    DBA_NAME = "dba name",
    PER_MILE = "per mile",
    PER_STOP = "per stop",
    FLAT_RATE = "flat rate",
    PER_LOAD = "per load",
    RELATIONSHIP = "relationship",
    SCAC = "scac",
    EMERGENCY_NAME = "emergency name",
    FULL_CONTACT_NAME = "full contact name",
    FUEL_STORE = "fuel-store",
    HOS = "hos",
    FULL_PARKING_SLOT = "full parking slot",
    PARKING_SLOT = "parking slot",
    CDL_NUMBER = "cdl-number",
    USERNAME = "username",
    NICKNAME = "nickname",
    PASSWORD = "password",
    TOLL_VALIDATION = "tollvalidation",
    PREFIX = "prefix",
    SUFFIX = "suffix",
    PARKING_NAME = "parking name",
    FILE_NAME = "file name",
    INSURER_NAME = "insurer name",
    OFFICE_NAME = "office name",
    INPUT_DROPDOWN_LABEL = "input dropdown label"
}

declare enum DropdownTemplateTypeEnum$1 {
    SVG_TEMPLATE = "svg-template",
    SVGTEXT_TEMPLATE = "svgtext-template",
    SVGTEXT_DISPATCH_TEMPLATE = "svgtext-dispatch-template",
    DETAILS_TEMPLATE = "details-template",
    GROUPS = "groups",
    MULTISELECT = "multiselect",
    LABELS = "labels",
    DISPATCH = "dispatch",
    LOAD_DISPATCHER = "load-dispatcher",
    LOAD_DISPATCHES_TTD = "load-dispatches-ttd",
    LOAD_BROKER = "load-broker",
    LOAD_BROKER_CONTACT = "load-broker-contact",
    LOAD_SHIPPER = "load-shipper",
    TEXT_COUNTER = "text-counter",
    FUEL_FRANCHISE = "fuel-franchise",
    DOUBLE_TEXT_TEMPLATE = "double-text-template",
    DOUBLE_COLUMN_TEMPLATE = "double-column-template",
    TRIPLE_COLUMN_TEMPLATE = "triple-column-template",
    PAYROLL_TRUCKS = "payroll-trucks",
    PARKING = "parking"
}

declare abstract class CaInputBaseHelpersComponent {
    abstract input: ElementRef;
    abstract lastCursorSpacePosition: number;
    abstract superControl: NgControl;
    abstract _inputConfig: ICaInput$1;
    abstract cdRef: ChangeDetectorRef;
    numberOfConsecutivelyPoints: number;
    numberOfPoints: number;
    oneSpaceOnlyCounter: number;
    inputCommandsTimeout: ReturnType<typeof setTimeout> | number;
    disableConsecutivelySpaces(event: any): void;
    disableConsecutivelyPoints(event: KeyboardEvent): void | boolean;
    disableMultiplePoints(event: KeyboardEvent): void | boolean;
    enableOneSpaceOnly(event: any): boolean;
    handlePmIncrementDecrement(action: string): void;
    private decrementPmValue;
    private resetPmValue;
    private incrementPmValue;
    setInputCursorAtTheEnd(input: any, time?: number): void;
    handleIncrementDecrement(action: string): void;
    handleMonths(action: string): void;
    private decrementMonth;
    private incrementMonth;
    blurOnCommands(): void;
    checkNameArray(array: string[], name: string): boolean;
}

declare class EventInputManager$1<T> {
    private eventEmitter;
    private stateSubject;
    state$: Observable<T | null>;
    constructor(initialValue: T | null, eventEmitter: EventEmitter<T>);
    /**
     * Update the value and emit the event.
     */
    next(newValue: T): void;
    /**
     * Get the current value.
     */
    get value(): T | null;
}

declare abstract class CaInputBaseComponent extends CaInputBaseHelpersComponent {
    cdRef: ChangeDetectorRef;
    thousandSeparatorPipe: ThousandSeparatorPipe;
    abstract focusInputEvent: EventEmitter<FocusEvent>;
    abstract handleToggleDropdownOptions: EventEmitter<void>;
    abstract isFocusInput: boolean;
    abstract isTouchedInput: boolean;
    abstract isVisibleCommands: boolean;
    abstract isEditInput: boolean;
    abstract isDropdownToggler: boolean;
    abstract isCapsLockOn: boolean;
    abstract setCommandEvent: EventInputManager$1<CommandsEvent$1>;
    abstract setClearInputEvent: EventInputManager$1<boolean>;
    abstract setIncorrectInput: EventInputManager$1<boolean>;
    abstract setBlurInput: EventInputManager$1<boolean>;
    abstract setChangeInput: EventInputManager$1<InputChangeValue$1>;
    abstract setShowHideDropdown: EventInputManager$1<boolean>;
    abstract setDropDownKeyNavigation: EventInputManager$1<{
        keyCode: number;
        data: ICaInput$1 | null;
    }>;
    inputSelection: boolean;
    cursorInputPosition: number;
    hasDecimalIndex: number;
    originPriceSeparatorLimit: number | undefined;
    timeoutCleaner: ReturnType<typeof setTimeout> | number;
    lastCursorSpacePosition: number;
    private preventBlur;
    passwordTimeout: ReturnType<typeof setTimeout> | number;
    isDotDeleted: boolean;
    abstract incorrectValue: boolean;
    showDateInput: boolean;
    dateTimeInputDate: Date;
    numberOfConsecutivelySpaces: number;
    abstract caInputValidationService: CaInputValidationService;
    constructor(cdRef: ChangeDetectorRef, thousandSeparatorPipe: ThousandSeparatorPipe);
    transformText(value: string, isPaste?: boolean): void;
    private handlePaste;
    private limitInputLength;
    private applyTextTransformation;
    private applyThousandSeparator;
    private applyPriceSeparator;
    private setInputCursorPosition;
    private formatWithDecimal;
    private customValidation;
    private formatWithoutDecimal;
    private sanitizeConsecutiveSpaces;
    private setCursorForSanitizedInput;
    private removeLeadingZero;
    writeValueBase(obj: InputChangeValue$1): void;
    private capitalizeWords;
    private isAllZeros;
    onBlurBase(event?: FocusEvent): void;
    private blurOnDropDownArrow;
    blurOnPassword(): void;
    checkRegexPattern(charCode: string, name: string): boolean | undefined;
    onKeypress(event: KeyboardEvent): boolean | void;
    onFocus(event?: FocusEvent): void;
    onKeydown(event: KeyboardEvent): void;
    onKeyup(event: KeyboardEvent): void;
    private handleConfirmCancel;
    private cancelCommand;
    private confirmCommand;
    clearInput(event: Event): void;
    onCommands(e: any): void;
    onEditInput(event: Event): void;
    toggleDropdownOptions(): void;
    onPlaceholderIconEvent(event: Event): void;
    selectionChange(event: Event): void;
    autoFocusFirstInput(): void;
    onPopoverShown(): void;
    onPopoverHidden(): void;
    onInputConfigChange(): void;
}

declare class CaInputComponent extends CaInputBaseComponent implements OnInit, OnDestroy, AfterViewInit, ControlValueAccessor {
    superControl: NgControl;
    cdRefd: ChangeDetectorRef;
    thsep: ThousandSeparatorPipe;
    caInputValidationService: CaInputValidationService;
    input: ElementRef;
    ngbMainPopover: NgbPopover;
    caInputPlaceholderIconComponent: CaInputPlaceholderIconComponent$1;
    _inputConfig: ICaInput$1;
    set inputConfig(config: ICaInput$1);
    dateTimePopover: TemplateRef<any>;
    incorrectValue: boolean;
    selectedDropdownLabelColor: LabelColor$1 | null;
    template: string;
    handleToggleDropdownOptions: EventEmitter<void>;
    incorrectInput: EventEmitter<boolean>;
    blurInput: EventEmitter<boolean>;
    focusInputEvent: EventEmitter<FocusEvent>;
    changeInput: EventEmitter<InputChangeValue$1>;
    commandEvent: EventEmitter<CommandsEvent$1>;
    clearInputEvent: EventEmitter<boolean>;
    showHideDropdownEvent: EventEmitter<boolean>;
    dropDownKeyNavigationEvent: EventEmitter<{
        keyCode: number;
        data: ICaInput$1 | null;
    }>;
    isFocusInput: boolean;
    isTouchedInput: boolean;
    isVisibleCommands: boolean;
    isDropdownToggler: boolean;
    isCapsLockOn: boolean;
    isEditInput: boolean;
    setCommandEvent: EventInputManager$1<CommandsEvent$1>;
    setClearInputEvent: EventInputManager$1<boolean>;
    setIncorrectInput: EventInputManager$1<boolean>;
    setBlurInput: EventInputManager$1<boolean>;
    setChangeInput: EventInputManager$1<InputChangeValue$1>;
    setShowHideDropdown: EventInputManager$1<boolean>;
    setDropDownKeyNavigation: EventInputManager$1<{
        keyCode: number;
        data: ICaInput$1 | null;
    }>;
    isTogglePassword: boolean;
    newInputChanged: boolean;
    private destroy$;
    inputSvgRoutes: typeof InputSvgRoutes$1;
    priceSeperatorWithFilledValue: boolean;
    inputCommandsType: typeof InputCommandsType$1;
    inputStringEnum: typeof InputStringEnum$1;
    dropdownTemplateTypeEnum: typeof DropdownTemplateTypeEnum$1;
    constructor(superControl: NgControl, cdRefd: ChangeDetectorRef, thsep: ThousandSeparatorPipe, caInputValidationService: CaInputValidationService);
    get getSuperControl(): _angular_forms.AbstractControl<any, any, any> | null;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    initStateService(): void;
    outputListeners(): void;
    initChangesListener(): void;
    writeValue(obj: InputChangeValue$1): void;
    registerOnChange(fn: any): void;
    onChange(_: any): void;
    registerOnTouched(): void;
    onBlur(event?: FocusEvent): void;
    onTogglePassword(event: Event): void;
    trackIdentity: (index: number) => number;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaInputComponent, [{ self: true; }, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaInputComponent, "app-ca-input", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "dateTimePopover": { "alias": "dateTimePopover"; "required": false; }; "incorrectValue": { "alias": "incorrectValue"; "required": false; }; "selectedDropdownLabelColor": { "alias": "selectedDropdownLabelColor"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, { "handleToggleDropdownOptions": "handleToggleDropdownOptions"; "incorrectInput": "incorrectEvent"; "blurInput": "blurInput"; "focusInputEvent": "focusInput"; "changeInput": "change"; "commandEvent": "commandEvent"; "clearInputEvent": "clear"; "showHideDropdownEvent": "showHideDropdown"; "dropDownKeyNavigationEvent": "dropDownKeyNavigation"; }, never, never, true, never>;
}

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: i0.ɵɵFactoryDeclaration<CalendarDateTimePickerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarDateTimePickerService>;
}

declare enum InputCommandsAction {
    DECREMENT = "decrement",
    INCREMENT = "increment",
    RESET = "reset",
    CONFIRM = "confirm",
    CANCEL = "cancel",
    MINUS = "minus",
    PLUS = "plus"
}

declare enum InputCommandsType {
    PM_INCREMENT_DECREMENT = "pm-increment-decrement",
    INCREMENT_DECREMENT = "increment-decrement",
    CONFIRM_CANCEL = "confirm-cancel",
    MONTHS = "months"
}

declare enum InputStringEnum {
    PHONE = "phone",
    CAPITALIZE = "capitalize",
    UPPERCASE = "uppercase",
    CAPITALIZED_CASE = "capitalizedcase",
    YEAR = "year",
    MONTHS = "months",
    AXLES = "axles",
    FULL_NAME = "full name",
    EMAIL = "email",
    INVOICE = "invoice",
    ADDRESS = "address",
    PERSONS = "persons",
    VEHICLES = "vehicles",
    PRICE_SEPARATOR = "price-separator",
    BUSINESS_NAME = "business name",
    SHOP_NAME = "shop name",
    FUEL_STOP = "fuel stop",
    PRODUCER_NAME = "producer name",
    TERMINAL_NAME = "terminal name",
    EIN = "ein",
    MC_FF = "mc/ff",
    PHONE_EXTENSION = "phone-extension",
    ACCOUNT_BANK = "account-bank",
    ROUTING_BANK = "routing-bank",
    SSN = "ssn",
    FUEL_CARD = "fuel-card",
    EMPTY_WEIGHT = "empty-weight",
    CREDIT_LIMIT = "credit limit",
    PO_BOX = "po box",
    PRICE = "price",
    TRAILER_VOLUME = "trailer-volume",
    REPAIR_ODOMETER = "repair-odometer",
    USDOT = "usdot",
    IRP = "irp",
    STARTING = "starting",
    CUSTOMER_PAY_TERM = "customer pay term",
    CUSTOMER_CREDIT = "customer credit",
    DEFAULT_BASE = "default base",
    EACH_OCCURRENCE = "each occurrence",
    DAMAGE = "damage",
    PERSONAL_ADVER_INJ = "personal-adver-inj",
    MEDICAL_EXPENSES = "medical expenses",
    BODILY_INJURY = "bodily injury",
    GENERAL_AGGREGATE = "general aggregate",
    PRODUCTS_COMP_OP_AGG = "products-comp-op-agg",
    COMBINED_SINGLE_LIMIT = "combined-single-limit",
    SINGLE_CONVEYANCE = "single-conveyance",
    DEDUCTABLE = "deductable",
    COMPREH_COLLISION = "compreh-collision",
    TRAILER_VALUE_INSURANCE_POLICY = "trailer-value-insurance-policy",
    RENT = "rent",
    SALARY = "salary",
    MILEAGE = "mileage",
    EMPTY_WEIGHT_SPACE = "empty weight",
    QTY = "qty",
    PURCHASE_PRICE = "purchase price",
    FUEL_TANK_SIZE = "fuel tank size",
    DEVICE_NO = "device no",
    WEIGHT = "weight",
    FUEL_PER_MILES = "fuel per miles",
    FUEL_PRICE_MAP = "fuel price map",
    AMOUNT = "amount",
    BOL_NO = "bol no.",
    SEAL_NO = "seal no.",
    PICKUP_NO = "pickup no.",
    CODE = "code",
    MULTI_FROM_FIRST_FROM = "multifromfirstfrom",
    MULTI_FROM_FIRST_TO = "multifromfirstto",
    MULTI_FORM_SECOND_FROM = "multiformsecondfrom",
    MULTI_FORM_SECOND_TO = "multiformsecondto",
    MULTI_FORM_THIRD_FROM = "multiformthirdfrom",
    MULTI_FORM_THIRD_TO = "multiformthirdto",
    ADDRESS_UNIT = "address-unit",
    DEPARTMENT = "department",
    VEHICLE_UNIT = "vehicle-unit",
    FIRST_NAME = "first name",
    LAST_NAME = "last name",
    BANK_NAME = "bank name",
    VIN_NUMBER = "vin-number",
    INSURANCE_POLICY = "insurance-policy",
    IFTA = "ifta",
    TRUCK_TRAILER_MODEL = "truck-trailer-model",
    LICENSE_PLATE = "license plate",
    DESCRIPTION = "description",
    ALLOW_ALL = "allow all",
    DBA_NAME = "dba name",
    PER_MILE = "per mile",
    PER_STOP = "per stop",
    FLAT_RATE = "flat rate",
    PER_LOAD = "per load",
    RELATIONSHIP = "relationship",
    SCAC = "scac",
    EMERGENCY_NAME = "emergency name",
    FULL_CONTACT_NAME = "full contact name",
    FUEL_STORE = "fuel-store",
    HOS = "hos",
    FULL_PARKING_SLOT = "full parking slot",
    PARKING_SLOT = "parking slot",
    CDL_NUMBER = "cdl-number",
    USERNAME = "username",
    NICKNAME = "nickname",
    PASSWORD = "password",
    TOLL_VALIDATION = "tollvalidation",
    PREFIX = "prefix",
    SUFFIX = "suffix",
    PARKING_NAME = "parking name",
    FILE_NAME = "file name",
    INSURER_NAME = "insurer name",
    OFFICE_NAME = "office name",
    INPUT_DROPDOWN_LABEL = "input dropdown label"
}

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;
    folder?: string;
    subFolder?: string;
    url?: string;
    nameInitialsInsteadUrl?: string;
    template?: string;
    color?: string;
    class?: string;
    remove?: boolean;
}
interface ICaInput {
    id?: number | string;
    name: string;
    type: string;
    label?: string;
    labelInInput?: boolean;
    placeholder?: string;
    placeholderIcon?: string;
    placeholderIconRightSide?: string;
    isPlaceHolderIconRightSideDynamicColor?: boolean;
    placeholderIconFolllowTextOnRightSide?: string;
    placeholderIconColor?: string;
    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;
    isAddress?: boolean;
    searchinGroupIndex?: string;
    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;
    priceParseFormat?: boolean;
}

declare class InputSvgRoutes {
    static removeInputSvg: string;
    static xClearSvg: string;
    static xClearCommonSvg: string;
    static confirmSvg: string;
    static dangerSvg: string;
    static eyeVisibleSvg: string;
    static eyeHiddenSvg: string;
    static decrementSvg: string;
    static incrementSvg: string;
    static inputPenSvg: string;
    static inputDropdownArrowSvg: string;
    static dynamicLabelSvg: string;
    static dynamicFocusLabelSvg: string;
    static ownerBadgeBlueSvg: string;
}

type InputChangeValue = string | number | Date;

interface CommandsEvent {
    data?: string | number;
    action?: string;
    mode?: string;
}

interface LabelColor {
    code?: string;
    color?: string;
    createdAt?: string;
    hoverCode?: string;
    name?: string;
    updatedAt?: string;
    colorId?: number;
    count?: number;
    id?: number;
}

interface AddressModel {
    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 EnumValue$1 {
    name?: string | null;
    id?: number;
}

interface FileResponse$1 {
    fileId?: number;
    fileName?: string | null;
    url?: string | null;
    fileSize?: number | null;
    tags?: Array<string> | null;
    tagGeneratedByUser?: boolean;
    updatedAt?: string | null;
}

interface DriverMinimalResponse {
    id?: number;
    firstName?: string | null;
    lastName?: string | null;
    owner?: number | null;
    status?: number;
    avatarFile?: FileResponse$1;
    address?: AddressModel;
    totalMiles?: number | null;
    totalEarnings?: number | null;
    hiredAt?: string | null;
    payType?: EnumValue$1;
    logoName?: string;
    name?: string;
}

interface PayrollBonusResponse {
    id?: number;
    payrollDriverMileageId?: number | null;
    driver?: DriverMinimalResponse;
    date?: string;
    description?: string | null;
    subtotal?: number;
    createdAt?: string;
    updatedAt?: string;
}

interface ColorResponse {
    id?: number;
    companyId?: number | null;
    name?: string | null;
    code?: string | null;
}

interface TruckTypeResponse {
    id?: number;
    companyId?: number | null;
    name?: string | null;
    logoName?: string | null;
}

interface TruckMinimalResponse {
    id?: number;
    truckNumber?: string | null;
    status?: number;
    owner?: string | null;
    color?: ColorResponse | null;
    truckType?: TruckTypeResponse;
    truckMakeName?: string | null;
    model?: string | null;
    year?: number;
}

interface PayrollCreditResponse {
    id?: number;
    type?: EnumValue$1;
    payrollDriverMileageId?: number | null;
    payrollDriverCommissionId?: number | null;
    driver?: DriverMinimalResponse;
    payrollOwnerId?: number | null;
    truck?: TruckMinimalResponse;
    date?: string;
    description?: string | null;
    subtotal?: number;
    createdAt?: string;
    updatedAt?: string;
}

interface PayrollDeductionResponse {
    id?: number;
    type?: EnumValue$1;
    payrollDriverMileageId?: number | null;
    payrollDriverCommissionId?: number | null;
    driver?: DriverMinimalResponse;
    payrollOwnerId?: number | null;
    truck?: TruckMinimalResponse;
    date?: string;
    description?: string | null;
    subtotal?: number;
    recurringType?: EnumValue$1;
    currentRecurrance?: number | null;
    limitedNumber?: number | null;
    limitedAmount?: number | null;
    createdAt?: string;
    updatedAt?: string;
}

interface PayrollLoadStopMinimalResponse {
    id?: number;
    loadStopName?: string | null;
    address?: string | null;
    date?: string | null;
}

interface PayrollLoadMinimalResponse {
    id?: number;
    loadNumber?: string | null;
    brokerName?: string | null;
    isTonu?: boolean;
    pickups?: Array<PayrollLoadStopMinimalResponse> | null;
    pickupCount?: number;
    deliveries?: Array<PayrollLoadStopMinimalResponse> | null;
    deliveryCount?: number;
    emptyMiles?: number | null;
    loadedMiles?: number | null;
    totalMiles?: number | null;
    revenue?: number;
    subtotal?: number | null;
    rate?: number | null;
}

interface BrokerShortResponse {
    id?: number;
    businessName?: string | null;
    contactName?: string | null;
    phone?: string | null;
    email?: string | null;
    availableCredit?: number | null;
    availableCreditType?: EnumValue$1 | null;
    payTerm?: EnumValue$1 | null;
    dnu?: boolean;
    ban?: boolean;
}

interface ShipperShortResponse {
    id?: number;
    businessName?: string | null;
    address?: AddressModel;
    longitude?: number | null;
    latitude?: number | null;
}

interface LoadStopShortResponse {
    loadNumber?: string | null;
    stopType?: EnumValue$1;
    stopOrder?: number;
    shipper?: ShipperShortResponse;
    dateFrom?: string | null;
}

interface LoadShortResponse {
    id: number;
    type?: EnumValue$1;
    loadNumber?: string | null;
    referenceNumber?: string | null;
    statusType?: EnumValue$1;
    broker?: BrokerShortResponse;
    pickup?: LoadStopShortResponse;
    delivery?: LoadStopShortResponse;
    childLoads?: Array<LoadShortResponse>;
    pickupCount?: number;
    deliveryCount?: number;
    totalMiles?: number | null;
    totalRate?: number | null;
    totalAdjustedRate?: number | null;
    driverMessage?: string | null;
    fraudCheck?: boolean;
}

interface PayrollPaymentResponse {
    id?: number;
    type?: EnumValue$1;
    date?: string;
    amount?: number;
    createdAt?: string;
    updatedAt?: string;
}

interface PayrollFuelMinimalResponse {
    id?: number;
    description?: string | null;
    galons?: number;
    pricePerGalon?: number;
    subtotal?: number;
    date?: string;
}

interface DriverInfo {
    fullName: string;
    driverAvatar?: string;
    payrollNumber: string;
}

interface ExtraPayments {
    bonuses: {
        included: Array<PayrollBonusResponse>;
        excluded: Array<PayrollBonusResponse>;
    };
    credits: {
        included: Array<PayrollCreditResponse>;
        excluded: Array<PayrollCreditResponse>;
    };
    deductions: {
        included: Array<PayrollDeductionResponse>;
        excluded: Array<PayrollDeductionResponse>;
    };
    payments: {
        included: Array<PayrollPaymentResponse>;
        excluded: Array<PayrollPaymentResponse>;
    };
    fuels: {
        included: Array<PayrollFuelMinimalResponse>;
        excluded: Array<PayrollFuelMinimalResponse>;
    };
}

interface OptionModel {
    id?: number;
    number?: number;
    name?: string;
    fullName?: string;
    type?: string;
    companyName?: string;
    colorId?: number;
    color?: string;
    colorD?: string;
    code?: string;
    class?: string;
    count?: number;
    description?: string;
    businessName?: string;
    address?: any;
    longLat?: number;
    logoName?: string;
    dropLabel?: string;
    trailer?: ArrayStatus;
    truck?: ArrayStatus;
    driver?: DriverMinimalResponse;
    isFranchise?: boolean;
    dnu?: boolean;
    ban?: boolean;
    status?: any;
    active?: boolean;
    disabled?: boolean;
    duplicateId?: boolean;
    canOpenModal?: boolean;
    open?: boolean;
    groups?: {
        id?: number;
        name?: string;
    }[];
    contacts?: {
        fullName?: string;
        id?: number;
        name?: string;
        originalPhone?: string;
        phone?: string;
        phoneExt?: string;
        phoneExtension?: string;
        shipperId?: number;
    }[];
    stores?: {
        id?: number | string;
        name?: string;
        address?: string;
    }[];
    folder?: string;
    subFolder?: string;
    isDriver?: boolean;
    additionalText?: string;
    svg?: string;
    referenceNumber?: number | string;
    totalBill?: number | string;
    totalMiles?: number | string;
    totalEarnings?: number | string;
    brokerName?: string;
    hiredAt?: number | string;
    groupName?: string;
    items?: {
        id?: number;
        name?: string;
    }[];
    hoverCode?: string;
    payType?: string;
    itemIndex?: number | string;
    availableCreditType?: {
        id?: number | string;
        name?: string;
    };
    department?: {
        id?: number | string;
        name?: string;
    };
    loadsCount?: number | string;
    hover?: boolean;
    ein?: string | number;
    brand?: string;
    account?: string;
    stopType?: string;
    valueForRequest?: string;
    availableCredit?: string | number;
    creditLimit?: string | number;
    suffix?: string | number;
    truckType?: {
        name?: string;
    };
    activeCounter?: string | number;
    totalCounter?: string | number;
    parkingAddress?: any;
}

interface SelectedStatus {
    valueForRequest?: string;
    name?: string | null;
    id?: number;
}

declare class CaSvgPipe implements PipeTransform {
    transform(svgPath?: string, folder?: string, subFolder?: string, option?: OptionModel): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaSvgPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CaSvgPipe, "caSvg", true>;
}

declare class DateFromStringPipe implements PipeTransform {
    transform(date: string | Date | null | undefined, template?: eDateTimeFormats | string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateFromStringPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateFromStringPipe, "dateFromStringPipe", true>;
}

declare class DateFormatPipe implements PipeTransform {
    transform(value: Date | null): string | null | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateFormatPipe, "dateFormat", true>;
}

declare class DispatchStatusColorPipe implements PipeTransform {
    transform(status: string, isDarkColor: boolean): {
        color: string;
        backgroundColor?: string;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<DispatchStatusColorPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DispatchStatusColorPipe, "dispatchStatusColor", true>;
}

declare class DropdownLoadStatusColorPipe implements PipeTransform {
    transform(status: string, isBadge?: boolean): {
        color: string;
        backgroundColor?: string;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownLoadStatusColorPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DropdownLoadStatusColorPipe, "dropdownLoadStatusColor", true>;
}

declare class FormatCityStatePipe implements PipeTransform {
    transform(city: string, state: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormatCityStatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FormatCityStatePipe, "formatCityStatePipe", true>;
}

declare class FormatCurrencyPipe implements PipeTransform {
    transform(currency: number, useAbbreviation?: boolean): string;
    private nFormatter;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormatCurrencyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FormatCurrencyPipe, "formatCurrency", true>;
}

interface HighlightText {
    index: number;
    text: string;
}

declare class HighlightSearchPipe implements PipeTransform {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(text: any, chips: HighlightText[]): SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightSearchPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<HighlightSearchPipe, "caHighlight", true>;
}

declare class LoadStatusColorPipe implements PipeTransform {
    transform(status: string, isBadge?: boolean): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadStatusColorPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LoadStatusColorPipe, "loadStatusColor", true>;
}

declare class NFormatterPipe implements PipeTransform {
    transform(value: number | string): string;
    nFormatter(num: number | string, digits: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NFormatterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NFormatterPipe, "nFormatter", true>;
}

declare class NameInitialsPipe implements PipeTransform {
    constructor();
    transform(fullName: string | number | undefined): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NameInitialsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NameInitialsPipe, "nameInitials", true>;
}

declare class SafeHtmlPipe implements PipeTransform {
    private sanitized;
    constructor(sanitized: DomSanitizer);
    transform(value: string): SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
}

declare class ThousandToShortFormatPipe implements PipeTransform {
    transform(value: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThousandToShortFormatPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThousandToShortFormatPipe, "thousandToShortFormatPipe", true>;
}

declare class ToLowerCasePipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToLowerCasePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ToLowerCasePipe, "toLowerCase", true>;
}

declare class TruncatePipe implements PipeTransform {
    transform(value: string, limit: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TruncatePipe, "truncate", true>;
}

declare class UnitPositionPipe implements PipeTransform {
    transform(value: string, indicator: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnitPositionPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<UnitPositionPipe, "unitPosition", true>;
}

declare class UserNameInitialsPipe implements PipeTransform {
    transform(userName: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserNameInitialsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<UserNameInitialsPipe, "userNameInitials", true>;
}

declare class TruckTrailerColorFinderPipe implements PipeTransform {
    transform(id?: number, type?: string, isTooltip?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TruckTrailerColorFinderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TruckTrailerColorFinderPipe, "truckTrailerColorFinder", true>;
}

declare class LoadStatusColorsPipe implements PipeTransform {
    transform(statusId?: number, iconColor?: boolean): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadStatusColorsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LoadStatusColorsPipe, "loadStatusColors", true>;
}

declare class ThousandFormatterPipe implements PipeTransform {
    transform(value: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThousandFormatterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThousandFormatterPipe, "addThousandSign", true>;
}

declare class LoadStatusBackgroundColorPipe implements PipeTransform {
    transform(statusId?: number, iconColor?: boolean): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadStatusBackgroundColorPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LoadStatusBackgroundColorPipe, "loadStatusBackgroundColor", true>;
}

declare class FormatDurationPipe implements PipeTransform {
    transform(time: {
        days: number;
        hours: number;
        minutes: number;
        seconds: number;
    }): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormatDurationPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FormatDurationPipe, "formatDuration", true>;
}

declare class DateWaitTimePipe implements PipeTransform {
    private datePipe;
    constructor(datePipe: DatePipe);
    transform(dateFrom: string, dateTo: string | null, timeFrom: string, timeTo: string | null): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateWaitTimePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateWaitTimePipe, "dateWaitTime", true>;
}

declare class ProgressBarLinePipe implements PipeTransform {
    transform(type: 'back' | 'front', percentageValue: number): Record<string, boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarLinePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ProgressBarLinePipe, "progressBarLine", true>;
}

interface ISearchQueryItem {
    text: string;
    colorClass: string;
}

declare class TableHighlightSearchTextPipe implements PipeTransform {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(text: string | number | null | undefined, chips: ISearchQueryItem[]): SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableHighlightSearchTextPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TableHighlightSearchTextPipe, "tableHighlightSearchText", true>;
}

declare class CaInputPlaceholderIconComponent {
    inputConfig: ICaInput;
    getSuperControl: AbstractControl<any, any> | null;
    isFocusInput: boolean;
    isTouchedInput: boolean;
    selectedDropdownLabelColor: LabelColor | null;
    isEditInput: boolean;
    dateTimePopover: TemplateRef<any>;
    onPopoverShownEmitter: EventEmitter<boolean>;
    onPopoverHiddenEmitter: EventEmitter<boolean>;
    onPlaceholderIconEventEmitter: EventEmitter<Event>;
    t2: NgbPopover;
    ngbMainPopover: NgbPopover;
    constructor();
    onPopoverShown(): void;
    onPopoverHidden(): void;
    onPlaceholderIconEvent(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaInputPlaceholderIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaInputPlaceholderIconComponent, "app-ca-input-placeholder-icon", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "getSuperControl": { "alias": "getSuperControl"; "required": false; }; "isFocusInput": { "alias": "isFocusInput"; "required": false; }; "isTouchedInput": { "alias": "isTouchedInput"; "required": false; }; "selectedDropdownLabelColor": { "alias": "selectedDropdownLabelColor"; "required": false; }; "isEditInput": { "alias": "isEditInput"; "required": false; }; "dateTimePopover": { "alias": "dateTimePopover"; "required": false; }; }, { "onPopoverShownEmitter": "onPopoverShownEmitter"; "onPopoverHiddenEmitter": "onPopoverHiddenEmitter"; "onPlaceholderIconEventEmitter": "onPlaceholderIconEventEmitter"; }, never, never, true, never>;
}

declare class EventInputManager<T> {
    private eventEmitter;
    private stateSubject;
    state$: Observable<T | null>;
    constructor(initialValue: T | null, eventEmitter: EventEmitter<T>);
    /**
     * Update the value and emit the event.
     */
    next(newValue: T): void;
    /**
     * Get the current value.
     */
    get value(): T | null;
}

declare class InputBase {
    inputElement: ElementRef;
    _inputConfig: ICaInput;
    isVisibleCommands: boolean;
    maskApplier: NgxMaskService;
    thousandSeparatorPipe: ThousandSeparatorPipe;
    isFocusInput: boolean;
    isEditInput: boolean;
    isDropdownToggler: boolean;
    isTouchedInput: boolean;
    setCommandEvent: EventInputManager<CommandsEvent>;
    handleToggleDropdownOptions: EventEmitter<void>;
    onTouched: () => void;
    onChange(_: any): void;
    handleChangeInputAndUpdateControl(_: InputChangeValue): void;
}
declare const InputTestComponent_base: {
    new (...args: any[]): {
        onCommands(e: any): void;
        handleMonths(action: string): void;
        handleConfirmCancel(action: string): void;
        cancelCommand(): void;
        confirmCommand(): void;
        handlePmIncrementDecrement(action: string): void;
        decrementIncrementDecrementPmValue(value: number, action: InputCommandsAction): number;
        resetPmValue(): void;
        inputElement: ElementRef;
        _inputConfig: ICaInput;
        onTouched: () => void;
        onChange(_: any): void;
        handleChangeInputAndUpdateControl(_: InputChangeValue): void;
        isVisibleCommands: boolean;
        maskApplier: NgxMaskService;
        thousandSeparatorPipe: ThousandSeparatorPipe;
        handleToggleDropdownOptions: EventEmitter<void>;
        isFocusInput: boolean;
        isEditInput: boolean;
        isDropdownToggler: boolean;
        isTouchedInput: boolean;
        setCommandEvent: EventInputManager<CommandsEvent>;
    };
} & {
    new (...args: any[]): {
        transformValue(inputConfig: ICaInput, value: InputChangeValue): any;
        toggleDropdownOptions(): void;
        onPlaceholderIconEvent(event: Event): void;
        inputElement: ElementRef;
        _inputConfig: ICaInput;
        onTouched: () => void;
        onChange(_: any): void;
        handleChangeInputAndUpdateControl(_: InputChangeValue): void;
        isVisibleCommands: boolean;
        maskApplier: NgxMaskService;
        thousandSeparatorPipe: ThousandSeparatorPipe;
        handleToggleDropdownOptions: EventEmitter<void>;
        isFocusInput: boolean;
        isEditInput: boolean;
        isDropdownToggler: boolean;
        isTouchedInput: boolean;
        setCommandEvent: EventInputManager<CommandsEvent>;
    };
} & typeof InputBase;
declare class InputTestComponent extends InputTestComponent_base implements ControlValueAccessor, AfterViewInit, OnDestroy {
    ngControl: NgControl;
    chdet: ChangeDetectorRef;
    maskApplier: NgxMaskService;
    thousandSeparatorPipe: ThousandSeparatorPipe;
    inputValue: InputChangeValue;
    _inputConfig: ICaInput;
    private destroy$;
    inputSvgRoutes: typeof InputSvgRoutes;
    dateTimePopover: TemplateRef<any>;
    inputElement: ElementRef;
    caInputPlaceholderIconComponent: CaInputPlaceholderIconComponent;
    parentControl: AbstractControl<any, any> | null;
    selectedDropdownLabelColor: LabelColor | null;
    template: string;
    incorrectValue: boolean;
    set inputConfig(config: ICaInput);
    activeItem: OptionModel | null;
    handleToggleDropdownOptions: EventEmitter<void>;
    incorrectInput: EventEmitter<boolean>;
    blurInput: EventEmitter<boolean>;
    focusInputEvent: EventEmitter<FocusEvent>;
    changeInput: EventEmitter<InputChangeValue>;
    commandEvent: EventEmitter<CommandsEvent>;
    clearInputEvent: EventEmitter<boolean>;
    showHideDropdownEvent: EventEmitter<boolean>;
    dropDownKeyNavigationEvent: EventEmitter<{
        keyCode: number;
        data: ICaInput | null;
    }>;
    setCommandEvent: EventInputManager<CommandsEvent>;
    isCapsLockOn: boolean;
    inputCommandsType: typeof InputCommandsType;
    inputStringEnum: typeof InputStringEnum;
    dropdownTemplateTypeEnum: typeof DropdownTemplateTypeEnum$1;
    isTogglePassword: boolean;
    get inputConfig(): ICaInput;
    constructor(ngControl: NgControl, chdet: ChangeDetectorRef, maskApplier: NgxMaskService, thousandSeparatorPipe: ThousandSeparatorPipe);
    ngAfterViewInit(): void;
    get control(): AbstractControl<any, any, any> | null;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: () => void): void;
    writeValue(obj: InputChangeValue): void;
    handleInput(event: Event): void;
    clearInput(event: Event): void;
    handleChangeInputAndUpdateControl(value: InputChangeValue): void;
    handleInputFocus(event: FocusEvent): void;
    handleInputBlur(event: FocusEvent): void;
    onPopoverShown(): void;
    onPopoverHidden(): void;
    onTogglePassword(event: Event): void;
    handleCapsLock(status: boolean): void;
    handleCommandVisible(status: boolean): void;
    identify(index: number): number;
    handleKeyDown(event: KeyboardEvent): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputTestComponent, [{ optional: true; self: true; }, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputTestComponent, "ca-input-test", never, { "dateTimePopover": { "alias": "dateTimePopover"; "required": false; }; "parentControl": { "alias": "parentControl"; "required": false; }; "selectedDropdownLabelColor": { "alias": "selectedDropdownLabelColor"; "required": false; }; "template": { "alias": "template"; "required": false; }; "incorrectValue": { "alias": "incorrectValue"; "required": false; }; "inputConfig": { "alias": "inputConfig"; "required": false; }; "activeItem": { "alias": "activeItem"; "required": false; }; }, { "handleToggleDropdownOptions": "handleToggleDropdownOptions"; "incorrectInput": "incorrectEvent"; "blurInput": "blurInput"; "focusInputEvent": "focusInput"; "changeInput": "change"; "commandEvent": "commandEvent"; "clearInputEvent": "clear"; "showHideDropdownEvent": "showHideDropdown"; "dropDownKeyNavigationEvent": "dropDownKeyNavigation"; }, never, never, true, never>;
}

declare class CaInputDatetimePickerComponent implements AfterViewInit, ControlValueAccessor, OnDestroy {
    superControl: NgControl;
    private calendarService;
    inputConfig: ICaInput$1;
    formFormat?: string;
    clearInputEvent: EventEmitter<boolean>;
    blurInputEvent: EventEmitter<boolean>;
    caInputPlaceholderIconComponent: CaInputPlaceholderIconComponent$1;
    dateTimePopover: NgbPopover;
    caInputComponent: InputTestComponent;
    inputFormControl: FormControl;
    showDateInput: boolean;
    dateTimeInputDate: Date;
    dateTimeIntDate: Date;
    selectionInput: number;
    private dateTimeMainTimer;
    private focusBlur;
    private timeoutCleaner;
    inputSvgRoutes: typeof InputSvgRoutes$1;
    isTouchedInput: boolean;
    preventBlur: boolean;
    newInputChanged: boolean;
    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;
    private destroy$;
    constructor(superControl: NgControl, calendarService: CalendarDateTimePickerService);
    valueAfterWriteValue: string;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    get getSuperControl(): _angular_forms.AbstractControl<any, any, any> | null;
    selectLastOneForSelection(): void;
    selectLastOneAfterMouseUp(): void;
    onDatePaste(event: ClipboardEvent): void;
    changeSelection(e: any, noPreventDefault?: boolean): void;
    changeSelectionTwo(event: KeyboardEvent, noPreventDefault?: boolean): void;
    private isNumber;
    private isNavigationKey;
    onFocus(event?: FocusEvent): void;
    closePopover(): void;
    toggleDropdownOptions(): void;
    handleFocusInput(e: Event): void;
    setSpanSelection(element: Node): void;
    setSelection(event: {
        preventDefault: () => void;
        stopPropagation: () => void;
        target: any;
    }): void;
    registerOnChange(fn: any): void;
    onChange(_: InputChangeValue$1): void;
    writeValue(obj: InputChangeValue$1): void;
    registerOnTouched(): void;
    blurOnDateTime(): void;
    onPopoverShown(): void;
    onPopoverHidden(): void;
    setTimeDateInput(date: InputChangeValue$1, hasValue?: boolean): void;
    handleKeyboardInputs(e: KeyboardEvent, isRestart?: boolean): void;
    selectSpanByTabIndex(indx: number, changeTab?: boolean): void;
    private handleNavigationKey;
    private handleDatePickerInput;
    private setDateTimeModel;
    private moveSelectionRightOrTab;
    private focusPreviousInput;
    private focusNextInput;
    setIsFocusInput(value: boolean): void;
    private moveSelectionLeft;
    private updateMonth;
    private updateDate;
    private updateYear;
    private padValue;
    private handleTimePickerInput;
    private updateHours;
    private updateMinutes;
    private toggleAMPM;
    clearInput(event: boolean): void;
    onBlurInput(event: any): void;
    resetDateTimeInputs(): void;
    setTimePickerTime(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaInputDatetimePickerComponent, [{ self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaInputDatetimePickerComponent, "ca-input-datetime-picker", never, { "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>;
}

interface RadioButton {
    id: number;
    label: string;
    value: string;
    name: string;
    checked: boolean;
    isActive?: boolean;
}
declare class CaInputRadiobuttonsComponent {
    buttons: RadioButton[] | null;
    disabled: boolean;
    displayRequiredNote?: boolean;
    changedValue: EventEmitter<RadioButton[]>;
    onChange(button: RadioButton): void;
    identity(index: number, item: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaInputRadiobuttonsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaInputRadiobuttonsComponent, "app-ca-input-radiobuttons", never, { "buttons": { "alias": "buttons"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "displayRequiredNote": { "alias": "displayRequiredNote"; "required": false; }; }, { "changedValue": "changedValue"; }, never, never, true, never>;
}

declare class ImageBase64Service {
    private domSanitizer;
    constructor(domSanitizer: DomSanitizer);
    sanitizer(url: string): SafeResourceUrl;
    getStringFromBase64(url: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageBase64Service, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ImageBase64Service>;
}

declare class InputDropdownSvgRoutes$1 {
    static trailersSvgRoute: string;
    static trucksSvgRoute: string;
    static repairPmSvgRoute: string;
    static inputDropdownArrowSvg: string;
    static xClearSvg: string;
    static plusSvg: string;
    static dynamicLabelSvg: string;
    static ownerBadgeBlackSvg: string;
    static arrowDownUpdatedSvg: string;
    static specConfirmSvg: string;
}

declare class CaInputDropdownComponent implements OnInit, AfterViewInit, OnChanges, OnDestroy, ControlValueAccessor {
    superControl: NgControl;
    imageBase64Service: ImageBase64Service;
    private cdRef;
    private renderer;
    inputRef: CaInputComponent;
    popoverRef: NgbPopover;
    _template: string;
    _canAddNew: boolean;
    set template(value: string);
    multiselectTemplate: string;
    inputConfig: ICaInput$1;
    set canAddNew(value: boolean);
    canOpenModal: boolean;
    isAddressDropdown: boolean;
    _sort: string;
    set sort(value: string);
    _activeItem: OptionModel | null;
    set activeItem(value: OptionModel | null);
    activeItemColor: OptionModel | null;
    labelMode: 'Label' | 'Color';
    _options: OptionModel[];
    set options(values: OptionModel[]);
    set preloadMultiselectItems(values: OptionModel[]);
    isDetailsPages: boolean;
    isIncorrectValue: boolean;
    selectedItem: EventEmitter<OptionModel | null>;
    selectedItems: EventEmitter<OptionModel[] | null>;
    selectedItemColor: EventEmitter<OptionModel | null>;
    selectedLabelMode: EventEmitter<string>;
    closeDropdown: EventEmitter<boolean>;
    saveItem: EventEmitter<{
        data: OptionModel | null;
        action: string;
    }>;
    incorrectEvent: EventEmitter<boolean>;
    placeholderIconEvent: EventEmitter<boolean>;
    paginationEvent: EventEmitter<number>;
    activeGroupEvent: EventEmitter<OptionModel>;
    clearInputEvent: EventEmitter<boolean>;
    originalOptions: OptionModel[];
    paginationNumber: number;
    multiselectItems: OptionModel[];
    isMultiSelectInputFocus: boolean;
    multiSelectLabel: string | undefined;
    lastActiveMultiselectItem: OptionModel | null;
    isInAddMode: boolean;
    private dropdownPosition;
    clearTimeoutDropdown: string | number | ReturnType<typeof setTimeout> | undefined;
    hoveringIndex: number;
    inputDropdownSvgRoutes: typeof InputDropdownSvgRoutes$1;
    dropdownTemplateTypeEnum: typeof DropdownTemplateTypeEnum$1;
    originalInputConfig: ICaInput$1;
    private destroy$;
    constructor(superControl: NgControl, imageBase64Service: ImageBase64Service, cdRef: ChangeDetectorRef, renderer: Renderer2);
    get getSuperControl(): _angular_forms.AbstractControl<any, any, any> | null;
    writeValue(_: any): void;
    registerOnChange(_: any): void;
    registerOnTouched(_: any): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    onScrollDropdown(event: EventTarget | null): void;
    onActiveItem(option: OptionModel, group?: any): void;
    onActiveItemGroup(event: {
        option: OptionModel;
        group: any;
    }): void;
    onClearSearch(): void;
    clearDropdownLabel(): void;
    commandEvent(event: CommandsEvent$1): void;
    addNewItem(): void;
    updateItem(): void;
    addNewConfig(): void;
    onIncorrectInput(event: boolean): void;
    identity(index: number, item: OptionModel): number | undefined;
    toggleNestedList(option: OptionModel): void;
    onBlurInput(event: boolean): void;
    onClearInputEvent(event: boolean): void;
    showHideDropdown(action: boolean): void;
    dropDownKeyNavigation({ keyCode, data, }: {
        keyCode: number;
        data: any;
    }): void;
    onMultiselectSelect(option: OptionModel): void;
    removeMultiSelectItem(index: number): void;
    deleteAllMultiSelectItems(currentLabel?: string): void;
    toggleMultiselectDropdown(): void;
    private pickupElementWithKeyboard;
    private search;
    /**
     * Navigate through dropdown with keyboard arrows
     */
    private dropdownNavigation;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaInputDropdownComponent, [{ self: true; }, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaInputDropdownComponent, "app-ca-input-dropdown", never, { "template": { "alias": "template"; "required": false; }; "multiselectTemplate": { "alias": "multiselectTemplate"; "required": false; }; "inputConfig": { "alias": "inputConfig"; "required": false; }; "canAddNew": { "alias": "canAddNew"; "required": false; }; "canOpenModal": { "alias": "canOpenModal"; "required": false; }; "isAddressDropdown": { "alias": "isAddressDropdown"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "activeItem": { "alias": "activeItem"; "required": false; }; "activeItemColor": { "alias": "activeItemColor"; "required": false; }; "labelMode": { "alias": "labelMode"; "required": false; }; "options": { "alias": "options"; "required": false; }; "preloadMultiselectItems": { "alias": "preloadMultiselectItems"; "required": false; }; "isDetailsPages": { "alias": "isDetailsPages"; "required": false; }; "isIncorrectValue": { "alias": "isIncorrectValue"; "required": false; }; }, { "selectedItem": "selectedItem"; "selectedItems": "selectedItems"; "selectedItemColor": "selectedItemColor"; "selectedLabelMode": "selectedLabelMode"; "closeDropdown": "closeDropdown"; "saveItem": "saveItem"; "incorrectEvent": "incorrectEvent"; "placeholderIconEvent": "placeholderIconEvent"; "paginationEvent": "pagination"; "activeGroupEvent": "activeGroup"; "clearInputEvent": "clearInputEvent"; }, never, never, true, never>;
}

interface MapDropdownContent {
    mainContent?: MapDropdownContentItem[];
    expandedContent?: MapDropdownContentItem[];
    clusterData?: MapDropdownClusterItem[];
    selectedClusterItemData?: any;
    isAlwaysExpanded?: boolean;
    mainContentTemplate?: TemplateRef<any>;
    expandedContentTemplate?: TemplateRef<any>;
}
interface MapDropdownContentItem {
    template: 'header-title' | 'rating-review' | 'divider' | 'repair-shop-services' | 'fuel-price-range' | 'stop-type' | 'icon-text' | 'title' | 'title-count' | 'subtitle' | 'text' | 'money-text' | 'open-hours' | 'small-subtitle' | 'text-count' | 'side-by-side' | 'date' | 'travel-time';
    field: string;
    secondField?: string;
    thirdField?: string;
    url?: string;
    count?: number;
    title?: string;
    iconTooltipText?: string;
    hasBackButton?: boolean;
    customClassContainer?: string;
    customClassText?: string;
    isDate?: boolean;
    isDuration?: boolean;
    sideBySideInfo?: {
        leftSide: MapDropdownContentItem;
        rightSide: MapDropdownContentItem;
    };
}
interface MapDropdownClusterItem {
    id?: number;
    name?: string | null;
    favourite?: boolean;
    isClosed?: boolean;
    pricePerGallon?: number | null;
}

interface IRoutePath {
    lat: number;
    lng: number;
}
interface IRouteLocation {
    latitude?: number | null;
    longitude?: number | null;
}
interface ICaMapProps {
    clusterMarkers?: IMapMarkers[];
    routingMarkers?: IMapMarkers[];
    routePaths?: IMapRoutePath[];
    selectedMarkerData?: IMapSelectedMarkerData;
    selectedRoutingMarkerData?: IMapMarkers;
    isAccidentMap?: boolean;
    stateBoundariesUrl?: {
        url: string;
    };
    markers?: IMapMarkers[];
    view?: string;
    isUnitViewStops?: boolean;
    isDriverMiles?: boolean;
    mapType?: string;
    darkMode?: boolean;
    isZoomShown?: boolean;
    isVerticalZoom?: boolean;
    isOpenInMapShown?: boolean;
    areaFilterData?: IMapAreaFilter;
}
interface IMapOptions {
    fullscreenControl: boolean;
    disableDefaultUI: boolean;
    restriction: {
        latLngBounds: {
            north: number;
            south: number;
            east: number;
            west: number;
        };
        strictBounds: boolean;
    };
    streetViewControl: boolean;
    styles?: IMapStyles[];
    keyboardShortcuts: boolean;
    panControl: boolean;
    gestureHandling: string;
    mapTypeControl?: boolean;
    zoom?: number;
    center?: IRoutePath;
}
interface IMapStyles {
    elementType?: string | null;
    featureType?: string | null;
    stylers: IMapColor[];
}
interface IMapColor {
    color?: string;
    visibility?: string;
    weight?: number;
    saturation?: number;
    lightness?: number;
}
interface IMapMarkers {
    position: IRoutePath;
    icon?: IMapMarkersIcon;
    infoWindowContent?: MapDropdownContent;
    label?: string;
    labelOrigin?: {
        x: number;
        y: number;
    };
    data?: any;
    options?: {
        zIndex?: number;
    };
    isLargeMarker?: boolean;
    isFavorite?: boolean;
    isClosed?: boolean;
    isShowLabelOnHover?: boolean;
    hasClickEvent?: boolean;
    hasHoverEvent?: boolean;
    id?: number;
    content?: any;
    routeId?: number;
    isRouteHover?: boolean;
}
interface IMapMarkersIcon {
    url: string;
    labelOrigin?: google.maps.Point;
    scaledSize?: google.maps.Size;
}
interface IMarkerLabel {
    text: string;
    fontSize?: string;
    color?: string;
    fontWeight?: string;
    isShowOnHover?: boolean;
}
interface IMapRoutePath {
    path: IRoutePath[];
    decodedShape?: IRouteLocation[];
    strokeColor: string;
    strokeOpacity?: number;
    strokeWeight?: number;
    isDashed?: boolean;
    dashedLineStyle?: IMapDashedRouteStyle[];
    id?: number;
}
interface IMapBoundsZoom {
    bounds: google.maps.LatLngBounds;
    zoom: number;
}
interface IMapSelectedMarkerData extends IMapMarkers {
    isClusterMarker?: boolean;
}
interface IMapDashedRouteStyle {
    icon: IMapDashedRouteIcon;
    offset: string;
    repeat: string;
}
interface IMapDashedRouteIcon {
    path: string;
    strokeOpacity: number;
    strokeColor: string;
    scale: number;
}
interface IMapPagination {
    pageIndex: number;
    pageSize: number;
}
interface IMapBounds {
    northEastLatitude: number;
    northEastLongitude: number;
    southWestLatitude: number;
    southWestLongitude: number;
    zoomLevel: number;
}
interface IMapList {
    isSelected?: boolean;
    id?: number;
}
interface IMapAreaFilter {
    options: IMapAreaFilterOptions;
    center: IRoutePath;
    radius: number;
}
interface IMapAreaFilterOptions {
    fillColor: string;
    strokeWeight: number;
    fillOpacity: number;
    editable: boolean;
    draggable: boolean;
    clickable: boolean;
}

declare class MapMarkerIconService {
    private renderer;
    private clusterMarkerIds;
    clusterMarkerIds$: Observable<IMapMarkers[]>;
    private routingMarkerIds;
    routingMarkerIds$: Observable<IMapMarkers[]>;
    private markerElements;
    private clusterElements;
    private routingElements;
    constructor(rendererFactory: RendererFactory2);
    getMarkerIcon(markerId: number, labelName?: string, isClosed?: boolean, isFavorite?: boolean, isAlwaysSelected?: boolean, fuelMarkerClass?: string, secondLabelName?: string, isCreateNewMarker?: boolean): HTMLElement;
    getClusterMarkerIcon(markerData: IMapMarkers, isFuelMarker?: boolean): HTMLElement;
    getRoutingMarkerIcon(markerData: IMapMarkers, stopNumber: number, stopType: string, isStopChecked?: boolean, isLightMode?: boolean, labelName?: string): HTMLElement;
    getCurrentLocationMarkerIcon(markerData: IMapMarkers, motionStatus: eGpsMotionStatus): HTMLElement;
    createClusterId(clusterData: IMapMarkers): number;
    createRoutingId(markerData: IMapMarkers): number;
    resetMarkersData(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapMarkerIconService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MapMarkerIconService>;
}

declare class SharedSvgRoutes {
    static COMMON_FOLDER_ROUTE: string;
    static ARROW_DOWN_SORT: string;
    static ARROW_UP_SORT: string;
    static SORT_ARROWS_ICON: string;
    static DROPDOWN_ARROW: string;
    static ARROW_LEFT: string;
    static LAST_PRICE_ARROW_DOWN: string;
    static ARROW_RIGHT: string;
    static ARROW_DOWN: string;
    static SELECT_REMAINING_ICON: string;
    static CIRCLE: string;
    static CLEAR_SELECTED_ICON: string;
    static BACK_STATUS_ICON: string;
    static ARROW_UP: string;
    static CONFIRMATION_TRASH_MODAL_ICON: string;
    static CONFIRMATION_DELETE_ICON: string;
    static CONFIRMATION_INFO_ICON: string;
    static CONFIRMATION_CHECKMARK_ICON: string;
    static CONFIRMATION_RESET_ICON: string;
    static CONFIRMATION_VOID_ICON: string;
    static CONFIRMATION_MODAL_ACTIVATE_ICON: string;
    static CONFIRMATION_MODAL_DEACTIVATE_ICON: string;
    static CONFIRMATION_MODAL_CLOSE_ICON: string;
    static CONFIRMATION_MODAL_OPEN_ICON: string;
    static CONFIRMATION_MODAL_TABEL_RESET_ICON: string;
    static CONFIRMATION_MODAL_MOVE_ICON: string;
    static CONFIRMATION_MODAL_REMOVE_ICON: string;
    static CONFIRMATION_MODAL_VOID_ICON: string;
    static MODAL_INFO_ICON: string;
    static FILES_ICON: string;
    static CHECKMARK_ICON: string;
    static CANCEL_ICON: string;
    static ARROW_UP_FILLED_ICON: string;
    static PLUS_ICON: string;
    static COMMENT_ICON: string;
    static DOCUMENT_ICON: string;
    static CLOSE_ICON_NORMAL: string;
    static PHONE_ICON: string;
    static EMAIL_ICON: string;
    static EDIT_ICON: string;
    static DELETE_ICON: string;
    static COPY_ICON: string;
    static CHECK_ICON: string;
    static NEW_SORT_ICON: string;
    static NEW_SORT_ICON_ASCENDING: string;
    static NEW_SORT_ICON_DESCENDING: string;
    static MINUS_ICON: string;
    static MAP_LOCATION_ICON: string;
}

declare class CaMapComponent {
    cd: ChangeDetectorRef;
    private el;
    private renderer;
    private markerIconService;
    constructor(cd: ChangeDetectorRef, el: ElementRef, renderer: Renderer2, markerIconService: MapMarkerIconService);
    maps: GoogleMap;
    markerDropdown: ElementRef;
    clusterDropdown: ElementRef;
    mapMarkers: QueryList<MapAdvancedMarker>;
    set data(values: ICaMapProps);
    resetSelectedMarkerItem: EventEmitter<boolean>;
    routingMarkerClick: EventEmitter<number>;
    clusterMarkerClick: EventEmitter<IMapMarkers>;
    clusterListScrollEvent: EventEmitter<IMapMarkers>;
    getInfoWindowData: EventEmitter<number>;
    boundsChanged: EventEmitter<IMapBoundsZoom>;
    openInMapEvent: EventEmitter<any>;
    private destroy$;
    directionsRenderers: google.maps.DirectionsRenderer[];
    mapOptions: IMapOptions;
    mapZoom: number;
    mapCenter: IRoutePath;
    map: google.maps.Map | null;
    mapStyleId: string;
    mapData: ICaMapProps;
    mapScaleMilesLabel: number;
    mapScalePixelWidth: number;
    openedInfoWindowData: IMapMarkers | null;
    selectedRoutingMarker: IMapMarkers | null;
    areaFilterData: IMapAreaFilter | null;
    routePathColors: string[];
    routePolylines: google.maps.PolylineOptions[];
    isMarkerDropdownOpen: boolean;
    isClusterDropdownOpen: boolean;
    isMapCenterSet: boolean;
    openDropdownTimeout: ReturnType<typeof setTimeout> | number;
    selectRoutingTimeout: ReturnType<typeof setTimeout> | number;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onClusterMarkerClick(markerItem: IMapMarkers): void;
    getMarkerInfoWindow(markerId: number): void;
    onMarkerClick(markerItem: IMapMarkers): void;
    onRoutingMarkerClick(markerItem: IMapMarkers): void;
    onMapReady(mapInstance: google.maps.Map): {
        fillColor?: string;
        strokeColor?: string;
        strokeWeight?: number;
        fillOpacity?: number;
    } | void;
    onClusterBackButtonClick(): void;
    checkInfoWindowPosition(markerItem: IMapMarkers, markerItem2?: IMapMarkers | null): boolean;
    onClusterListScrollToEnd(): void;
    onZoomChange(isMinusClick?: boolean): void;
    onOpenInMap(): void;
    private calculateAndDisplayRoute;
    private resetMarkersIcons;
    private setMapStyles;
    private getMapIdleEvent;
    private sendBoundsChangedEvent;
    private openMarkerInfoWindow;
    private closeInfoWindow;
    private handleRoutingMarkerSelect;
    private handleMapData;
    private addHoverListeners;
    private handleHover;
    private highlightMarkersByRoute;
    private highlightSingleMarker;
    private updatePolylineColorsByRoute;
    private updatePolylineColorsByMarker;
    private storeRoutePathColors;
    private getScaleDistance;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaMapComponent, "app-ca-map", never, { "data": { "alias": "data"; "required": false; }; }, { "resetSelectedMarkerItem": "resetSelectedMarkerItem"; "routingMarkerClick": "routingMarkerClick"; "clusterMarkerClick": "clusterMarkerClick"; "clusterListScrollEvent": "clusterListScrollEvent"; "getInfoWindowData": "getInfoWindowData"; "boundsChanged": "boundsChanged"; "openInMapEvent": "openInMapEvent"; }, never, never, true, never>;
}

declare class MapDropdownSvgRoutes {
    static likeRoute: string;
    static dislikeRoute: string;
    static reviewRoute: string;
    static phoneRoute: string;
    static emailRoute: string;
    static addressRoute: string;
    static cornerDownArrowRoute: string;
    static calenderRoute: string;
    static calenderTwoRoute: string;
    static cornerTopArrowRoute: string;
    static vechileRoute: string;
    static injuryRoute: string;
    static hazmatRoute: string;
    static towingRoute: string;
    static accidentCalenderRoute: string;
    static ossRoute: string;
    static permanentlyClosedRoute: string;
    static favoriteRoute: string;
    static backButtonRoute: string;
    static dateDeactivatedRoute: string;
}

interface ILastFuelPriceProgressConfig {
    title: string;
    totalValue: number;
    minValue: number;
    maxValue: number;
    isOutdated: boolean;
    svgPosition: number;
    svgClass: string;
    isMapView?: boolean;
}

interface ILastFuelPriceProgressData {
    pricePerGallon: number;
    lowestPricePerGallon: number;
    highestPricePerGallon: number;
    priceOutDated: boolean;
    defPrice: number;
    defLowestPrice: number;
    defHighestPrice: number;
    defPriceOutDated: boolean;
    isMapView: boolean;
    dieselLastUsed?: string;
}

declare enum eMapDropdownString {
    HEADER_TITLE = "header-title",
    RATING_REVIEW = "rating-review",
    DIVIDER = "divider",
    REPAIR_SHOP_SERVICES = "repair-shop-services",
    FUEL_PRICE_RANGE = "fuel-price-range",
    STOP_TYPE = "stop-type",
    ICON_TEXT = "icon-text",
    TITLE = "title",
    TITLE_COUNT = "title-count",
    MONEY_TEXT = "money-text",
    OPEN_HOURS = "open-hours",
    TEXT_COUNT = "text-count",
    SUBTITLE = "subtitle",
    TEXT = "text",
    SMALL_SUBTITLE = "small-subtitle",
    DATE = "date",
    TRAVEL_TIME = "travel-time"
}

declare class CaMapDropdownComponent<T> {
    set infoWindowContent(values: MapDropdownContent | null);
    set markerData(values: T);
    onClusterItemClick: EventEmitter<number>;
    onClusterListScrollToEnd: EventEmitter<any>;
    onBackButtonClick: EventEmitter<any>;
    bodyActions: EventEmitter<IDropDownActions>;
    isHidden: boolean;
    isShowAllDaysActive: boolean;
    data: DropDownData[];
    _markerData: T | null;
    _infoWindowContent: MapDropdownContent | null;
    fuelPriceRangeData: ILastFuelPriceProgressData | null;
    mapDropdownSvgRoutes: typeof MapDropdownSvgRoutes;
    eMapDropdownString: typeof eMapDropdownString;
    showHiddenData(event: Event): void;
    callBodyAction(action: IDropDownActions): void;
    clusterItemClick(item: MapDropdownClusterItem): void;
    backButtonClick(event: Event): void;
    showAllDaysClick(): void;
    onClusterListScroll(event: Event): void;
    preventEventPropagation(event: Event, preventDefault?: boolean): void;
    setFuelPriceData(markerData: T): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaMapDropdownComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaMapDropdownComponent<any>, "app-ca-map-dropdown", never, { "infoWindowContent": { "alias": "infoWindowContent"; "required": false; }; "markerData": { "alias": "markerData"; "required": false; }; }, { "onClusterItemClick": "onClusterItemClick"; "onClusterListScrollToEnd": "onClusterListScrollToEnd"; "onBackButtonClick": "onBackButtonClick"; "bodyActions": "bodyActions"; }, never, never, true, never>;
}

interface NoteActiveOptions {
    bold: boolean;
    italic: boolean;
    foreColor: boolean;
    underline: boolean;
}

interface NoteColors {
    color: string;
    name: string;
}

declare class NoteContainerSvgRoutes {
    static boldRoute: string;
    static itallicRoute: string;
    static colorRoute: string;
    static underlineRoute: string;
    static checkRoute: string;
    static arrowRoute: string;
}

declare class CaNoteContainerComponent implements OnInit, OnDestroy {
    value: string;
    range: Range;
    selectionTaken: Selection;
    isExpanded: boolean | string;
    isParking: boolean;
    isPopoverNote: boolean;
    isVisibleArrow: boolean;
    type: string;
    selectedEditor: HTMLDivElement;
    stopBlurRemoveTimeout: EventEmitter<any>;
    selectedPaternColor: string;
    activeOptions: NoteActiveOptions | any;
    containerColors: NoteColors[];
    selectedColorName: NoteColors;
    private slowTimeout;
    private lastSavedIndex;
    private isDefaultColorSet;
    isShowColorPattern: boolean;
    isClosedPattern: boolean;
    isHoveringArrowPicker: boolean;
    private destroy$;
    constructor();
    ngOnInit(): void;
    private filterContainersColor;
    executeEditor(action: string, color?: string, indx?: number): void;
    togglePattern(): void;
    hoveringArrow(value: boolean): void;
    private setContainerColors;
    /**Function retrun id */
    identity(index: number): number;
    getSvgPath(propertyName: keyof typeof NoteContainerSvgRoutes): string;
    focusElement(): void;
    checkActiveItems(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaNoteContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaNoteContainerComponent, "app-ca-note-container", never, { "value": { "alias": "value"; "required": false; }; "range": { "alias": "range"; "required": false; }; "selectionTaken": { "alias": "selectionTaken"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; "isParking": { "alias": "isParking"; "required": false; }; "isPopoverNote": { "alias": "isPopoverNote"; "required": false; }; "isVisibleArrow": { "alias": "isVisibleArrow"; "required": false; }; "type": { "alias": "type"; "required": false; }; "selectedEditor": { "alias": "selectedEditor"; "required": false; }; }, { "stopBlurRemoveTimeout": "stopBlurRemoveTimeout"; }, never, never, true, never>;
}

declare class NoteSvgRoutes {
    static trashRoute: string;
    static noteRoute: string;
    static noteFilledRoute: string;
}

declare class CaNoteComponent {
    private ref;
    private elRef;
    saveNoteValue: EventEmitter<any>;
    isParking: boolean;
    dispatchIndex: number;
    type: string;
    parentWidth: string;
    isDispatch: boolean;
    set noteWidth(value: number);
    set isOpenAll(value: boolean);
    main_editor: ElementRef;
    note_popover: ElementRef;
    noteContainer: CaNoteContainerComponent;
    placeholder: string;
    _note: string;
    _noteWidth: number;
    _parentWidth: number;
    isAllOpen: boolean;
    noteIcon: string;
    isShowColorPattern: boolean;
    buttonsExpanded: boolean;
    activeOptions: NoteActiveOptions;
    selectedPaternColor: string;
    isExpanded: boolean;
    isNoteOpened: boolean;
    value: string;
    private lastTypeTime;
    isleavedOpened: boolean;
    selectionTaken: Selection;
    range: Range;
    isFocused: boolean;
    private isPreventedClosing;
    isSavingNote: boolean;
    savedValue: string;
    private destroy$;
    constructor(ref: ChangeDetectorRef, elRef: ElementRef);
    ngAfterViewInit(): void;
    checkFocus(event: Event): void;
    toggleNote(data: string, t2: NgbPopover): void;
    prepareForTextRange(): void;
    preventMouseDown(ev: Event): void;
    valueChange(event: Event | string, deleteAll?: boolean): void;
    saveNote(autoSave?: boolean, deleteAll?: boolean): void;
    private closeNote;
    popoverClosed(): void;
    onPaste(event: ClipboardEvent): void;
    private transferNoteData;
    private checkNoteImage;
    getSvgPath(propertyName: keyof typeof NoteSvgRoutes): string;
    private checkActiveItems;
    private setNoteParentWidth;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaNoteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaNoteComponent, "app-ca-note", never, { "isParking": { "alias": "isParking"; "required": false; }; "dispatchIndex": { "alias": "dispatchIndex"; "required": false; }; "type": { "alias": "type"; "required": false; }; "parentWidth": { "alias": "parentWidth"; "required": false; }; "isDispatch": { "alias": "isDispatch"; "required": false; }; "noteWidth": { "alias": "noteWidth"; "required": false; }; "isOpenAll": { "alias": "isOpenAll"; "required": false; }; }, { "saveNoteValue": "saveNoteValue"; }, never, never, true, never>;
}

declare class SvgRoutes {
    static downArrow: string;
    static upArrow: string;
}

interface PayrollListSummaryOverview {
    text: string;
    type: string;
    itemCount: number;
    date: string;
    money: number;
    moneyCounter: number;
    status: string;
    isExpanded?: boolean;
    isOpen?: boolean;
    description?: string;
}

declare class CaPayrollListSummaryOverviewComponent {
    leftTemplate: TemplateRef<any>;
    showLeftTemplate: boolean;
    item: PayrollListSummaryOverview;
    isItemExpanded: boolean;
    isExpanded: boolean;
    index: number;
    toggle: EventEmitter<{
        payrollSummary: PayrollListSummaryOverview;
        status: boolean;
        index: number;
    }>;
    animationMarginParams: {
        marginTop: string;
        marginBottom: string;
    };
    constructor();
    getSvgPath(propertyName: keyof typeof SvgRoutes): string;
    toggleAccordion(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaPayrollListSummaryOverviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaPayrollListSummaryOverviewComponent, "app-ca-payroll-list-summary-overview", never, { "leftTemplate": { "alias": "leftTemplate"; "required": false; }; "showLeftTemplate": { "alias": "showLeftTemplate"; "required": false; }; "item": { "alias": "item"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; "index": { "alias": "index"; "required": false; }; "animationMarginParams": { "alias": "animationMarginParams"; "required": false; }; }, { "toggle": "toggle"; }, never, ["*"], true, never>;
}

declare class CaPayrollListSummaryOverviewTableComponent {
    data: PayrollListSummaryOverview[];
    openIndex: number | null;
    identity(index: number, item: PayrollListSummaryOverview): string;
    toggleItem(index: number): number | void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaPayrollListSummaryOverviewTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaPayrollListSummaryOverviewTableComponent, "app-ca-payroll-list-summary-overview-table", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
}

declare enum StatusTypeEnum {
    CLOSED = "CLOSED",
    ACTIVE = "ACTIVE",
    PENDING = "PENDING"
}

interface CompanyUserShortResponse {
    id?: number;
    userId?: number;
    fullName?: string | null;
    avatarFile?: FileResponse$1 | null;
    departmentId?: number | null;
}

interface DispatchGroupedLoadsResponse {
    pending?: Array<LoadShortResponse> | null;
    closed?: Array<LoadShortResponse> | null;
    active?: Array<LoadShortResponse> | null;
}

interface DispatchHosResponse {
    id?: number;
    start?: number;
    end?: number;
    flag?: EnumValue$1;
    createdAt?: string;
    updatedAt?: string;
}

interface TrailerTypeResponse {
    id?: number;
    companyId?: number | null;
    name?: string | null;
    logoName?: string | null;
    hasVolume?: boolean | null;
}

interface TrailerMinimalResponse {
    id?: number;
    trailerNumber?: string | null;
    status?: number;
    owner?: string | null;
    trailerType?: TrailerTypeResponse;
    trailerMakeName?: string | null;
    model?: string | null;
    year?: number;
}

interface DriverDispatchResponse {
    id?: number;
    firstName?: string | null;
    lastName?: string | null;
    owner?: number | null;
    status?: number;
    vacation?: boolean;
    avatarFile?: FileResponse$1 | null;
    endorsements?: Array<string> | null;
}

interface DispatchStatusResponse {
    statusValue?: EnumValue$1;
    statusString?: string | null;
    statusCheckInNumber?: string | null;
}

interface ParkingSlotShortResponse {
    id?: number;
    parking?: ParkingShortResponse;
    slotNumber?: number;
    parkingSlotType?: EnumValue$1;
}
interface ParkingShortResponse {
    id?: number;
    name?: string | null;
}

interface DispatchResponse {
    id?: number;
    order?: number;
    dispatchBoardId?: number | null;
    dispatcher?: CompanyUserShortResponse;
    truck?: TruckMinimalResponse;
    trailer?: TrailerMinimalResponse;
    driver?: DriverDispatchResponse;
    coDriver?: DriverDispatchResponse | null;
    phone?: string | null;
    email?: string | null;
    location?: AddressModel;
    latitude?: number | null;
    longitude?: number | null;
    status?: DispatchStatusResponse;
    lastStatusDateTime?: string;
    currentStopType?: EnumValue$1 | null;
    nextStopType?: EnumValue$1;
    hoursOfService?: Array<DispatchHosResponse> | null;
    note?: string | null;
    activeLoad?: LoadShortResponse | null;
    parkingSlot?: ParkingSlotShortResponse | null;
    loadProgress?: any;
    preTripInspection?: EnumValue$1;
    preTripInspectionTime?: string | null;
}

interface IDropdownMenuItem {
    id?: number;
    title: string;
    titleOptionalClass?: string;
    type?: string;
    svgUrl?: string;
    svgClass?: string;
    hasBorder?: boolean;
    isDisabled?: boolean;
    innerDropdownContent?: {
        title: string;
        type?: string;
        isChecked?: boolean;
        isColumnDropdown?: boolean;
        isCheckBoxDisabled?: boolean;
    }[];
    isSelectMenuTypeActionItem?: boolean;
    isChecked?: boolean;
    groupName?: string;
    isColumnDropdown?: boolean;
    isCheckBoxDisabled?: boolean;
}

interface IDropdownMenuOptionEmit {
    id?: number;
    type?: string;
    isActive?: boolean;
}

declare class PickupDeliveryBlockComponent implements OnInit {
    set columnWidth(value: number);
    set searchStrings(value: ISearchQueryItem[]);
    loads: DispatchGroupedLoadsResponse | null;
    dispatchResponse: DispatchResponse | null;
    isHoveringRow: boolean;
    isDisabled: boolean;
    dropdownMenuAction: EventEmitter<IDropdownMenuOptionEmit>;
    _searchStrings: ISearchQueryItem[];
    _columnWidth: number;
    loadType: StatusTypeEnum;
    constructor();
    ngOnInit(): void;
    private initializeLoadType;
    openPopover(t2: NgbPopover): void;
    closePopover(t2: NgbPopover): void;
    onDropdownMenuAction(action: IDropdownMenuOptionEmit): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PickupDeliveryBlockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PickupDeliveryBlockComponent, "app-ca-pickup-delivery-block", never, { "columnWidth": { "alias": "columnWidth"; "required": false; }; "searchStrings": { "alias": "searchStrings"; "required": false; }; "loads": { "alias": "loads"; "required": false; }; "dispatchResponse": { "alias": "dispatchResponse"; "required": false; }; "isHoveringRow": { "alias": "isHoveringRow"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; }, { "dropdownMenuAction": "dropdownMenuAction"; }, never, never, true, never>;
}

interface LongLat$1 {
    longitude?: number | null;
    latitude?: number | null;
}

interface EnumValue {
    name?: string | null;
    id?: number;
}

interface LoadStatusHistoryResponse {
    id?: number;
    status?: EnumValue;
    statusString?: string | null;
    stopOrder?: number | null;
    dateTimeFrom?: string | null;
    dateTimeTo?: string | null;
    wait?: {
        days?: number;
        hours?: number;
        minutes?: number;
        seconds?: number;
    } | null;
    updatedAt?: string;
}

interface IUSerAvatarFile {
    fileId: number;
    fileName: string;
    url: string;
    fileSize?: number;
    tags?: string[];
    tagGeneratedByUser?: boolean;
    updatedAt?: string;
}

interface ICompanyUser {
    id: number;
    userId?: number;
    fullName?: string;
    name?: string;
    avatarFile?: IUSerAvatarFile;
    departmentId?: number;
}

interface IUser {
    userId: number;
    companyUserId?: number;
    areSettingsUpdated?: boolean;
    avatarFile?: FileResponse$1;
    driverId?: number;
    firstName: string;
    lastName: string;
    refreshToken?: string;
    token?: string;
}

interface IGpsProgress {
    type: string;
    heading: string;
    position: number;
    location: string;
    mileage: string;
    date?: string;
    time?: string;
    latitude: number;
    longitude: number;
    legMiles?: number;
    stopNumber?: number;
    isAtStop?: boolean;
    currentWaitTime?: number;
    averageWaitTime?: {
        [key: string]: number;
    };
    isVisited?: boolean;
    routeShape?: LongLat$1[];
    motionStatus?: number | null;
}

interface TableCardBodyActions<T> {
    type?: string;
    id?: number;
    data?: T;
}

interface IGpsCurrentLocation {
    id?: number;
    deviceId?: string | null;
    latitude?: number | null;
    longitude?: number | null;
    coordinates?: string | null;
    altitude?: number | null;
    speed?: number | null;
    heading?: number | null;
    headingString?: string | null;
    location?: string | null;
    motionStatus?: number | null;
    motionStatusPeriod?: string | null;
    updateTime?: string | null;
    startDate?: string | null;
    stopDate?: string | null;
    dateString?: string | null;
    companyId?: number | null;
    unitType?: number | null;
}

interface IGpsHeadingInfo {
    gpsHeading?: string;
    gpsTime?: string;
    gpsHeadingColor?: string;
    gpsDropdownHeadingColor?: string;
}

interface IProgressBarData {
    currentLocation: IGpsCurrentLocation | null;
    currentPosition: number;
    currentStop: IGpsProgress;
    mileageInfo: string;
    mileagesPercent: string;
    totalMiles: number;
    gpsTitle: string;
    gpsIcon: string;
    gpsInfo: IGpsHeadingInfo;
    gpsLocationIcon: string;
    gpsProgress: IGpsProgress[];
    dispatchStatus: string;
    driverId: number;
}

declare class ProgressBarSvgRoutes {
    static checkRoute: string;
}

declare class ProgressBarComponent {
    private markerIconService;
    set progressBarData(values: IProgressBarData);
    dropdownWidth: number | null;
    mapWidth: number | null;
    isDisabled: boolean;
    onOpenMap: EventEmitter<any>;
    _progressBarData: IProgressBarData | null;
    _gpsProgress: IGpsProgress[];
    currentPosition: number;
    gpsIconTopPosition: number;
    hoveredGpsTitle: string | null;
    hoveredMileageInfo: string | null;
    hoveredGpsIcon: boolean;
    staticConstant: {
        completed: string;
        completed_text: string;
        total: string;
        zero: number;
        percentage: string;
        miles: string;
    };
    progressBarSvgRoutes: typeof ProgressBarSvgRoutes;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    mapData: ICaMapProps;
    eUnit: typeof eUnit;
    ePosition: typeof ePosition;
    eColor: typeof eColor;
    eThousandSeparatorFormat: typeof eThousandSeparatorFormat;
    eDateTimeFormats: typeof eDateTimeFormats;
    get gpsStopsWithoutCurrentLocation(): IGpsProgress[];
    constructor(markerIconService: MapMarkerIconService);
    hoverStop(stop: IGpsProgress): void;
    hoverCurrentLocation(): void;
    leaveStop(): void;
    showDropdownMap(t2: NgbPopover): void;
    private setGpsProgress;
    private setMapMarkers;
    private calculateGpsIconPosition;
    private setProgressData;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressBarComponent, "app-ca-progress-bar", never, { "progressBarData": { "alias": "progressBarData"; "required": false; }; "dropdownWidth": { "alias": "dropdownWidth"; "required": false; }; "mapWidth": { "alias": "mapWidth"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; }, { "onOpenMap": "onOpenMap"; }, never, never, true, never>;
}

declare class SearchMultipleStatesRoutes {
    static searchButton: string;
    static focusedSearchButton: string;
    static clearSearch: string;
    static add: string;
}

declare class CaSearchMultipleStatesService {
    private searchTableData;
    currentSearchTableData: rxjs.Observable<any>;
    sendCurrentSearchTableData(search: any): void;
    private chipsForHighlightSearchToTable;
    currentChipsForHighlightSearchToTable: rxjs.Observable<string[]>;
    sendChipsForHighlightSearchToTable(chip: string[]): void;
    private selectedChipsSubject;
    selectedChips$: rxjs.Observable<string[]>;
    emitSelectedChips(chip: string[]): void;
    private deleteAllChipsSubject;
    deleteAllChips$: rxjs.Observable<void>;
    deleteAllChips(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaSearchMultipleStatesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CaSearchMultipleStatesService>;
}

interface ChipsModel {
    searchText: string;
    color: string;
    canDoAnimation: boolean;
    query: string;
}

interface GridColumn {
    avatar: null | string;
    disabled: boolean;
    export: boolean;
    field: string;
    filter: string;
    filterable: boolean;
    hidden: boolean;
    hoverTemplate: null | string;
    index: number;
    isActionColumn: boolean;
    isNumeric: boolean;
    isPined: boolean;
    isSelectColumn: boolean;
    name: string;
    ngTemplate: string;
    progress: null | string;
    resizable: boolean;
    sortable: boolean;
    tableHeadTitle: string;
    title: string;
    width: number;
}

interface ITabData {
    extended?: boolean;
    field?: string;
    gridNameTitle?: string;
    isActive?: boolean;
    length?: number;
    stateName?: string;
    tableConfiguration?: string;
    title?: string;
    gridColumns?: GridColumn;
    data?: any;
}

declare class CaSearchMultipleStatesComponent implements OnInit, OnDestroy {
    private searchMultipleStatesService;
    private elementRef;
    onDocumentClick(event: MouseEvent): void;
    tableSearchInput: ElementRef;
    toolbarSearch?: boolean;
    selectedTabData: ITabData;
    searchType: string;
    isAlwaysOpenSearch: boolean;
    set isDetailsPageSearch(value: boolean);
    close: EventEmitter<void>;
    onSearch: EventEmitter<string>;
    _isDetailsPageSearch: boolean;
    chips: ChipsModel[];
    openSearch: boolean;
    searchText: string;
    searchIsActive: boolean;
    isInputFocused: boolean;
    chipToDelete: number;
    private chipsForHighlightSearch;
    private typingTimeout;
    private destroy$;
    constructor(searchMultipleStatesService: CaSearchMultipleStatesService, elementRef: ElementRef);
    ngOnInit(): void;
    initDeleteAllChipsListener(): void;
    toggleSearch(): void;
    onTyping(event: MouseEvent | KeyboardEvent): void;
    private isKeyboardEvent;
    onEnter(): void;
    private sendHighlightSearchOnTyping;
    private sendHighlightSearchOnEnter;
    handleClearClick(): void;
    private checkChips;
    onDeleteChip(index: number): void;
    deleteAllChips(): void;
    private getChipColor;
    private getChipQuery;
    getSvgPath(propertyName: keyof typeof SearchMultipleStatesRoutes): string;
    capitalizeInput(text: string): void;
    emitSearchEvent(): void;
    onInputFocus(isFocused: boolean): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaSearchMultipleStatesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaSearchMultipleStatesComponent, "app-ca-search-multiple-states", never, { "toolbarSearch": { "alias": "toolbarSearch"; "required": false; }; "selectedTabData": { "alias": "selectedTabData"; "required": false; }; "searchType": { "alias": "searchType"; "required": false; }; "isAlwaysOpenSearch": { "alias": "isAlwaysOpenSearch"; "required": false; }; "isDetailsPageSearch": { "alias": "isDetailsPageSearch"; "required": false; }; }, { "close": "close"; "onSearch": "onSearch"; }, never, never, true, never>;
}

declare enum eSearchMultipleStateAction {
    MAX_ADDED = "Max Added"
}

declare class MultipleSearchStateSvg {
    static SEARCH_ICON: string;
    static CANCEL_ICON: string;
    static CLEAR_ALL_ICON: string;
    static ADD_ICON: string;
}

declare class CaSearchMultipleStates2Component implements OnInit {
    private cdr;
    private elementRef;
    onDocumentClick(event: MouseEvent): void;
    searchInput: ElementRef<HTMLInputElement>;
    constructor(cdr: ChangeDetectorRef, elementRef: ElementRef);
    set selectedTab(value: string);
    set isDetailsPageSearch(value: boolean);
    inputPlaceholder: string;
    isDisabled: boolean;
    onSearchQueryChange: EventEmitter<ISearchQueryItem[]>;
    onToggleSearch: EventEmitter<boolean>;
    readonly SEARCH_LIMIT: number;
    _isDetailsPageSearch: boolean;
    searchQuery: ISearchQueryItem[];
    searchControl: FormControl<eStringPlaceholder | null>;
    _selectedTab: string;
    isSearchActive: boolean;
    eSearchMultipleStateAction: typeof eSearchMultipleStateAction;
    eCommonAction: typeof eGeneralActions;
    ePosition: typeof ePosition;
    eColor: typeof eColor;
    eStringPlaceholder: typeof eStringPlaceholder;
    multipleSearchStateSvg: typeof MultipleSearchStateSvg;
    ngOnInit(): void;
    private focusSearchInput;
    addSearchItem(): void;
    clearAll(): void;
    onClearValuesAction(): void;
    deleteSearchQueryItem(index: number): void;
    removeSearchItem(searchItem: string): void;
    toggleSearch(): void;
    clearSearch(): void;
    resetComponentState(): void;
    resetSearchControl(): void;
    private updateSearchControlDisabled;
    propagateData(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaSearchMultipleStates2Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaSearchMultipleStates2Component, "ca-search-multiple-states-2", never, { "selectedTab": { "alias": "selectedTab"; "required": false; }; "isDetailsPageSearch": { "alias": "isDetailsPageSearch"; "required": false; }; "inputPlaceholder": { "alias": "inputPlaceholder"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; }, { "onSearchQueryChange": "onSearchQueryChange"; "onToggleSearch": "onToggleSearch"; }, never, never, true, never>;
}

interface TableBodyColorLabel {
    code?: string;
    color?: string;
    createdAt?: string;
    hoverCode?: string;
    name?: string;
    updatedAt?: string;
    colorId?: number;
    count?: number;
    id?: number;
}

interface Trucks {
    truckNumber: string;
    status: number;
    owner: string;
    id: number;
    color: {
        companyId: number;
        code: string;
        name: number;
        id: number;
    };
    truckType: {
        id: number;
        companyId: number;
        name: string;
        logoName: string;
    };
}
interface Trailers {
    trailerNumber: string;
    status: number;
    owner: string;
    id: number;
    trailerType: {
        id: number;
        companyId: number;
        name: string;
        logoName: string;
        hasVolume: boolean;
    };
}
interface Rating {
    avatarColor?: {
        background?: string;
        color?: string;
    };
    commentContent?: string;
    companyUser?: {
        id: number;
        avatar?: string;
        fullName?: string;
    };
    date?: string;
    disliked?: boolean;
    liked?: boolean;
    edited?: boolean;
    me?: true;
    textShortName?: string;
}
interface CardDetails {
    tableDOB?: string;
    textShortName?: string;
    avatarColor?: string;
    avatarImg?: string;
    filteredTrucks?: Truck[];
    trailers?: Trailers[];
    truckCount?: number;
    trailerCount?: number;
    descriptionItems?: string[];
    id?: number;
    type?: Type;
    companyContactLabel?: TableBodyColorLabel;
    companyAccountLabel?: TableBodyColorLabel;
    isSelected?: boolean;
    loadNumber?: string;
    statusType?: StatusType;
    status?: number;
    tableDropdownContent?: tableDropdownContent;
    dispatcher?: Dispatcher;
    company?: Company$1;
    dateCreated?: string;
    dispatch?: Dispatch;
    ban?: boolean;
    dnu?: boolean;
    broker?: Broker;
    brokerContact?: BrokerContact;
    referenceNumber?: string;
    generalCommodity?: GeneralCommodity;
    weight?: number;
    loadRequirements?: LoadRequirements;
    stops?: Stop[];
    splitLoad?: SplitLoad;
    note?: string;
    baseRate?: number;
    adjustedRate?: number;
    revisedRate?: number;
    tonuRate?: number;
    driverRate?: number;
    additionalBillingRatesTotal?: number;
    additionalBillingRates?: AdditionalBillingRate[];
    totalRate?: number;
    totalAdjustedRate?: number;
    advancePay?: number;
    pays?: Pay[];
    statusHistory?: StatusHistory[];
    commentsCount?: number;
    comments?: Comment[];
    totalPaid?: number;
    totalDue?: number;
    loadedMiles?: number;
    totalMiles?: number;
    totalTimeDays?: number;
    totalTimeHours?: number;
    paidDate?: string;
    invoicedDate?: string;
    shortPaid?: number;
    age?: number;
    daysToPay?: number;
    totalLoadTime?: TotalLoadTime;
    firstPickupTime?: FirstPickupTime;
    lastDeliveryTime?: LastDeliveryTime;
    currentLocation?: CurrentLocation;
    nextStop?: NextStop;
    trucks?: Trucks[];
    completedPercentage?: number;
    pendingPercentage?: number;
    closedPercentage?: number;
    progressBar?: ProgressBar[];
    createdAt?: string;
    updatedAt?: string;
    files?: File$1[];
    fileCount?: number;
    loadTotal?: LoadTotal;
    isFlipped?: boolean;
    items?: {
        description?: string;
        id?: number;
        pmTrailer?: string;
        pmTruck?: string;
        price?: number;
        quantity?: number;
        subtotal?: number;
    };
    rating?: Rating[];
    textCommodity?: string;
    textMiles?: string;
    textWeight?: string;
    textBase?: string;
    textAdditional?: string;
    textAdvance?: string;
    textPayTerms?: string;
    textDriver?: string;
    tableAttachments?: File$1[];
    acCompressor?: PmTruckProgressData;
    airCompressor?: PmTruckProgressData;
    airFilter?: PmTruckProgressData;
    alignment?: PmTruckProgressData | PmTrailerProgressData;
    battery?: PmTruckProgressData;
    belts?: PmTruckProgressData;
    brakeChamber?: PmTruckProgressData;
    engTuneUp?: PmTruckProgressData;
    fuelPump?: PmTruckProgressData;
    oilFilter?: PmTruckProgressData;
    oilPump?: PmTruckProgressData;
    radiator?: PmTruckProgressData;
    transFluid?: PmTruckProgressData;
    turbo?: PmTruckProgressData;
    waterPump?: PmTruckProgressData;
    general?: PmTrailerProgressData;
    ptoPump?: PmTrailerProgressData;
    reeferUnit?: PmTrailerProgressData;
    truck?: TruckMinimalResponse;
    trailer?: TrailerMinimalResponse;
    pmId?: number;
    businessName?: string;
    billingAddress?: Address;
    address?: Address;
    fullName?: string;
    cost?: number;
    textInv?: string;
    textRepairShop?: string;
    textOdometer?: string;
    lastService?: string;
    creditLimit?: number;
}
interface PmTruckProgressData {
    expirationMiles?: number;
    expirationMilesText?: string;
    percentage: number;
    totalValueText: string;
    expirationCreditText?: string;
    expirationDaysText?: string;
}
interface PmTrailerProgressData {
    expirationDays?: number;
    expirationDaysText?: string;
    percentage: number;
    totalValueText: string;
    expirationCreditText?: string;
    expirationMilesText?: string;
}
interface tableDropdownContent {
    content: DropdownItem[];
    hasContent: boolean;
}
interface DropdownItem {
    title?: string;
    name?: string;
    svgUrl?: string;
    class?: string;
    mutedStyle?: boolean;
    contentType?: string;
    text?: string;
    svgStyle?: {
        width: number;
        height: number;
    };
    svgClass?: string;
    isDropdown?: boolean;
    hasBorder?: boolean;
    isDisabled?: boolean;
    tableListDropdownContentStyle?: {
        [key: string]: any;
    };
    insideDropdownContent?: InsideDropdownContent[];
    svg?: string;
    show?: boolean;
    iconName?: string;
    type?: string;
    danger?: boolean;
    redIcon?: boolean;
}
interface InsideDropdownContent {
    title: string;
    name: string;
}
interface Type {
    name: string;
    id: number;
}
interface LoadTotal {
    total: string;
    subTotal: string;
}
interface StatusType {
    name: string;
    id: number;
}
interface Dispatcher {
    id: number;
    fullName: string;
    avatar: string;
    departmentId: number;
}
interface Company$1 {
    id: number;
    companyName: string;
    logo: string;
    isDivision: boolean;
    isActive: boolean;
    lastLogin: string;
}
interface Dispatch {
    id: number;
    dispatchBoardId: number;
    dispatcherId: number;
    truck: Truck;
    trailer: Trailer;
    driver: Driver;
    coDriver: CoDriver;
}
interface Truck {
    id: number;
    truckNumber: string;
    status: number;
    owner: string;
    color: Color;
    truckType: TruckType;
}
interface Color {
    id: number;
    companyId: number;
    name: string;
    code: string;
}
interface TruckType {
    id: number;
    companyId: number;
    name: string;
    logoName: string;
}
interface Trailer {
    id: number;
    trailerNumber: string;
    status: number;
    owner: string;
    trailerType: TrailerType;
}
interface TrailerType {
    id: number;
    companyId: number;
    name: string;
    logoName: string;
    hasVolume: boolean;
}
interface Driver {
    id: number;
    firstName: string;
    lastName: string;
    owner: number;
    status: number;
    avatar: string;
}
interface CoDriver {
    id: number;
    firstName: string;
    lastName: string;
    owner: number;
    status: number;
    avatar: string;
}
interface Broker {
    id: number;
    businessName: string;
    availableCredit: number;
    availableCreditType: AvailableCreditType;
    payTerm: PayTerm;
    dnu: boolean;
    ban: boolean;
}
interface AvailableCreditType {
    name: string;
    id: number;
}
interface PayTerm {
    name: string;
    id: number;
}
interface BrokerContact {
    id: number;
    brokerId: number;
    email: string;
    phone: string;
    contactName: string;
    department: Department$1;
    extensionPhone: string;
}
interface Department$1 {
    id: number;
    name: string;
}
interface GeneralCommodity {
    name: string;
    id: number;
}
interface LoadRequirements {
    id: number;
    truckType: TruckType2;
    trailerType: TrailerType2;
    doorType: DoorType;
    suspension: Suspension;
    trailerLength: TrailerLength;
    year: number;
    liftgate: boolean;
    driverMessage: string;
}
interface TruckType2 {
    id: number;
    companyId: number;
    name: string;
    logoName: string;
}
interface TrailerType2 {
    id: number;
    companyId: number;
    name: string;
    logoName: string;
    hasVolume: boolean;
}
interface DoorType {
    name: string;
    id: number;
}
interface Suspension {
    name: string;
    id: number;
}
interface TrailerLength {
    id: number;
    companyId: number;
    name: string;
}
interface Stop {
    id: number;
    stopType: StopType;
    stopOrder: number;
    stopLoadOrder: number;
    shipper: Shipper;
    shipperContact: ShipperContact;
    dateFrom: string;
    dateTo: string;
    timeType: TimeType;
    timeFrom: string;
    timeTo: string;
    arrive: string;
    depart: string;
    wait: Wait;
    items: Item[];
    milesType: MilesType;
    legMiles: number;
    legHours: number;
    legMinutes: number;
    shape: string;
}
interface StopType {
    name: string;
    id: number;
}
interface Shipper {
    id: number;
    businessName: string;
    address: Address;
    longitude: number;
    latitude: number;
}
interface Address {
    city: string;
    state: string;
    county: string;
    address: string;
    street: string;
    streetNumber: string;
    country: string;
    zipCode: string;
    stateShortName: string;
    addressUnit: string;
}
interface ShipperContact {
    id: number;
    shipperId: number;
    phone: string;
    contactName: string;
    extensionPhone: string;
}
interface TimeType {
    name: string;
    id: number;
}
interface Wait {
    additionalProp1: number;
    additionalProp2: number;
    additionalProp3: number;
}
interface Item {
    id: number;
    bolNumber: string;
    appointmentNumber: string;
    pickupNumber: string;
    poNumber: string;
    sealNumber: string;
    weight: number;
    length: number;
    height: number;
    temperature: number;
    description: string;
    code: string;
    quantity: number;
    units: Units;
    secure: Secure;
    tarp: Tarp;
    stackable: Stackable;
    driverAssist: DriverAssist;
    hazardousMaterial: HazardousMaterial;
}
interface Units {
    name: string;
    id: number;
}
interface Secure {
    name: string;
    id: number;
}
interface Tarp {
    name: string;
    id: number;
}
interface Stackable {
    name: string;
    id: number;
}
interface DriverAssist {
    name: string;
    id: number;
}
interface HazardousMaterial {
    id: number;
    class: number;
    division: number;
    group: string;
    description: string;
    notes: string;
    logoName: string;
}
interface MilesType {
    name: string;
    id: number;
}
interface SplitLoad {
    id: number;
    previousStopOrder: number;
    nextStopOrder: number;
    splitDate: string;
    splitTime: string;
    splitLocation: SplitLocation;
    newDispatch: NewDispatch;
    rateFirstLoad: number;
    rateSecondLoad: number;
    firstLegMiles: number;
    secondLegMiles: number;
    createdAt: string;
    updatedAt: string;
}
interface SplitLocation {
    city: string;
    state: string;
    county: string;
    address: string;
    street: string;
    streetNumber: string;
    country: string;
    zipCode: string;
    stateShortName: string;
    addressUnit: string;
}
interface NewDispatch {
    id: number;
    dispatchBoardId: number;
    dispatcherId: number;
    truck: Truck2;
    trailer: Trailer2;
    driver: Driver2;
    coDriver: CoDriver2;
}
interface Truck2 {
    id: number;
    truckNumber: string;
    status: number;
    owner: string;
    color: Color2;
    truckType: TruckType3;
}
interface Color2 {
    id: number;
    companyId: number;
    name: string;
    code: string;
}
interface TruckType3 {
    id: number;
    companyId: number;
    name: string;
    logoName: string;
}
interface Trailer2 {
    id: number;
    trailerNumber: string;
    status: number;
    owner: string;
    trailerType: TrailerType3;
}
interface TrailerType3 {
    id: number;
    companyId: number;
    name: string;
    logoName: string;
    hasVolume: boolean;
}
interface Driver2 {
    id: number;
    firstName: string;
    lastName: string;
    owner: number;
    status: number;
    avatar: string;
}
interface CoDriver2 {
    id: number;
    firstName: string;
    lastName: string;
    owner: number;
    status: number;
    avatar: string;
}
interface AdditionalBillingRate {
    id: number;
    additionalBillingType: AdditionalBillingType;
    rate: number;
}
interface AdditionalBillingType {
    name: string;
    id: number;
}
interface Pay {
    id: number;
    paymentType: PaymentType;
    pay: number;
    payDate: string;
}
interface PaymentType {
    name: string;
    id: number;
}
interface StatusHistory {
    status: Status2;
    updatedAt: string;
}
interface Status2 {
    name: string;
    id: number;
}
interface Comment {
    id?: number;
    companyUser?: CompanyUser$1;
    entityTypeComment?: EntityTypeComment;
    commentContent?: string;
    downRatingCount?: number;
    upRatingCount?: number;
    currentCompanyUserRating?: number;
    createdAt?: string;
    updatedAt?: string;
    userAvatar?: string;
    fullName?: string;
    avatarColor?: {
        background?: string;
        color?: string;
    };
    cardId?: number;
    textShortName?: string;
    date?: string;
    edited?: boolean;
    comment?: string;
    isOpen?: boolean;
    entityTypeId?: number;
}
interface CompanyUser$1 {
    id?: number;
    fullName?: string;
    avatar?: string;
    departmentId?: number;
}
interface EntityTypeComment {
    name: string;
    id: number;
}
interface TotalLoadTime {
    additionalProp1: number;
    additionalProp2: number;
    additionalProp3: number;
}
interface FirstPickupTime {
    additionalProp1: number;
    additionalProp2: number;
    additionalProp3: number;
}
interface LastDeliveryTime {
    additionalProp1: number;
    additionalProp2: number;
    additionalProp3: number;
}
interface CurrentLocation {
    city: string;
    state: string;
    county: string;
    address: string;
    street: string;
    streetNumber: string;
    country: string;
    zipCode: string;
    stateShortName: string;
    addressUnit: string;
}
interface NextStop {
    id: number;
    stopType: StopType2;
    stopOrder: number;
    stopLoadOrder: number;
    shipper: Shipper2;
    shipperContact: ShipperContact2;
    dateFrom: string;
    dateTo: string;
    timeType: TimeType2;
    timeFrom: string;
    timeTo: string;
    arrive: string;
    depart: string;
    wait: Wait2;
    items: Item2[];
    milesType: MilesType2;
    legMiles: number;
    legHours: number;
    legMinutes: number;
    shape: string;
}
interface StopType2 {
    name: string;
    id: number;
}
interface Shipper2 {
    id: number;
    businessName: string;
    address: Address2;
    longitude: number;
    latitude: number;
}
interface Address2 {
    city: string;
    state: string;
    county: string;
    address: string;
    street: string;
    streetNumber: string;
    country: string;
    zipCode: string;
    stateShortName: string;
    addressUnit: string;
}
interface ShipperContact2 {
    id: number;
    shipperId: number;
    phone: string;
    contactName: string;
    extensionPhone: string;
}
interface TimeType2 {
    name: string;
    id: number;
}
interface Wait2 {
    additionalProp1: number;
    additionalProp2: number;
    additionalProp3: number;
}
interface Item2 {
    id: number;
    bolNumber: string;
    appointmentNumber: string;
    pickupNumber: string;
    poNumber: string;
    sealNumber: string;
    weight: number;
    length: number;
    height: number;
    temperature: number;
    description: string;
    code: string;
    quantity: number;
    units: Units2;
    secure: Secure2;
    tarp: Tarp2;
    stackable: Stackable2;
    driverAssist: DriverAssist2;
    hazardousMaterial: HazardousMaterial2;
}
interface Units2 {
    name: string;
    id: number;
}
interface Secure2 {
    name: string;
    id: number;
}
interface Tarp2 {
    name: string;
    id: number;
}
interface Stackable2 {
    name: string;
    id: number;
}
interface DriverAssist2 {
    name: string;
    id: number;
}
interface HazardousMaterial2 {
    id: number;
    class: number;
    division: number;
    group: string;
    description: string;
    notes: string;
    logoName: string;
}
interface MilesType2 {
    name: string;
    id: number;
}
interface ProgressBar {
    loadStopId: number;
    stopType: StopType3;
    totalLegMiles: number;
    progressBarPercentage: number;
}
interface StopType3 {
    name: string;
    id: number;
}
interface File$1 {
    fileId: number;
    fileName: string;
    url: string;
    fileSize: number;
    tags: string[];
    tagGeneratedByUser: boolean;
}

declare class TableCardViewSvgRoutes {
    static flipArrowRoute: string;
}

declare enum eTableCardTypes {
    FRONT = "FRONT",
    BACK = "BACK"
}

declare enum eTableCardGeneral {
    FLIP_CARD = "Flip Card",
    VIEW_DETAILS = "View Details"
}

declare class CaTableCardViewSkeletonComponent {
    cardsCount: number;
    placeholders: QueryList<ElementRef>;
    tableCardViewSvgRoutes: typeof TableCardViewSvgRoutes;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaTableCardViewSkeletonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaTableCardViewSkeletonComponent, "ca-table-card-view-skeleton", never, { "cardsCount": { "alias": "cardsCount"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaTableCardViewComponent<T> implements OnInit, AfterViewInit, OnDestroy {
    private renderer;
    onResize(): void;
    cardBodyContents: QueryList<ElementRef>;
    showMoreContainer: ElementRef;
    cardsContainer: ElementRef;
    skeletonLoader: CaTableCardViewSkeletonComponent;
    set frontSide(value: TemplateRef<{
        data: T;
    }>);
    set backSide(value: TemplateRef<{
        data: T;
    }>);
    set titleIcon(value: TemplateRef<{
        data: T;
    }>);
    set rightSideTemplate(value: TemplateRef<{
        data: T;
    }>);
    set viewData(value: T[]);
    set cardTitle(value: string);
    set isLoading(value: boolean);
    set searchStrings(value: ISearchQueryItem[]);
    totalDataCount: number;
    cardsFlipType: string;
    isDropdownMenuHidden: boolean;
    isSelectHidden: boolean;
    isBannerVisible: boolean;
    showBackSide: boolean;
    dropdownMenuOptions: IDropdownMenuItem[];
    hasDetailsPage: boolean;
    isCardSortingActive: boolean;
    showMore: EventEmitter<void>;
    selectCard: EventEmitter<number>;
    cardTitleClick: EventEmitter<number>;
    finishOrder: EventEmitter<number>;
    dropdownOptionEmitter: EventEmitter<TableCardBodyActions<CardDetails>>;
    _searchStrings: ISearchQueryItem[];
    _cardTitle: string;
    _isLoading: boolean;
    _viewData: T[];
    _frontSide: TemplateRef<{
        data: T;
    }>;
    _backSide: TemplateRef<{
        data: T;
    }>;
    _titleIcon: TemplateRef<{
        data: T;
    }>;
    _rightSideTemplate: TemplateRef<{
        data: T;
    }>;
    isCardFlippedCheckInCards: number[];
    private deferObserver?;
    tableCardViewSvgRoutes: typeof TableCardViewSvgRoutes;
    tableCardTypes: typeof eTableCardTypes;
    ePosition: typeof ePosition;
    eColor: typeof eColor;
    eTableCardGeneral: typeof eTableCardGeneral;
    eStringPlaceholder: typeof eStringPlaceholder;
    private copyHandler;
    constructor(renderer: Renderer2);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private handleCopyEvent;
    private adjustShowMoreWidth;
    private waitForCardsContainerAndCalculate;
    private disconnectDeferObserver;
    private calculateAndSetup;
    handleToggleDropdownMenuActions(event: IDropdownMenuOptionEmit, card: CardDetails): void;
    flipCard(index: number): void;
    onCheckboxSelect(id: number): void;
    cardTitleClicked(id: number): void;
    onShowMoreClick(): void;
    repairFinishOrder(id: number): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaTableCardViewComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaTableCardViewComponent<any>, "ca-table-card-view", never, { "frontSide": { "alias": "frontSide"; "required": false; }; "backSide": { "alias": "backSide"; "required": false; }; "titleIcon": { "alias": "titleIcon"; "required": false; }; "rightSideTemplate": { "alias": "rightSideTemplate"; "required": false; }; "viewData": { "alias": "viewData"; "required": false; }; "cardTitle": { "alias": "cardTitle"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "searchStrings": { "alias": "searchStrings"; "required": false; }; "totalDataCount": { "alias": "totalDataCount"; "required": false; }; "cardsFlipType": { "alias": "cardsFlipType"; "required": false; }; "isDropdownMenuHidden": { "alias": "isDropdownMenuHidden"; "required": false; }; "isSelectHidden": { "alias": "isSelectHidden"; "required": false; }; "isBannerVisible": { "alias": "isBannerVisible"; "required": false; }; "showBackSide": { "alias": "showBackSide"; "required": false; }; "dropdownMenuOptions": { "alias": "dropdownMenuOptions"; "required": false; }; "hasDetailsPage": { "alias": "hasDetailsPage"; "required": false; }; "isCardSortingActive": { "alias": "isCardSortingActive"; "required": false; }; }, { "showMore": "showMore"; "selectCard": "selectCard"; "cardTitleClick": "cardTitleClick"; "finishOrder": "finishOrder"; "dropdownOptionEmitter": "dropdownOptionEmitter"; }, never, never, true, never>;
}

declare class CaSpinnerComponent implements OnChanges {
    size?: string;
    color?: string;
    isBarSpinner?: boolean;
    lottieSpinner: {
        path: string;
    };
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    getLottieSpinner(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaSpinnerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaSpinnerComponent, "app-ca-spinner", never, { "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "isBarSpinner": { "alias": "isBarSpinner"; "required": false; }; }, {}, never, never, true, never>;
}

interface ImageAvatar {
    indx: number;
    textShortName: string;
    avatarColor: {
        background?: string;
        color?: string;
    };
}

interface ToDoCardConfig {
    title: string;
    department: string;
    assigment: string[];
    description: string;
    link: string;
    imageProfiles?: ImageAvatar[];
}

interface CommentConfig {
    user: {
        avatarImage: string;
        name: string;
    };
    owner: boolean;
    id?: number;
    createdAt?: Date;
    updatedAt?: Date;
    content: string;
}

interface ProgressExpirationColor {
    primary: string;
    secondary: string;
}

type ProgressExpirationTemplate = 'todo-list' | 'details' | 'settings-insurance-policy' | 'settings-parking' | 'location';

type ProgressExpirationTheme = 'light' | 'dark';

interface ProgressExpirationTitle {
    before: string;
    days: string;
    after: string;
}

type ProgressExpirationType = 'small' | 'big';

interface ProgressExpiration {
    template: ProgressExpirationTemplate;
    expireDate: Date;
    completedDate?: Date;
    startDate?: Date;
    customTitle?: string;
    type?: ProgressExpirationType;
    theme?: ProgressExpirationTheme;
    rent?: number;
}

interface IDropBackgroundEvent {
    action: string;
    value: boolean;
}

declare enum eFileDropZoneAction {
    ADD = "add",
    DROP = "drop",
    DRAGOVER = "dragover",
    DRAGLEAVE = "dragleave"
}

declare enum eDropZoneFileType {
    FILES = "files",
    MEDIA = "media",
    IMAGE = "image",
    LOGO = "logo"
}

declare enum eFileUploadPage {
    LIST_LOAD = "list_load",
    LIST_CUSTOMER = "list_customer",
    LIST_DRIVER = "list_driver",
    CDL = "cdl",
    MEDICAL = "medical",
    MVR = "mvr",
    TEST = "test",
    LIST_TRUCK = "list_truck",
    REGISTRATION = "registration",
    INSPECTION = "inspection",
    TITLE = "title",
    LEASE_RENT = "lease_rent",
    LEASE_PURCHASE = "lease_purchase",
    LIST_REPAIR_TRUCK_TRAILER = "list_repair_truck_trailer",
    LIST_REPAIR_SHOP = "list_repair_shop",
    LIST_FUEL = "list_fuel",
    LIST_OWNER = "list_owner",
    SAFETY_ROADSIDE_INSPECTION = "safety_roadside_inspection",
    SAFETY_ROADSIDE_INSPECTION_CITATION = "safety_roadside_inspection_citation",
    SAFETY_ACCIDENT = "safety_accident",
    SAFETY_ACCIDENT_CITATION = "safety_accident_citation",
    TOOLS_TODO = "tools_todo",
    FAX = "fax",
    INSURANCE_COMPANY = "insurance_company"
}

declare enum eTemplateType {
    DOCUMENTS = "documentsTemplate",
    MEDIA = "mediaTemplate",
    IMAGE = "imageTemplate",
    IMAGE_CROP = "imageCropTemplate",
    LOGO = "logoTemplate"
}

interface IDropZoneSettings {
    dropZoneType?: eDropZoneFileType;
    dropZoneAvailableFiles?: string;
    multiple?: boolean;
    globalDropZone?: boolean;
    dropZonePages?: string;
}

interface IDropZoneOptionConfig {
    customClassName?: string;
    size?: string;
    modalSize?: string;
    filesLength?: number;
    disableUnsupportedPreview?: boolean;
    isRequired?: boolean;
    showRequired?: boolean;
    dropzoneClose?: boolean;
    dropzoneFocus?: boolean;
    dropzoneColumn?: boolean;
    dropzoneIndex?: number;
    showDropzone?: boolean;
}

interface IFileConfig {
    fileId?: number;
    name?: any;
    fileName?: string;
    url: string | any;
    extension?: string;
    guid?: string | null;
    size?: number;
    fileSize?: number;
    tags?: any;
    realFile?: File | any;
    tagId?: any;
    incorrect?: boolean;
    tagChanged?: boolean;
    savedTag?: any;
    tagGeneratedByUser?: boolean;
    lastHovered?: boolean;
    page?: string;
}

interface IFileEvent {
    files: IFileConfig[] | IFileConfig;
    action: string;
    deleteId?: number;
    index?: number;
    type?: string;
}

interface IDropZoneConfig {
    template: eTemplateType;
    config?: {
        dropzone?: IDropZoneSettings;
        dropzoneOption?: IDropZoneOptionConfig;
    };
}

interface IDocumentReviewInputEvent {
    file: IFileConfig;
    message: string;
}

interface IFileOptionConfig {
    id: number;
    customClassName?: string;
    url?: string;
    file: IFileConfig;
    hasTagsDropdown?: boolean;
    hasNumberOfPages?: boolean;
    activePage?: number;
    type?: string;
    hasLandscapeOption?: boolean;
    tagsOptions?: any[];
    tags?: any[];
}

declare enum eFileType {
    MODAL = "modal",
    TABLE = "table",
    DETAILS = "details",
    TODO = "todo"
}

declare enum eFileSize {
    SMALL = "small",
    MEDIUM = "medium",
    LARGE = "large",
    MODAL_LARGE = "modal-large",
    MODAL_MEDIUM = "modal-medium"
}

declare enum eFileAction {
    ADD = "add",
    REPLACE = "replace",
    DELETE = "delete"
}

declare enum eReviewState {
    REVIEW_MODE = "REVIEW_MODE",
    FEEDBACK_MODE = "FEEDBACK_MODE"
}

interface IReviewFileConfig {
    isReview?: boolean;
    reviewMode?: eReviewState;
    feedbackText?: string;
    categoryTag?: string;
    isFooterHidden?: boolean;
    isActionsHidden?: boolean;
}

interface ISlider {
    dontUseSlider: boolean;
    hasCarouselBottomTabs: boolean;
}

interface IFilesCarouselConfig {
    files: any[];
    customClass: string;
    customDetailsPageClass?: string;
    hasCarouselBottomTabs?: boolean;
    size?: string | undefined;
}

interface IUploadFilesConfig {
    files: IFileConfig[];
    slider: ISlider;
    carouselConfig: IFilesCarouselConfig;
    hasCrop: boolean;
    isRoundCrop: boolean;
    hasBlobUrl: boolean;
    onlyOneTagFile?: boolean;
    dropZoneConfig: IDropZoneConfig;
    dropzoneCustomWidth: string;
    isVisibleCropAndDrop: boolean;
    initialCropperPosition: CropperPosition;
    containWithinAspectRatio: boolean;
    aspectRatio: number[];
    review: IReviewFileConfig;
    fileOptionsConfig: IFileOptionConfig;
    size: eFileSize;
    slideWidth: number;
}

interface ToDoConfig {
    id: number;
    config: ToDoCardConfig;
    commentConfig: CommentConfig[];
    newCommentConfig: CommentConfig[];
    configProgress?: ProgressExpiration[];
    uploadFilesConfig: IUploadFilesConfig;
}

interface IToDoColumn {
    id: string;
    title: string;
    toDoConfigs: ToDoConfig[];
}

declare class CaTodoComponent {
    private cdr;
    todoConfigs: ToDoConfig[];
    inProgressConfigs: ToDoConfig[];
    completedConfigs: ToDoConfig[];
    columns: IToDoColumn[];
    constructor(cdr: ChangeDetectorRef);
    ngOnInit(): void;
    onDrop(event: CdkDragDrop<any[]>): void;
    private initializeColumn;
    private updateTodoStates;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaTodoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaTodoComponent, "app-ca-todo", never, { "todoConfigs": { "alias": "todoConfigs"; "required": false; }; "inProgressConfigs": { "alias": "inProgressConfigs"; "required": false; }; "completedConfigs": { "alias": "completedConfigs"; "required": false; }; }, {}, never, never, true, never>;
}

interface ProgressDropdownData {
    row: CardDetails;
    column: PmTruckProgressData | PmTrailerProgressData;
}

declare class CaTruckTrailerProgresBarComponent {
    type: string;
    text: string | number;
    percents: number;
    data: any;
    columnField: string;
    isTable: boolean;
    daysExpired: boolean;
    daysToPay: number;
    hasPopover: boolean;
    pmName: string;
    progressDropdownActive: number;
    progressDropdownColumnActive: string | any;
    progressDropdownData: ProgressDropdownData;
    isOpenPopup: boolean;
    get daysPluralization(): string;
    toggleProgressDropdown(tooltip: NgbPopover): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaTruckTrailerProgresBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaTruckTrailerProgresBarComponent, "app-ca-truck-trailer-progress-bar", never, { "type": { "alias": "type"; "required": false; }; "text": { "alias": "text"; "required": false; }; "percents": { "alias": "percents"; "required": false; }; "data": { "alias": "data"; "required": false; }; "columnField": { "alias": "columnField"; "required": false; }; "isTable": { "alias": "isTable"; "required": false; }; "daysExpired": { "alias": "daysExpired"; "required": false; }; "daysToPay": { "alias": "daysToPay"; "required": false; }; "hasPopover": { "alias": "hasPopover"; "required": false; }; "pmName": { "alias": "pmName"; "required": false; }; }, {}, never, never, true, never>;
}

declare enum PayrollTypeEnum {
    MILEAGE = "MILEAGE",
    COMMISSION = "COMMISSION",
    FLAT_RATE = "FLAT_RATE",
    OWNER_COMMISSION = "OWNER"
}
declare enum userInfoEnum {
    SHORT_PAID = "SHORT PAID",
    CLOSED_UNPAID = "CLOSED UNPAID",
    PAID_IN_FULL = "PAID IN FULL",
    READY_IN_DAYS = "READY IN 444 DAYS",
    READY_TO_PROCESS = "READY TO PROCESS",
    DAYS_OVERDUE = "444 DAYS OVERDUE"
}

declare enum ePeriodTitleType {
    FUEL = "Fuel",
    CREDIT = "Credit",
    DEDUCTION = "Deduction",
    PAYMENT = "Payment",
    BONUS = "Bonus"
}

interface PayrollReportTableResponse {
    id?: number;
    description?: string | null;
    subtotal?: number;
    date?: string;
    recurring?: boolean;
    currentRecurrance?: number | null;
    reorderItem?: boolean;
}

interface PayrollReport {
    id?: number;
    fullName: string;
    userId: number;
    avatar: string | null;
    periodStart?: string;
    periodEnd?: string;
    payrollNumber?: string | null;
    daysUntilPayment: number;
    mileagePay?: number;
    earnings?: number;
    flatPay?: number;
    salary?: number | null;
    extraStopPay?: number;
    extraStopCount?: number;
    loadCount?: number;
    payrollDeadLine: {
        numberOfDays: number;
        period: string;
    };
    perMilesEntity?: {
        emptyMile: number;
        loadedMile: number;
        perStop: number;
    };
    includedDeductions?: Array<PayrollReportTableResponse> | null;
    excludedDeductions?: Array<PayrollReportTableResponse> | null;
    totalDeduction?: number;
    includedCredits?: Array<PayrollReportTableResponse> | null;
    excludedCredits?: Array<PayrollReportTableResponse> | null;
    totalCredits?: number;
    includedBonuses?: Array<PayrollReportTableResponse> | null;
    excludedBonuses?: Array<PayrollReportTableResponse> | null;
    totalBonus?: number;
    includedLoads?: Array<PayrollLoadMinimalResponse> | null;
    excludedLoads?: Array<PayrollLoadMinimalResponse> | null;
    includedFuels?: Array<PayrollReportTableResponse> | null;
    excludedFuels?: Array<PayrollReportTableResponse> | null;
    mapLocations?: Array<any> | null;
    sums?: any | null;
    payments?: Array<PayrollReportTableResponse> | null;
    status: {
        name: string;
        id: number;
    };
    debt: number;
}

declare class CaPeriodContentComponent {
    isOpen: boolean;
    type: PayrollTypeEnum;
    componentData: PayrollReport;
    reorderedDataEmiter: EventEmitter<{
        _included: PayrollReportTableResponse[];
        _title: string;
    }>;
    openModalEmiter: EventEmitter<string>;
    openActionEditItems: EventEmitter<any>;
    proccessPayroll: EventEmitter<PayrollReport>;
    salary: number;
    totalEarnings: number;
    debt: number;
    debtTitle: string;
    isInDebt?: boolean;
    paymentStatus: string;
    driverInfo: DriverInfo;
    extraPayments: ExtraPayments;
    ngOnInit(): void;
    constructor();
    processPayment(): void;
    addPayment(): void;
    getReorderedData(data: {
        _included: PayrollReportTableResponse[];
        _title: string;
    }): void;
    openAddNewModal(type: any): void;
    handleOpenEditEntryItem(item: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaPeriodContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaPeriodContentComponent, "app-ca-period-content", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "type": { "alias": "type"; "required": false; }; "componentData": { "alias": "componentData"; "required": false; }; }, { "reorderedDataEmiter": "reorderedDataEmiter"; "openModalEmiter": "openModalEmiter"; "openActionEditItems": "openActionEditItems"; "proccessPayroll": "proccessPayroll"; }, never, never, true, never>;
}

declare class CaInputNoteComponent implements ControlValueAccessor {
    noteRef: ElementRef | undefined;
    noteContainer: CaNoteContainerComponent;
    set note(value: string);
    set isVisibleNote(value: boolean);
    isBlankNote: boolean;
    noteType: string;
    entityId: number;
    entityType: string;
    hasDefArrow: boolean;
    isVisibleArrow: boolean;
    noteLabel: string;
    placeholder: string;
    isReadOnly: boolean;
    customClass: string;
    styledValueEmitter: EventEmitter<string>;
    saveNoteEmitter: EventEmitter<string>;
    _isVisibleNote: boolean | string;
    selectionTaken: Selection;
    range: Range;
    private isValue;
    showNote: string;
    value: string;
    isFocused: boolean;
    private blurNoteTimeout;
    noActive: string;
    isSavingNote: boolean;
    private saveInterval;
    private isSaveIntervalStarted;
    savedValue: string;
    private onChange;
    private onTouched;
    constructor();
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    openNote(): void;
    checkFocus(): void;
    changeValue(event: Event): void;
    saveNote(allowSave?: boolean): void;
    stopBlurRemoveTimeout(): void;
    checkActiveItems(): void;
    prepareForTextRange(): void;
    updateNote(): void;
    onPaste(event: ClipboardEvent): void;
    getSvgPath(propertyName: keyof typeof SvgRoutes): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaInputNoteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaInputNoteComponent, "app-ca-input-note", never, { "note": { "alias": "note"; "required": false; }; "isVisibleNote": { "alias": "isVisibleNote"; "required": false; }; "isBlankNote": { "alias": "isBlankNote"; "required": false; }; "noteType": { "alias": "noteType"; "required": false; }; "entityId": { "alias": "entityId"; "required": false; }; "entityType": { "alias": "entityType"; "required": false; }; "hasDefArrow": { "alias": "hasDefArrow"; "required": false; }; "isVisibleArrow": { "alias": "isVisibleArrow"; "required": false; }; "noteLabel": { "alias": "noteLabel"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "isReadOnly": { "alias": "isReadOnly"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; }, { "styledValueEmitter": "styledValueEmitter"; "saveNoteEmitter": "saveNoteEmitter"; }, never, never, true, never>;
}

declare enum InputAddressCommandsStringEnum {
    CONFIRM = "confirm",
    CANCEL = "cancel",
    ENTER = "Enter",
    ESCAPE = "Escape"
}

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 LongLat {
    latitude?: number;
    longitude?: number;
}

type InputAddressCommandsString = 'confirm' | 'cancel' | 'Enter' | 'Escape';

interface AddressData {
    address: AddressEntity;
    longLat?: LongLat;
    valid: boolean;
    type?: InputAddressCommandsStringEnum | InputAddressCommandsString;
    isParking?: boolean;
}

interface AddressList {
    id?: number;
    name?: string;
    address?: string;
    parkingAddress?: any;
}

interface CommandProperties {
    popup: {
        name: string;
        backgroundColor: string;
    };
    svg: string;
}

interface CommandsHandler {
    commands: {
        firstCommand: CommandProperties;
        secondCommand: CommandProperties;
    };
}

type AutocompleteSearchLayer = 'Venue' | 'Address' | 'Street' | 'Neighbourhood' | 'Borough' | 'LocalAdmin' | 'Locality' | 'County' | 'MacroCounty' | 'Region' | 'MacroRegion' | 'Country' | 'Coarse' | 'PostalCode';
declare const AutocompleteSearchLayer: {
    Venue: AutocompleteSearchLayer;
    Address: AutocompleteSearchLayer;
    Street: AutocompleteSearchLayer;
    Neighbourhood: AutocompleteSearchLayer;
    Borough: AutocompleteSearchLayer;
    LocalAdmin: AutocompleteSearchLayer;
    Locality: AutocompleteSearchLayer;
    County: AutocompleteSearchLayer;
    MacroCounty: AutocompleteSearchLayer;
    Region: AutocompleteSearchLayer;
    MacroRegion: AutocompleteSearchLayer;
    Country: AutocompleteSearchLayer;
    Coarse: AutocompleteSearchLayer;
    PostalCode: AutocompleteSearchLayer;
};

interface SentAddressData {
    query: string;
    searchLayers: AutocompleteSearchLayer[];
    closedBorder: boolean;
}

interface AddressListResponse {
    addresses?: Array<string> | null;
}

declare class CaInputAddressDropdownComponent implements OnInit, ControlValueAccessor, OnDestroy {
    superControl: NgControl;
    private ref;
    inputDropdown: CaInputDropdownComponent;
    set placeholderType(value: string);
    set activeAddress(value: AddressList | null);
    set receivedAddressData(value: AddressData | null);
    set receivedAddressList(value: AddressListResponse | null);
    set parkingList(value: any[]);
    sentAddressValue: EventEmitter<string>;
    inputConfig: ICaInput$1;
    commandHandler: CommandsHandler;
    isRouting: boolean;
    closedBorder: boolean;
    incorrectValue: boolean;
    hideEmptyLoaded: boolean;
    addresList: AddressList[];
    template: string;
    selectedAddress: EventEmitter<AddressData>;
    sentAddressData: EventEmitter<SentAddressData>;
    closeDropdown: EventEmitter<boolean>;
    commandEvent: EventEmitter<AddressData | {}>;
    changeFlag: EventEmitter<boolean>;
    incorrectEvent: EventEmitter<boolean>;
    handleKeyboardEvent(event: KeyboardEvent): void;
    private searchLayers;
    currentAddressData: AddressData | null;
    addressExpanded: boolean;
    chosenFromDropdown: boolean;
    private allowValidation;
    stopType: string;
    private requestSent;
    _receivedAddressList: AddressListResponse | null;
    _activeAddress: AddressList | null;
    _parkingList: any;
    private destroy$;
    addressForm: UntypedFormGroup;
    isParkingAddressSelected: boolean;
    constructor(superControl: NgControl, ref: ChangeDetectorRef);
    writeValue(_: any): void;
    registerOnChange(fn: any): void;
    onChange(_: any): void;
    registerOnTouched(_: any): void;
    ngOnInit(): void;
    initChangesListener(): void;
    get getSuperControl(): FormControl;
    onCloseDropdown(event: boolean): void;
    getAddressData(address: string): void;
    onSelectDropdown(event: AddressList | null): void;
    onCommands(event: KeyboardEvent, type: InputAddressCommandsString): void;
    addressExpand(): void;
    closeAddress(): void;
    clearInput(event: KeyboardEvent): void;
    private checkSearchLayers;
    changeStopType(): void;
    onIncorrectInput(event: boolean): void;
    onClearInputEvent(): void;
    private checkAddressValidation;
    private filterParkingByCity;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaInputAddressDropdownComponent, [{ self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaInputAddressDropdownComponent, "app-ca-input-address-dropdown", never, { "placeholderType": { "alias": "placeholderType"; "required": false; }; "activeAddress": { "alias": "activeAddress"; "required": false; }; "receivedAddressData": { "alias": "receivedAddressData"; "required": false; }; "receivedAddressList": { "alias": "receivedAddressList"; "required": false; }; "parkingList": { "alias": "parkingList"; "required": false; }; "inputConfig": { "alias": "inputConfig"; "required": false; }; "commandHandler": { "alias": "commandHandler"; "required": false; }; "isRouting": { "alias": "isRouting"; "required": false; }; "closedBorder": { "alias": "closedBorder"; "required": false; }; "incorrectValue": { "alias": "incorrectValue"; "required": false; }; "hideEmptyLoaded": { "alias": "hideEmptyLoaded"; "required": false; }; "addresList": { "alias": "addresList"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, { "sentAddressValue": "sentAddressValue"; "selectedAddress": "selectedAddress"; "sentAddressData": "sentAddressData"; "closeDropdown": "closeDropdown"; "commandEvent": "commandEvent"; "changeFlag": "changeFlag"; "incorrectEvent": "incorrectEvent"; }, never, never, true, never>;
}

interface ColumnConfig {
    header: string;
    field?: string;
    row?: boolean;
    sortable?: boolean;
    reorderable?: boolean;
    hiddeOnTableReduce?: boolean;
    pipeType?: 'currency' | 'date';
    pipeString?: string;
    headerCellType?: 'text' | 'template';
    headerTemplate?: ElementRef<any>;
    rowType?: 'normal' | 'reorder';
    cellType: 'text' | 'component' | 'template';
    cellCustomClasses?: string;
    textCustomClasses?: string;
    component?: any;
    inputs?: {
        [key: string]: any;
    };
    outputs?: {
        [key: string]: (event: any) => void;
    };
    template?: ElementRef<any>;
    templateRef?: TemplateRef<any>;
}

declare class CaMainTableComponent<T = any> implements OnInit {
    private injector;
    private cdRef;
    tableData: T;
    selectedRowIndex: number | null;
    onPressEvent: EventEmitter<any>;
    onReorder: EventEmitter<CdkDragDrop<any[] | null, any, any>>;
    truckTemplate: TemplateRef<any>;
    reorderTemplate: TemplateRef<any>;
    reorderTemplatePreview: TemplateRef<any>;
    transparentTable: boolean;
    sortPredicate: (index: number, item: CdkDrag<number>) => boolean;
    hideFieldsToHide: boolean;
    reorderItems: boolean;
    disableReorderRow: boolean;
    columns: ColumnConfig[];
    data$: Observable<any[]>;
    constructor(injector: Injector, cdRef: ChangeDetectorRef);
    onPressRow(rowData: any, rowIndex: number): void;
    ngOnInit(): void;
    createInjector(inputs: {
        [key: string]: any;
    }): Injector;
    attachOutputs(componentRef: any, outputs: {
        [key: string]: (event: any) => void;
    }): void;
    dropHeader(event: CdkDragDrop<string[]>): void;
    drop(event: CdkDragDrop<any[] | null, any, any>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaMainTableComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaMainTableComponent<any>, "app-ca-main-table", never, { "truckTemplate": { "alias": "truckTemplate"; "required": false; }; "reorderTemplate": { "alias": "reorderTemplate"; "required": false; }; "reorderTemplatePreview": { "alias": "reorderTemplatePreview"; "required": false; }; "transparentTable": { "alias": "transparentTable"; "required": false; }; "sortPredicate": { "alias": "sortPredicate"; "required": false; }; "hideFieldsToHide": { "alias": "hideFieldsToHide"; "required": false; }; "reorderItems": { "alias": "reorderItems"; "required": false; }; "disableReorderRow": { "alias": "disableReorderRow"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "data$": { "alias": "data$"; "required": false; }; }, { "onPressEvent": "onPressEvent"; "onReorder": "onReorder"; }, never, never, true, never>;
}

declare enum ActionLogType {
    CREATED = "Created",
    EDITED = "Edited",
    DELETED = "Deleted",
    DEACTIVATED = "Deactivated",
    ACTIVATED = "Activated"
}

interface ActionLog {
    id: number;
    name: ActionLogType;
}

interface ActivityLogItemDescription {
    title: string;
    subTitle: string;
    additional: any;
}

interface ActivityLogItem {
    id: number;
    companyUser: CompanyUser;
    entityTypeActivity: EntityTypeActivity;
    actionLog: ActionLog;
    description: ActivityLogItemDescription | string;
    createdAt?: Date | null;
    updatedAt?: Date | null;
    isFirstInDay?: boolean;
}

interface CompanyUserAvatarFile {
    fileId: number;
    fileName: string;
    url: string;
    fileSize: number;
    tags: string[];
    tagGeneratedByUser: boolean;
    updatedAt: Date;
}

interface CompanyUser {
    id: number;
    userId: number;
    fullName: string;
    avatarFile: CompanyUserAvatarFile | null;
    departmentId: number | null;
}

interface EntityTypeActivity {
    id: number;
    name: string;
}

declare enum RightSidePanelCurrentTab {
    PERSONAL = "personal",
    ALL = "All"
}

declare enum SelectedModule {
    COMPANY_INFO = "Company Info",
    DIVISION_INFO = "Division Info",
    DOCUMENT = "Document",
    LOCATION = "Location",
    INSURANCE_POLICY = "Insurance Policy",
    FACTORING_COMPANY = "Factoring Company",
    CHAT = "Chat",
    WIDGET = "Widget",
    NOTES = "Notes",
    ACTIVITY_LOG = "Activity Log",
    NOTIFICATIONS = "Notifications"
}

declare enum ActivityLogSortType {
    ASCENDING = "Ascending",
    DESCENDING = "Descending"
}

declare enum CompanyInfoTitle {
    PHONE = "Phone",
    FAX = "Fax",
    EMAIL = "Email",
    WEBSITE = "Website",
    ADDRESS = "Address",
    USDOT = "USDOT",
    EIN = "EIN",
    MC = "MC",
    IRP = "IRP",
    IFTA = "IFTA",
    TOLL = "Toll",
    SCAC = "SCAC",
    TIME_ZONE = "Time Zone",
    CURRENCY = "Currency"
}

declare enum PreferredLoadType {
    FTL = "FTL",
    LTL = "LTL"
}

declare enum FleetType {
    SOLO = "Solo",
    TEAM = "Team",
    COMBINED = "Combined"
}

declare enum BankAccountStatus {
    UNVERIVIED = "Unverivied",
    VERIFIED = "Verified",
    PENDING = "Pending",
    DECLINED = "Declined"
}

declare class CaActivityLogListComponent implements OnInit, OnDestroy {
    private formBuilder;
    private cdr;
    RightSidePanelCurrentTab: typeof RightSidePanelCurrentTab;
    activityLogSearchConfig: ICaInput$1;
    searchForm: UntypedFormGroup;
    searchButtonSvg: string;
    showSearch: boolean;
    hoveredItemId: number;
    hoveredUserName?: string;
    focusedItemId: number;
    _selectedTab: RightSidePanelCurrentTab;
    private destroy$;
    _activityLogList: ActivityLogItem[];
    set activityLogList(value: ActivityLogItem[]);
    set selectedTab(value: RightSidePanelCurrentTab);
    searchText: EventEmitter<string>;
    resetFilters: EventEmitter<boolean>;
    constructor(formBuilder: UntypedFormBuilder, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    private createForm;
    private filterActivityLogListDate;
    private setActivityLogSearch;
    openSearchInput(): void;
    hoverItem(activityLogItem: ActivityLogItem): void;
    leaveItem(): void;
    private setHoveredUserName;
    activityLogItemFocus(activityLogItemId: number): void;
    private watchSearchFormValueChanges;
    resetFiltersClick(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaActivityLogListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaActivityLogListComponent, "app-ca-activity-log-list", never, { "activityLogList": { "alias": "activityLogList"; "required": false; }; "selectedTab": { "alias": "selectedTab"; "required": false; }; }, { "searchText": "searchText"; "resetFilters": "resetFilters"; }, never, never, true, never>;
}

interface NavigationItem {
    icon: string;
    title: SelectedModule;
    companyName: string | null;
    companyId?: number;
    isLastInList: boolean;
}

interface ActivityLogFilterParams {
    companyUserIds: number[];
    actionLogIds: number[];
    entityTypeActivityIds: number[];
    sort: ActivityLogSortType;
    userFilterType: RightSidePanelCurrentTab;
    dateFrom: Date | null;
    dateTo: Date | null;
    search: string | null;
    reloadFilters?: boolean;
}

interface ActivityLogFilter {
    filterType: string;
    action: string;
    queryParams: number[];
    subType: string;
}

interface UserFilterAvatarFile {
    fileId: number;
    fileName: string;
    url: string;
    fileSize: number;
    tags: string[];
    tagGeneratedByUser: boolean;
    updatedAt: Date;
}

interface UserFilterData {
    id: number;
    fullName: string;
    avatarFile: UserFilterAvatarFile;
    count: number;
}

interface UserFilterInputData {
    id: number;
    name: string;
    count: number;
    users: UserFilterData[];
}

interface ModuleFilterActivityLog {
    id: number;
    companyId: number;
    name: string;
    logoName: string;
}

interface ModuleFilterInputData {
    activityLogType: ModuleFilterActivityLog;
    count: number;
}

interface ActionFilterInputData {
    logoName: string;
    name: string;
    actionLogs: ActionLog;
    count: number;
}

interface TimeFilterEvent {
    filterType: string;
    action: string;
    queryParams: {
        timeSelected: string;
    };
    subType: string;
}

interface CompanyNavigationData {
    id: number;
    companyName: string;
    isDivision: boolean;
}

interface CompanyAddress {
    city: string;
    state: string;
    county: string;
    address: string;
    street: string;
    streetNumber: string;
    country: string;
    zipCode: string;
    stateShortName: string;
    addressUnit: string;
}

interface CompanyEnumValue {
    name: string;
    id: number;
}

interface CompanyAdditionalInfo {
    prefix: string;
    starting: number;
    sufix: string;
    autoInvoicing: boolean;
    preferredLoadType: PreferredLoadType;
    fleetType: FleetType;
    factorByDefault: boolean;
    payTerm: number;
    customerCredit: string;
    mvrMonths: number;
    truckInspectionMonths: number;
    trailerInspectionMonths: number;
}

interface FactoringCompany {
    name: string;
    phone: string;
    email: string;
    address: CompanyAddress;
    noticeOfAssigment: string;
    note: string;
}

interface DepartmentContact {
    id: number;
    department: Department;
    phone: string;
    extensionPhone: string;
    email: string;
    createdAt: string;
    updatedAt: string;
}

interface Department {
    id: number;
    name: string;
    count: number;
    companyUsers: CompanyUserShort[];
}

interface CompanyUserShort {
    id: number;
    userId: number;
    fullName: string;
    avatarFile: FileResponse;
    departmentId: number;
}

interface FileResponse {
    fileId: number;
    fileName: string;
    url: string;
    fileSize: number;
    tags: string[];
    tagGeneratedByUser: boolean;
    updatedAt: string;
}

interface BankAccount {
    id: number;
    bank: Bank;
    routing: string;
    account: string;
    status: BankAccountStatus;
    createdAt: string;
    updatedAt: string;
}

interface Bank {
    id: number;
    name: string;
    logoName: string;
    createdAt: string;
    updatedAt: string;
}

interface BankCard {
    id: number;
    nickname: string;
    cardType: string;
    card: string;
    cvc: string;
    expireDate: string;
    createdAt: string;
    updatedAt: string;
}

interface PerMileEntity {
    emptyMile: number;
    loadedMile: number;
    perStop: number;
}

interface CompanyPayroll {
    id: number;
    department: Department;
    payPeriod: CompanyEnumValue;
    endingIn: CompanyEnumValue;
    defaultBase: number;
    defaultCommission: number;
    solo: PerMileEntity;
    team: PerMileEntity;
    soloPerLoad: number;
    teamPerLoad: number;
    perMileSolo: number;
    perMileTeam: number;
    loadedAndEmptySameRate: boolean;
    defaultSoloDriverCommission: number;
    defaultTeamDriverCommission: number;
    defaultOwnerCommission: number;
    createdAt: string;
    updatedAt: string;
}

interface InsurancePolicy {
    id: number;
    producerName: string;
    issued: string;
    expires: string;
    phone: string;
    email: string;
    address: CompanyAddress;
    insurancePolicyAddons: InsurancePolicyAddon[];
    files: FileResponse[];
    note: string;
}

interface InsurancePolicyAddon {
    id: number;
    insurancePolicyId: number;
    insurancePolicyAddonType: CompanyEnumValue;
    policy: string;
    insurerName: string;
    rating: CompanyEnumValue;
    eachOccurrence: number;
    damageToRentedPremises: number;
    personalAndAdvertisingInjury: number;
    medicalExpanses: number;
    generalAggregate: number;
    productsCompOperAggregate: number;
    bodilyInjuryAccident: number;
    bodilyInjuryPerson: number;
    combinedSingleLimit: number;
    propertyDamage: number;
    singleConveyance: number;
    deductable: number;
    comprehensiveAndCollision: number;
    value: number;
    createdAt: string;
    updatedAt: string;
}

interface CompanyShort {
    id: number;
    companyName: string;
    isDivision: boolean;
    isActive: boolean;
    lastLogin: string;
    logoFile: FileResponse;
}

interface Company {
    id: number;
    name: string;
    usDot: string;
    ein: string;
    mc: string;
    phone: string;
    email: string;
    fax: string;
    webUrl: string;
    address: CompanyAddress;
    irp: string;
    ifta: string;
    toll: string;
    scac: string;
    timeZone: CompanyEnumValue;
    currency: CompanyEnumValue;
    companyType: CompanyEnumValue;
    dateOfIncorporation: string;
    hazMat: boolean;
    additionalInfo: CompanyAdditionalInfo;
    factoringCompany: FactoringCompany;
    departmentContacts: DepartmentContact[];
    bankAccounts: BankAccount[];
    bankCards: BankCard[];
    useACHPayout: boolean;
    companyPayrolls: CompanyPayroll[];
    insurancePolicies: InsurancePolicy[];
    divisions: CompanyShort[];
    files: FileResponse;
    logoFile: FileResponse;
    createdAt: string;
    updatedAt: string;
    driverMiles: boolean;
    driverComission: boolean;
    driverFlatRate: boolean;
}

declare class CaRightSidePanelMenuComponent {
    private elementRef;
    isPopupListShown: boolean;
    isPopupModuleShown: boolean;
    selectedModuleItem: NavigationItem;
    isHamburgerMenuFocused: boolean;
    isPinFocused: boolean;
    isNavShown: boolean;
    haveMenu: boolean;
    itemList: NavigationItem[];
    constructor(elementRef: ElementRef);
    set companyList(value: CompanyNavigationData[]);
    set selectedCompany(value: number);
    selectedNav: EventEmitter<SelectedModule>;
    isPinned: EventEmitter<boolean>;
    isNavOpen: EventEmitter<boolean>;
    selectedCompanyId: EventEmitter<number>;
    private setItemList;
    onDocumentClick(event: MouseEvent): void;
    openMenu(): void;
    closeMenu(): void;
    onToggleMenu(): void;
    itemClickEvent(item: NavigationItem): void;
    navItemClickEvent(item: NavigationItem): void;
    closeModule(): void;
    toggleNav(): void;
    hamburgerMenuClickEvent(): void;
    pinClickEvent(): void;
    private setSettings;
    private setSelectedCompany;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaRightSidePanelMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaRightSidePanelMenuComponent, "app-ca-right-side-panel-menu", never, { "companyList": { "alias": "companyList"; "required": false; }; "selectedCompany": { "alias": "selectedCompany"; "required": false; }; }, { "selectedNav": "selectedNav"; "isPinned": "isPinned"; "isNavOpen": "isNavOpen"; "selectedCompanyId": "selectedCompanyId"; }, never, never, true, never>;
}

declare class RightSidePanelTopBarSvgRoutes {
    static icons: {
        sortArrowFilter: string;
    };
    static folders: {
        common: string;
        actions: string;
    };
}

declare class CaRightSidePanelTopBarComponent {
    private cdr;
    currentTabActivityLog: RightSidePanelCurrentTab;
    hoveredActivityLogTab: RightSidePanelCurrentTab | null;
    RightSidePanelCurrentTab: typeof RightSidePanelCurrentTab;
    currentTabCompany: number;
    hoveredCompanyId: number;
    _usersFilter: UserGroup[];
    _modulesFilter: UserGroup[];
    _actionsFilter: ArrayStatus[];
    _companyList: CompanyNavigationData[];
    SelectedModule: typeof SelectedModule;
    activitySortOrderAsc: boolean;
    RightSidePanelTopBarSvgRoutes: typeof RightSidePanelTopBarSvgRoutes;
    _activityLogFilterParams: ActivityLogFilterParams;
    ActivityLogSortType: typeof ActivityLogSortType;
    selectedModule: SelectedModule;
    set usersFilter(value: UserFilterInputData[]);
    set modulesFilter(value: ModuleFilterInputData[]);
    set actionsFilter(value: ActionFilterInputData[]);
    set resetFilters(value: boolean);
    set companyList(value: CompanyNavigationData[]);
    set selectedCompanyId(value: number);
    selectedTab: EventEmitter<RightSidePanelCurrentTab>;
    activityLogFilterParams: EventEmitter<ActivityLogFilterParams>;
    selectedDivisionId: EventEmitter<number>;
    selectedMainCompanyId: EventEmitter<number>;
    constructor(cdr: ChangeDetectorRef);
    switchTab(tab: RightSidePanelCurrentTab): void;
    switchTabCompany(companyId: number, isDivision: boolean): void;
    private transformUsersFilter;
    private transformModulesFilter;
    private transformActionsFilter;
    setUserFilters(filter: ActivityLogFilter | any): void;
    setModuleFilters(filter: ActivityLogFilter | any): void;
    setTimeFilters(filter: TimeFilterEvent | any): void;
    clearAll(values: filterOutputWithParams | filterOutput | any): void;
    sortDate(): void;
    onHoverTabActivityLog(hoveredTab: RightSidePanelCurrentTab): void;
    onHoverLeaveActivityLog(): void;
    onHoverTabCompany(companyId: number): void;
    onHoverLeaveCompany(): void;
    reloadActivities(): void;
    private resetActivityLogFilters;
    private setCompanyList;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaRightSidePanelTopBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaRightSidePanelTopBarComponent, "app-ca-right-side-panel-top-bar", never, { "selectedModule": { "alias": "selectedModule"; "required": false; }; "usersFilter": { "alias": "usersFilter"; "required": false; }; "modulesFilter": { "alias": "modulesFilter"; "required": false; }; "actionsFilter": { "alias": "actionsFilter"; "required": false; }; "resetFilters": { "alias": "resetFilters"; "required": false; }; "companyList": { "alias": "companyList"; "required": false; }; "selectedCompanyId": { "alias": "selectedCompanyId"; "required": false; }; }, { "selectedTab": "selectedTab"; "activityLogFilterParams": "activityLogFilterParams"; "selectedDivisionId": "selectedDivisionId"; "selectedMainCompanyId": "selectedMainCompanyId"; }, never, never, true, never>;
}

declare class CaRightSidePanelComponent {
    _activityLogFilterParams: ActivityLogFilterParams;
    selectedNav?: SelectedModule;
    selectedTab: RightSidePanelCurrentTab;
    SelectedModule: typeof SelectedModule;
    resetFilters: boolean;
    selectedCompanyId: number;
    selectedCompanyIsDivision: boolean;
    companiesData: CompanyNavigationData[];
    activityLogData: ActivityLogItem[];
    mainCompanyData: Company | null;
    usersFilter: UserFilterInputData[];
    modulesFilter: ModuleFilterInputData[];
    actionsFilter: ActionFilterInputData[];
    activityLogFilterParams: EventEmitter<ActivityLogFilterParams>;
    selectedNavModule: EventEmitter<SelectedModule>;
    isSidePanelPinned: EventEmitter<boolean>;
    isNavOpen: EventEmitter<boolean>;
    selectedDivisionId: EventEmitter<number>;
    selectedNavEvent(selectedNav: SelectedModule): void;
    selectedTabEvent(selectedTab: RightSidePanelCurrentTab): void;
    selectedCompanyIdEvent(companyId: number): void;
    selectedDivisionIdEvent(companyId: number): void;
    selectedMainCompanyIdEvent(companyId: number): void;
    pinSidebarEvent(isPinned: boolean): void;
    setActivityLogFilterParams(activityLogFilterParams: ActivityLogFilterParams): void;
    searchEvent(searchText: string): void;
    resetFiltersEvent(resetFilters: boolean): void;
    openNavEvent(isNavOpen: boolean): void;
    private clearData;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaRightSidePanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaRightSidePanelComponent, "app-ca-right-side-panel", never, { "companiesData": { "alias": "companiesData"; "required": false; }; "activityLogData": { "alias": "activityLogData"; "required": false; }; "mainCompanyData": { "alias": "mainCompanyData"; "required": false; }; "usersFilter": { "alias": "usersFilter"; "required": false; }; "modulesFilter": { "alias": "modulesFilter"; "required": false; }; "actionsFilter": { "alias": "actionsFilter"; "required": false; }; }, { "activityLogFilterParams": "activityLogFilterParams"; "selectedNavModule": "selectedNavModule"; "isSidePanelPinned": "isSidePanelPinned"; "isNavOpen": "isNavOpen"; "selectedDivisionId": "selectedDivisionId"; }, never, never, true, never>;
}

interface IBaseDataset {
    type: keyof ChartTypeRegistry;
    order?: number;
    label: string;
    data: number[] | [number, number][];
    hidden?: boolean;
    borderColor?: string;
    borderWidth?: number;
    backgroundColor?: string | string[] | CanvasGradient;
    color?: string;
    spanGaps?: boolean;
    colorEdgeValue?: number;
    color2?: string;
    fill?: boolean;
    yAxisID?: string;
    shiftValue?: number;
    isCurrency?: boolean;
}

interface IChartData<DatasetType extends IBaseDataset> {
    labels: string[];
    datasets: DatasetType[];
}

interface ILineDataset extends IBaseDataset {
    pointHoverBorderWidth?: number;
    pointHoverBorderColor?: string | string[] | CanvasGradient;
    pointHoverBackgroundColor?: string | string[] | CanvasGradient;
    tension?: number;
    cubicInterpolationMode?: string;
    pointRadius?: number;
    pointBorderWidth?: number;
    pointBorderColor?: string;
    pointBackgroundColor?: string;
    pointHoverRadius?: number;
    showLine?: boolean;
}

declare const enum eChartTypesString {
    LINE = "line",
    BAR = "bar",
    DOUGHNUT = "doughnut"
}

declare enum CubicInterpolationStringEnum {
    DEFAULT = "default",
    MONOTONE = "monotone"
}

declare const enum ChartColorsStringEnum {
    WHITE = "#FFFFFF",
    HOVER_SEGMENT = "#EEEEEE",
    X_AXIS_LABEL_COLOR = "#919191",
    TRANSPARENT = "transparent",
    BORDER_BOTTOM_LINE_CHART_COLOR = "#DADADA"
}

declare enum ChartPluginIdsStringEnum {
    HIGHLIGHT_SEGMENT_ON_HOVER = "highlightSegmentOnHover",
    HIGHLIGHT_POINT_ON_HOVER = "highlightPointOnHover",
    BORDER_BOTTOM_LINE_CHART = "borderBottomLineChart",
    X_DASHED = "x-dashed"
}

declare enum ChartEventTypesStringEnum {
    MOUSE_OUT = "mouseout"
}

declare enum EChartEventProperties {
    X = "x",
    Y = "y",
    Y_AXIS_0 = "y-axis-0"
}

declare const enum ChartImagesStringEnum {
    CHART_NO_DATA_GREEN = "assets/ca-components/svg/chart/chart_no_data_green.svg",
    CHART_NO_DATA_YELLOW = "assets/ca-components/svg/chart/chart_no_data_yellow.svg",
    CHART_NO_DATA_PAY = "assets/ca-components/svg/chart/chart_no_data_pay.svg",
    CHART_NO_DATA_STACKED = "assets/ca-components/svg/chart/chart_no_data_stacked.svg",
    CHART_NO_DATA_MIXED = "assets/ca-components/svg/chart/chart_no_data_mixed.svg"
}

declare enum ChartFontPropertiesStringEnum {
    FONT_FAMILY_MONTSERRAT = "Montserrat",
    FONT_WEIGHT_BOLDER = "bolder"
}

declare enum EChartAnnotationType {
    LINE = "line",
    BOX = "box",
    ELLIPSE = "ellipse",
    LABEL = "label",
    POINT = "point",
    POLYGON = "polygon"
}

declare class EChartAnnotation {
    static X_DASHED: {
        id: ChartPluginIdsStringEnum;
        type: EChartAnnotationType;
        scaleID: EChartEventProperties;
        borderWidth: number;
        borderDash: number[];
    };
}

interface IChartAnnotation {
    id?: string;
    value: number | string;
    type: EChartAnnotationType;
    color?: string;
    borderWidth?: number;
    borderDash?: [number, number];
    axis: EChartEventProperties;
}

interface IChartConfiguration {
    chartType: keyof ChartTypeRegistry;
    chartData: IChartData<IBaseDataset>;
    chartOptions: ChartOptions;
    height: number;
    width: number;
    noDataImage: string;
    isMultiYAxis?: boolean;
    isStacked?: boolean;
    showTooltipBackground?: boolean;
    showXAxisLabels?: boolean;
    verticalyAlignBarChartWithLineCart?: boolean;
    showHighlightPointOnHover?: boolean;
    isDatasetHoverEnabled?: boolean;
    isTooltipItemInSelectedItems?: boolean;
    showBottomLineOnLineChart?: boolean;
    annotations?: IChartAnnotation[];
    hasVerticalDashedAnnotation?: boolean;
    isDashboardChart?: boolean;
    centerLabels?: IChartCenterLabel[];
    selectedIndex?: number | null;
}

interface IChartDatasetHover {
    label: string;
    color: string;
    isHoverd: boolean;
}

interface IChartCenterLabel {
    value: string;
    position?: {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
    };
    color?: string;
    fontSize?: number;
}

interface IChartLegendProperty {
    name: string;
    value: number;
    color: string;
    unit?: string;
    isLineIndicator?: boolean;
}

interface IChartLegendConfig {
    title: string;
    data: IChartLegendProperty[];
    hasHighlightedBackground: boolean;
}

interface IChartBoundaries {
    leftBoundary: number;
    rightBoundary: number;
}

interface IHoverState {
    index: number | null;
    chartId: string | null;
    boundaries: IChartBoundaries | undefined;
}

declare class ChartManagerService {
    hoverStateSubject: BehaviorSubject<IHoverState>;
    hoverState$: rxjs.Observable<IHoverState>;
    setHoverState(index: number | null, chartId: string | null, boundaries?: IChartBoundaries): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChartManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ChartManagerService>;
}

declare class CaChartComponent implements AfterViewInit {
    private changeDetector;
    private chartManagerService?;
    chartCanvas: ElementRef;
    legendData: IChartLegendConfig;
    chartId: string;
    set chartDatasetHover(value: IChartDatasetHover | null);
    set chartConfig(value: IChartConfiguration);
    set selectedIndex(value: number);
    hoveredIndex: EventEmitter<number | null>;
    private destroy$;
    private chart;
    private chartContext;
    private plugins?;
    private areAnimationsCompleated;
    private _hoveredIndex;
    private lastHoveredIndex;
    _chartConfig: IChartConfiguration;
    isChartDataAvailable: boolean;
    constructor(changeDetector: ChangeDetectorRef, chartManagerService?: ChartManagerService | undefined);
    ngAfterViewInit(): void;
    ngOnInit(): void;
    private initializeChartManagerService;
    private initializeAnnotationPlugin;
    updateDatasetBackgroundOnHover(chartDatasetHover: IChartDatasetHover): void;
    private createChart;
    private updateChart;
    private setChartOptionsProperties;
    private focusDoughnutArc;
    private setOriginalDoughnutArcsColor;
    private setChartDataProperties;
    private setChartPluginsProperties;
    private updateChartAnnotations;
    private setMultipleYAxis;
    private removeVerticalDashedLine;
    private setVerticalDashedAnnotationLine;
    removeVerticalDashedLineAndFocus(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaChartComponent, [null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaChartComponent, "app-ca-chart", never, { "legendData": { "alias": "legendData"; "required": false; }; "chartId": { "alias": "chartId"; "required": false; }; "chartDatasetHover": { "alias": "chartDatasetHover"; "required": false; }; "chartConfig": { "alias": "chartConfig"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "hoveredIndex": "hoveredIndex"; }, never, never, true, never>;
}

interface ITooltipListItem {
    label: string;
    value: number;
    isCurrency: boolean;
    percentage?: string;
    color: string;
}

interface ITooltipList {
    date: string;
    selectedItems: ITooltipListItem[];
    otherItems?: ITooltipListItem[];
    showPercentage?: boolean;
}

declare class CaChartManagerComponent {
    private chartManagerService;
    private cdr;
    chartConfigs: IChartConfiguration[];
    tooltipLables: string[];
    chartDatasetHover: IChartDatasetHover | null;
    chartManagerContainer: ElementRef;
    tooltipContainer: ElementRef;
    hoveredIndex: number | null;
    hoveredChartId: string | null;
    tooltipList: ITooltipList | null;
    tooltipPosition: {
        x: number;
        y: number;
    };
    constructor(chartManagerService: ChartManagerService, cdr: ChangeDetectorRef);
    calculateTooltipPosition(boundaries: IChartBoundaries): void;
    private updateTooltipList;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaChartManagerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaChartManagerComponent, "app-ca-chart-manager", never, { "chartConfigs": { "alias": "chartConfigs"; "required": false; }; "tooltipLables": { "alias": "tooltipLables"; "required": false; }; "chartDatasetHover": { "alias": "chartDatasetHover"; "required": false; }; }, {}, never, never, true, never>;
}

interface IColumnCheckAction {
    isChecked: boolean;
    name: string;
    groupIndex: number;
    itemIndex: number;
}

declare enum eDropdownMenu {
    CLOSE = "Close",
    OPEN = "Open",
    RESET_TABLE = "reset-table",
    RIGHT_TOP = "right-top",
    BOTTOM_RIGHT = "bottom-right",
    DOTS_MENU_TYPE = "dots-menu-type",
    HAMBURGER_MENU_TYPE = "hamburger-menu-type",
    SELECT_MENU_TYPE = "select-menu-type",
    EMPTY_STRING_PLACEHOLDER = "",
    BACK_TO_MENU = "Back To Menu",
    CLOSE_MENU = "Close Menu",
    OPEN_MENU = "Open Menu",
    MORE = "More",
    RESET_TABLE_TITLE = "Reset Table"
}

declare enum eDropdownMenuItemType {
    ADD_NEW = "add-new",
    CDL = "cdl",
    TEST = "test",
    REQUEST = "request",
    OPEN_BUSINESS_HOURS = "open-business",
    DELETE = "delete",
    EDIT = "edit",
    ADD_BILL = "add-bill",
    COLUMNS = "columns"
}

declare class DropdownMenuSvgRoutes {
    static dotsDropdownIcon: string;
    static hamburgerDropdownIcon: string;
    static showMoreIcon: string;
    static backToMenuIcon: string;
}

type DropdownMenuType = 'dots-menu-type' | 'hamburger-menu-type' | 'select-menu-type';

declare class CaDropdownMenuComponent {
    type: DropdownMenuType;
    options: IDropdownMenuItem[];
    placement: string;
    popoverClass?: string;
    isDarkBackground?: boolean;
    isLeftSideIconPosition?: boolean;
    isColumnsDropdown?: boolean;
    dropdownOptionEmitter: EventEmitter<IDropdownMenuOptionEmit>;
    dropdownMenuSvgRoutes: typeof DropdownMenuSvgRoutes;
    eDropdownMenu: typeof eDropdownMenu;
    eDropdownMenuItemType: typeof eDropdownMenuItemType;
    dropdownPopover: NgbPopover | null;
    activeInnerDropdownOptionIndex: number;
    isSelectMenuTypeActionItemSelected: boolean;
    isBackToMainDropdownItemHovered: boolean;
    isResetTableHovered: boolean;
    isActionLocked: boolean;
    get isDropdownMenuActive(): boolean | undefined;
    constructor();
    private handleCheckboxAction;
    private handleChildCheckboxAction;
    private handleParentCheckboxAction;
    handleDropdownOptionClick(option: IDropdownMenuItem, itemIndex?: number, groupIndex?: number): void;
    handleDropdownOpenCloseClick(dropdownPopover: NgbPopover): void;
    handleCheckboxActionEmit(action: IColumnCheckAction): void;
    handleResetTableClick(event: Event): void;
    handleBackToMainDropdownListItemHover(isHovered: boolean): void;
    onResetTableHover(): void;
    handleDropdownClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaDropdownMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaDropdownMenuComponent, "ca-dropdown-menu", never, { "type": { "alias": "type"; "required": false; }; "options": { "alias": "options"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "popoverClass": { "alias": "popoverClass"; "required": false; }; "isDarkBackground": { "alias": "isDarkBackground"; "required": false; }; "isLeftSideIconPosition": { "alias": "isLeftSideIconPosition"; "required": false; }; "isColumnsDropdown": { "alias": "isColumnsDropdown"; "required": false; }; }, { "dropdownOptionEmitter": "dropdownOptionEmitter"; }, never, never, true, never>;
}

interface IDeleteAction {
    id: number;
    action: string;
}

interface IFileActionEvent {
    file: IFileConfig;
    action: string;
}

declare enum eDocumentAction {
    TAG = "tag",
    DOWNLOAD = "download",
    DELETE = "delete",
    CANCEL = "cancel",
    MARK_CORRECT = "mark-correct",
    MARK_INCORRECT = "mark-incorrect"
}

declare class UrlExtensionPipe implements PipeTransform {
    transform(url: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<UrlExtensionPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<UrlExtensionPipe, "urlExtension", true>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UrlExtensionPipe>;
}

declare class FileNamePipe implements PipeTransform {
    transform(url: string | undefined): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileNamePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FileNamePipe, "fileName", true>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FileNamePipe>;
}

declare class DocumentService {
    documentName: string | null;
    constructor();
    setDocumentName(data: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentService>;
}

declare class CaUploadFileComponent implements OnInit, AfterViewInit {
    private http;
    private ref;
    private renderer;
    private urlExt;
    private fileNamePipe;
    private detailsDataService;
    t2: NgbPopover;
    inputRef: CaInputComponent;
    config: IFileOptionConfig;
    reviewFileConfig: IReviewFileConfig;
    fileAction: EventEmitter<IFileActionEvent>;
    deleteAction: EventEmitter<IDeleteAction>;
    documentReviewInputEvent: EventEmitter<IDocumentReviewInputEvent>;
    landscapeCheck: EventEmitter<any>;
    fileHover: EventEmitter<any>;
    fileNewName: FormControl;
    documentReviewInputControl: FormControl;
    editFile: boolean;
    isFileDelete: boolean;
    documentReviewInputVisible: boolean;
    isIncorrectMarkHover: boolean;
    annotationHover: boolean;
    documentLoading: boolean;
    isArrowHovered: boolean;
    numberOfFilePages: string;
    fileName: string;
    icons: {
        download: string;
        confirm: string;
        tag: string;
        trash: string;
        close: string;
    };
    isImageFile: boolean;
    isVideoFile: boolean;
    reviewState: typeof eReviewState;
    fileInputConfig: ICaInput$1;
    documentAction: typeof eDocumentAction;
    videoThumbnail: string | null;
    private destroy$;
    constructor(http: HttpClient, ref: ChangeDetectorRef, renderer: Renderer2, urlExt: UrlExtensionPipe, fileNamePipe: FileNamePipe, detailsDataService: DocumentService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onBlurInput(event: boolean): void;
    afterLoadComplete(pdf: PDFDocumentProxy): void;
    pageRendered(event: any): void;
    onAction(action: string): void;
    onEditFile(): void;
    getAnnotationReviewEvent(event: {
        type: string;
    }): void;
    selectTag(tag: string): void;
    removeTag(): void;
    openDeletePopup(name: string): void;
    hoverFile(): void;
    updateHover(mod: boolean): void;
    hoverArrow(mod: boolean): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    private generateVideoThumbnail;
    private getfileName;
    private onSpinner;
    private reviewInputControlChange;
    private setSavedTag;
    private handleTagAction;
    private handleDownloadAction;
    private handleDeleteAction;
    private handleCancelAction;
    private handleMarkIncorrectAction;
    private handleMarkCorrectAction;
    private downloadFile;
    private setCategoryTag;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaUploadFileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaUploadFileComponent, "app-ca-upload-file", never, { "config": { "alias": "config"; "required": false; }; "reviewFileConfig": { "alias": "reviewFileConfig"; "required": false; }; }, { "fileAction": "fileAction"; "deleteAction": "deleteAction"; "documentReviewInputEvent": "documentReviewInputEvent"; "landscapeCheck": "landscapeCheck"; "fileHover": "fileHover"; }, never, never, true, never>;
}

declare enum eCarouselAction {
    PREV = "prev",
    NEXT = "next"
}

declare class CaUploadFilesCarouselComponent implements OnInit {
    private ref;
    fileSlider: ElementRef;
    fileHolder: ElementRef;
    slideWidth: number;
    set config(data: IFilesCarouselConfig);
    activeSlide: EventEmitter<number>;
    hoverArrowEmit: EventEmitter<boolean>;
    carouselConfig: IFilesCarouselConfig;
    action: typeof eCarouselAction;
    currentSlide: number;
    removePointers: boolean;
    filesShown: number;
    arrowSvg: string;
    multipleCurrentSlide: number;
    translateXMultipleSlides: number;
    constructor(ref: ChangeDetectorRef);
    ngOnInit(): void;
    private initializeCarousel;
    calculateFilesShown(): number;
    onAction(action: eCarouselAction): void;
    private handleSlideChange;
    private goToPreviousSlide;
    private goToNextSlide;
    private resetMultipleSlides;
    private updatePointerRemoval;
    slideToFile(index: number): void;
    hoverArrow(show: boolean): void;
    identity(index: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaUploadFilesCarouselComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaUploadFilesCarouselComponent, "app-ca-upload-files-carousel", never, { "slideWidth": { "alias": "slideWidth"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "activeSlide": "activeSlide"; "hoverArrowEmit": "hoverArrowEmit"; }, never, ["*"], true, never>;
}

declare class CaUploadFileService {
    private uploadDocumentsSubject;
    private visibilityDropZoneSubject;
    get visibilityDropZone$(): rxjs.Observable<boolean>;
    visibilityDropZone(action: boolean): void;
    get uploadedFiles$(): rxjs.Observable<{
        files: IFileConfig[];
        action: string;
    }>;
    uploadFiles(data: {
        files: IFileConfig[];
        action: string;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaUploadFileService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CaUploadFileService>;
}

declare class FilesUploadSvgRoutes {
    static AVATAR_RECTANGLE: string;
    static AVATAR_CIRCLE: string;
}

declare class CaUploadFilesComponent implements AfterViewInit {
    private uploadFileService;
    private http;
    modalCarousel: CaUploadFilesCarouselComponent;
    uploadedFiles: QueryList<CaUploadFileComponent>;
    set uploadFilesConfig(value: IUploadFilesConfig);
    documentReviewInputEvent: EventEmitter<IDocumentReviewInputEvent>;
    onFileEvent: EventEmitter<IFileEvent>;
    closeDropzone: EventEmitter<{}>;
    fileAdded: EventEmitter<File>;
    currentSlide: number;
    isDropzoneShown: boolean;
    filesUploadSvgRoutes: typeof FilesUploadSvgRoutes;
    private _config;
    private destroy$;
    get config(): IUploadFilesConfig;
    get carouselFileConfig(): IFilesCarouselConfig;
    get reviewFileConfig(): IReviewFileConfig;
    constructor(uploadFileService: CaUploadFileService, http: HttpClient);
    ngAfterViewInit(): void;
    /**
     *
     * @param data - returned data from file action (one or multiple)
     */
    onFileAction(data: {
        file: IFileConfig;
        action: string;
    }): void;
    onUploadFiles(data: {
        files: IFileConfig[];
        action: string;
    }): void;
    documentReviewInputEventMethod(data: {
        file: IFileConfig;
        message: string;
    }): void;
    downloadFile(fileUrl: string, fileName: string): void;
    onLandscapeCheck(landscape: boolean): void;
    dropZoneClose(): void;
    fileHover(file: IFileConfig): void;
    hoverArrow(mod: boolean): void;
    private subscribeToUploadedFiles;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaUploadFilesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaUploadFilesComponent, "app-ca-upload-files", never, { "uploadFilesConfig": { "alias": "uploadFilesConfig"; "required": false; }; }, { "documentReviewInputEvent": "documentReviewInputEvent"; "onFileEvent": "onFileEvent"; "closeDropzone": "closeDropzone"; "fileAdded": "fileAdded"; }, never, never, true, never>;
}

declare class CaRightSidePanelCompanyComponent {
    private clipboar;
    _company: Company;
    set company(value: Company | null);
    companyIsDivision?: boolean;
    fontSizeLogo: string;
    CompanyInfoTitle: typeof CompanyInfoTitle;
    firstPartAddress: string;
    secondPartAddress: string;
    isAdditionalInfoOpen: boolean;
    isDepartmentContactOpen: boolean;
    isPhoneShown: boolean;
    isBankAccountOpen: boolean;
    isRoutingShown: boolean;
    accountVisibility: {
        [key: string]: boolean;
    };
    isBankCardOpen: boolean;
    isCardShown: boolean;
    cardVisibility: {
        [key: string]: boolean;
    };
    cvcVisibility: {
        [key: string]: boolean;
    };
    textCopied: string;
    constructor(clipboar: Clipboard);
    private changeFontSizeLogo;
    private splitAddress;
    toggleAdditionalInfo(): void;
    toggleDepartmentContact(): void;
    toggleDepartmentContactView(): void;
    toggleBankAccount(): void;
    toggleBankAccountView(): void;
    toggleAccountVisibility(account: string): void;
    isAccountVisible(account: string): boolean;
    toggleBankCard(): void;
    toggleBankCardView(): void;
    toggleCardVisibility(card: string): void;
    isCardVisible(card: string): boolean;
    toggleCvcVisibility(cvc: string): void;
    isCvcVisible(cvc: string): boolean;
    copyText(event: Event, val: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaRightSidePanelCompanyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaRightSidePanelCompanyComponent, "app-ca-right-side-panel-company", never, { "company": { "alias": "company"; "required": false; }; "companyIsDivision": { "alias": "companyIsDivision"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaTooltipListConstants {
    static VALUE_PERCENTAGE_DELIMITER: string;
}

declare class CaTooltipListComponent {
    tooltipList: ITooltipList | null;
    constants: typeof CaTooltipListConstants;
    truncateLength: number;
    get isSingleItemSelected(): boolean;
    get isLessThanFourItemsSelected(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaTooltipListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaTooltipListComponent, "app-ca-tooltip-list", never, { "tooltipList": { "alias": "tooltipList"; "required": false; }; }, {}, never, never, true, never>;
}

declare enum eVehicleList {
    REPAIRED_VEHICLE_LIST = "repaired-vehicle-list",
    FUELLED_VEHICLE_LIST = "fuelled-vehicle-list"
}

declare class VehicleListSvgRoutes {
    static repairedVehicleListSvgRoute: string;
    static fuelledVehicleListSvgRoute: string;
    static trucksRoute: string;
    static trailersRoute: string;
}

type VehicleListType = eVehicleList.REPAIRED_VEHICLE_LIST | eVehicleList.FUELLED_VEHICLE_LIST;

interface VehicleListResponse {
    unitId?: number | null;
    unitType?: RepairUnitType;
    unitNumber?: string | null;
    totalCount?: number | null;
    vehicleTypeId?: number;
    vehicleName?: string;
    logoName?: string | null;
    totalCost?: number | null;
}
type RepairUnitType = 'Truck' | 'Trailer';

interface IVehicleListConfig {
    type?: VehicleListType;
    list: VehicleListResponse[];
    isSearchActive?: boolean;
}

interface IVehicleListActionsEmit {
    unitType?: string;
    unitId?: number | null;
    isCloseSearch?: boolean;
}

declare class CaVehicleListComponent {
    set vehicleListConfig(data: IVehicleListConfig);
    vehicleListActionsEmitter: EventEmitter<IVehicleListActionsEmit>;
    onSearchActionEmit: EventEmitter<string>;
    _vehicleListConfig: IVehicleListConfig;
    vehicleListSvgRoutes: typeof VehicleListSvgRoutes;
    eVehicleList: typeof eVehicleList;
    eStringPlaceholder: typeof eStringPlaceholder;
    vehicleListHeaderItems: string[];
    vehicleHoverIndex: number;
    constructor();
    private getConstantData;
    handleVehicleTypeHoverAction(vehicleIndex: number): void;
    onClickActions(action?: IVehicleListActionsEmit): void;
    onSearchAction(searchText: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaVehicleListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaVehicleListComponent, "app-ca-vehicle-list", never, { "vehicleListConfig": { "alias": "vehicleListConfig"; "required": false; }; }, { "vehicleListActionsEmitter": "vehicleListActionsEmitter"; "onSearchActionEmit": "onSearchActionEmit"; }, never, never, true, never>;
}

declare class LastFuelPriceSvgRoutes {
    static progressIconRoute: string;
}

declare class CaLastFuelPriceProgressComponent implements OnInit {
    set lastFuelPriceData(data: ILastFuelPriceProgressData);
    lastFuelPriceSvgRoutes: typeof LastFuelPriceSvgRoutes;
    eStringPlaceholder: typeof eStringPlaceholder;
    eUnit: typeof eUnit;
    lastFuelPriceConfig: ILastFuelPriceProgressConfig[];
    lastFuelPriceColors: string[];
    isMapView: boolean;
    constructor();
    ngOnInit(): void;
    private getConstantData;
    private createLastFuelPriceCardData;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaLastFuelPriceProgressComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaLastFuelPriceProgressComponent, "app-ca-last-fuel-price-progress", never, { "lastFuelPriceData": { "alias": "lastFuelPriceData"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CheckboxSvgRoutes {
    static carrieraLogoActiveIcon: string;
    static carrieraLogoInactiveIcon: string;
    static checkedIcon: string;
    static disabledIcon: string;
}

declare class CaCheckboxComponent implements ControlValueAccessor {
    private renderer;
    superControl?: NgControl | undefined;
    private cdRef?;
    label: string;
    required: boolean;
    disabled?: boolean;
    disabledStillCheckMark: boolean;
    svg: string;
    name: string;
    customClass: string;
    svgCustomClass: string;
    moveIconDown: boolean;
    isUseCarrieraACHCheckBox: boolean;
    isDisabledBlue: boolean;
    isDisabledRegularCheck: boolean;
    isLabelDisabled: boolean;
    isRegularCheckbox: boolean;
    isChecked?: boolean;
    isGroupPartialyChecked: boolean;
    isBlackLabelCheckbox: boolean;
    isModalCheckbox: boolean;
    isMarginTopReset: boolean;
    groupIndex: number;
    itemIndex: number;
    isDarkBackgroundCheckbox: boolean;
    formArrayAction: EventEmitter<boolean>;
    columnCheckAction: EventEmitter<IColumnCheckAction>;
    isInputChecked: boolean;
    checkboxSvgRoutes: typeof CheckboxSvgRoutes;
    eGeneralActions: typeof eGeneralActions;
    eColor: typeof eColor;
    get getSuperControl(): _angular_forms.AbstractControl<any, any, any> | null | undefined;
    constructor(renderer: Renderer2, superControl?: NgControl | undefined, cdRef?: ChangeDetectorRef | undefined);
    ngAfterViewInit(): void;
    private onChangeCallback;
    private onTouchedCallback;
    writeValue(obj: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    onChange(event: Event): void;
    onHandleClick(event?: MouseEvent, fromCheckboxArea?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaCheckboxComponent, [null, { optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaCheckboxComponent, "app-ca-checkbox", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "disabledStillCheckMark": { "alias": "disabledStillCheckMark"; "required": false; }; "svg": { "alias": "svg"; "required": false; }; "name": { "alias": "name"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "svgCustomClass": { "alias": "svgCustomClass"; "required": false; }; "moveIconDown": { "alias": "moveIconDown"; "required": false; }; "isUseCarrieraACHCheckBox": { "alias": "isUseCarrieraACHCheckBox"; "required": false; }; "isDisabledBlue": { "alias": "isDisabledBlue"; "required": false; }; "isDisabledRegularCheck": { "alias": "isDisabledRegularCheck"; "required": false; }; "isLabelDisabled": { "alias": "isLabelDisabled"; "required": false; }; "isRegularCheckbox": { "alias": "isRegularCheckbox"; "required": false; }; "isChecked": { "alias": "isChecked"; "required": false; }; "isGroupPartialyChecked": { "alias": "isGroupPartialyChecked"; "required": false; }; "isBlackLabelCheckbox": { "alias": "isBlackLabelCheckbox"; "required": false; }; "isModalCheckbox": { "alias": "isModalCheckbox"; "required": false; }; "isMarginTopReset": { "alias": "isMarginTopReset"; "required": false; }; "groupIndex": { "alias": "groupIndex"; "required": false; }; "itemIndex": { "alias": "itemIndex"; "required": false; }; "isDarkBackgroundCheckbox": { "alias": "isDarkBackgroundCheckbox"; "required": false; }; }, { "formArrayAction": "formArrayAction"; "columnCheckAction": "columnCheckAction"; }, never, never, true, never>;
}

declare class CaLoadStatusComponent implements OnInit {
    containerLoadStatus: ElementRef;
    set status(value: SelectedStatus);
    set isRowHover(value: boolean);
    time: string;
    isNoStyle: boolean;
    fontSize: number;
    width: number;
    height: number;
    isTitleCardDropdown: boolean;
    isDark: boolean;
    isMarked: boolean;
    isDropdownStatusChange: boolean;
    isDefaultHoverFocus: boolean;
    isNoStatesColor: boolean;
    isStatusCard: boolean;
    isTableBigStatus: boolean;
    isDisabledClick: boolean;
    isSelectedItem: boolean;
    isFilter: boolean;
    isDispatchStatus: boolean;
    dispatchTime: string;
    isDispatchShowTimeAlways: boolean;
    _status: SelectedStatus;
    displayString: string[];
    isStatusFocused: boolean;
    constructor();
    ngOnInit(): void;
    private generateDisplayString;
    focusOnClick(): void;
    onStatusFocus(): void;
    onStatusBlur(): void;
    private onRowHover;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaLoadStatusComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaLoadStatusComponent, "app-ca-load-status", never, { "status": { "alias": "status"; "required": false; }; "isRowHover": { "alias": "isRowHover"; "required": false; }; "time": { "alias": "time"; "required": false; }; "isNoStyle": { "alias": "isNoStyle"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "isTitleCardDropdown": { "alias": "isTitleCardDropdown"; "required": false; }; "isDark": { "alias": "isDark"; "required": false; }; "isMarked": { "alias": "isMarked"; "required": false; }; "isDropdownStatusChange": { "alias": "isDropdownStatusChange"; "required": false; }; "isDefaultHoverFocus": { "alias": "isDefaultHoverFocus"; "required": false; }; "isNoStatesColor": { "alias": "isNoStatesColor"; "required": false; }; "isStatusCard": { "alias": "isStatusCard"; "required": false; }; "isTableBigStatus": { "alias": "isTableBigStatus"; "required": false; }; "isDisabledClick": { "alias": "isDisabledClick"; "required": false; }; "isSelectedItem": { "alias": "isSelectedItem"; "required": false; }; "isFilter": { "alias": "isFilter"; "required": false; }; "isDispatchStatus": { "alias": "isDispatchStatus"; "required": false; }; "dispatchTime": { "alias": "dispatchTime"; "required": false; }; "isDispatchShowTimeAlways": { "alias": "isDispatchShowTimeAlways"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaCheckboxSelectedCountComponent {
    itemsTotalCount: number | null;
    itemsSelectedCount: number | null;
    isTableHeader: boolean;
    onCheckboxCountClick: EventEmitter<string>;
    isCheckboxCountHovered: boolean;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    ePosition: typeof ePosition;
    eColor: typeof eColor;
    eGeneralActions: typeof eGeneralActions;
    eStringPlaceholder: typeof eStringPlaceholder;
    constructor();
    handleCheckboxCountHover(isHovered?: boolean): void;
    handleCheckboxCountClick(action: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaCheckboxSelectedCountComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaCheckboxSelectedCountComponent, "app-ca-checkbox-selected-count", never, { "itemsTotalCount": { "alias": "itemsTotalCount"; "required": false; }; "itemsSelectedCount": { "alias": "itemsSelectedCount"; "required": false; }; "isTableHeader": { "alias": "isTableHeader"; "required": false; }; }, { "onCheckboxCountClick": "onCheckboxCountClick"; }, never, never, true, never>;
}

interface CaDetailsTitleCardConfig {
    title?: string;
    tooltip?: string;
    placeholder?: string;
    width?: string;
    tooltipNext?: string;
    tooltipPrevious?: string;
    isNextButtonDisabled?: boolean;
    isPreviousButtonDisabled?: boolean;
    isSearchTooltipDisabled?: boolean;
}

declare class CaDetailsTitleCardComponent<T> {
    private cdr;
    popoverRef: NgbPopover;
    titleCardTooltip: NgbTooltip;
    titleCard: ElementRef;
    inputSearch: ElementRef;
    dropdownTemplate: TemplateRef<T>;
    titleTemplate: TemplateRef<T>;
    set detailsTitleCardConfig(values: CaDetailsTitleCardConfig);
    onNextAction: EventEmitter<void>;
    onPreviousAction: EventEmitter<void>;
    onSearchTextChange: EventEmitter<string | null>;
    _detailsTitleCardConfig: CaDetailsTitleCardConfig;
    titleCardWidth: number;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eColor: typeof eColor;
    ePosition: typeof ePosition;
    toggleInput: boolean;
    dropdownPopover: NgbPopover | null;
    get isDropdownActive(): boolean | undefined;
    constructor(cdr: ChangeDetectorRef);
    private refreshWidth;
    onTitleClick(): void;
    onToggleInput(): void;
    onPopoverClosed(): void;
    handleDropdownOpenCloseClick(dropdownPopover: NgbPopover): void;
    preventPopoverClosing(event: MouseEvent): void;
    onPrevious(): void;
    onNext(): void;
    onSearchText(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaDetailsTitleCardComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaDetailsTitleCardComponent<any>, "app-ca-details-title-card", never, { "dropdownTemplate": { "alias": "dropdownTemplate"; "required": false; }; "titleTemplate": { "alias": "titleTemplate"; "required": false; }; "detailsTitleCardConfig": { "alias": "detailsTitleCardConfig"; "required": false; }; }, { "onNextAction": "onNextAction"; "onPreviousAction": "onPreviousAction"; "onSearchTextChange": "onSearchTextChange"; }, never, never, true, never>;
}

declare class CaCustomCardComponent<T> implements OnDestroy {
    headerLeftSideTemplate: TemplateRef<T>;
    headerRightSideTemplate: TemplateRef<T>;
    headerLeftSideContext: any;
    headerRightSideClass: string;
    cardHeight: number;
    isAnimationsDisabled: boolean;
    cardName: string;
    cardSubText: string | null;
    hasArrow: boolean;
    hasPlusIcon: boolean;
    isPlusIconDisabled: boolean;
    plusIconTooltip: string;
    isHeaderSvgEnabled: boolean;
    counter: number;
    hasDivider: boolean;
    hasBodyData: boolean;
    hasScrollBody: boolean;
    isStayOpen: boolean;
    isDisabledCard: boolean;
    isHeaderHidden?: boolean;
    isTwoRowTitle?: boolean;
    isAlwaysOpen: boolean;
    isShowArrowOnHover?: boolean;
    animationMarginParams: {
        marginTop: string;
        marginBottom: string;
    };
    set isCardOpen(value: boolean);
    customClass: string;
    customNameClass: string;
    customDividerClass: string;
    onActionEvent: EventEmitter<{
        check: boolean;
        action: string;
    }>;
    onOpenCard: EventEmitter<boolean>;
    private isCardOpenAnimatedTimeout;
    private isCardClicked;
    isHeaderHover: boolean;
    noActive: string;
    _isCardOpen: boolean;
    isCardOpenAnimated: boolean;
    isCardHover: boolean;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eColor: typeof eColor;
    ePosition: typeof ePosition;
    eGeneralActions: typeof eGeneralActions;
    constructor();
    private updateCardAnimationState;
    onIsCardOpenChange(value: boolean): void;
    isCardOpenEvent(event: MouseEvent): void;
    onPlusIconClick(event: MouseEvent): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaCustomCardComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaCustomCardComponent<any>, "app-ca-custom-card", never, { "headerLeftSideTemplate": { "alias": "headerLeftSideTemplate"; "required": false; }; "headerRightSideTemplate": { "alias": "headerRightSideTemplate"; "required": false; }; "headerLeftSideContext": { "alias": "headerLeftSideContext"; "required": false; }; "headerRightSideClass": { "alias": "headerRightSideClass"; "required": false; }; "cardHeight": { "alias": "cardHeight"; "required": false; }; "isAnimationsDisabled": { "alias": "isAnimationsDisabled"; "required": false; }; "cardName": { "alias": "cardName"; "required": false; }; "cardSubText": { "alias": "cardSubText"; "required": false; }; "hasArrow": { "alias": "hasArrow"; "required": false; }; "hasPlusIcon": { "alias": "hasPlusIcon"; "required": false; }; "isPlusIconDisabled": { "alias": "isPlusIconDisabled"; "required": false; }; "plusIconTooltip": { "alias": "plusIconTooltip"; "required": false; }; "isHeaderSvgEnabled": { "alias": "isHeaderSvgEnabled"; "required": false; }; "counter": { "alias": "counter"; "required": false; }; "hasDivider": { "alias": "hasDivider"; "required": false; }; "hasBodyData": { "alias": "hasBodyData"; "required": false; }; "hasScrollBody": { "alias": "hasScrollBody"; "required": false; }; "isStayOpen": { "alias": "isStayOpen"; "required": false; }; "isDisabledCard": { "alias": "isDisabledCard"; "required": false; }; "isHeaderHidden": { "alias": "isHeaderHidden"; "required": false; }; "isTwoRowTitle": { "alias": "isTwoRowTitle"; "required": false; }; "isAlwaysOpen": { "alias": "isAlwaysOpen"; "required": false; }; "isShowArrowOnHover": { "alias": "isShowArrowOnHover"; "required": false; }; "animationMarginParams": { "alias": "animationMarginParams"; "required": false; }; "isCardOpen": { "alias": "isCardOpen"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "customNameClass": { "alias": "customNameClass"; "required": false; }; "customDividerClass": { "alias": "customDividerClass"; "required": false; }; }, { "onActionEvent": "onActionEvent"; "onOpenCard": "onOpenCard"; }, never, ["*"], true, never>;
}

declare class CaLoadStatusLogComponent {
    loadStatusHistory: LoadStatusHistoryResponse[];
    onSortChange: EventEmitter<string>;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eSharedString: typeof eSharedString;
    sortDirection: eSharedString;
    constructor();
    onSortClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaLoadStatusLogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaLoadStatusLogComponent, "app-ca-load-status-log", never, { "loadStatusHistory": { "alias": "loadStatusHistory"; "required": false; }; }, { "onSortChange": "onSortChange"; }, never, never, true, never>;
}

interface LoadStatusResponse {
    statusValue?: EnumValue;
    statusString?: string | null;
    statusCheckInNumber?: string | null;
}

interface LoadPossibleStatusesResponse {
    possibleStatuses?: Array<LoadStatusResponse> | null;
    previousStatus?: LoadStatusResponse;
}

declare class CaStatusChangeDropdownComponent {
    statuses?: LoadPossibleStatusesResponse;
    width?: number;
    isDispatchStatus: boolean;
    currentStatus?: LoadStatusResponse;
    currentStatusTime: string;
    onNextStatus: EventEmitter<LoadStatusResponse>;
    onPreviousStatus: EventEmitter<LoadStatusResponse>;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    constructor();
    onNextStatusEvent(status: LoadStatusResponse): void;
    onPreviousStatusEvent(status?: LoadStatusResponse): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaStatusChangeDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaStatusChangeDropdownComponent, "app-ca-status-change-dropdown", never, { "statuses": { "alias": "statuses"; "required": false; }; "width": { "alias": "width"; "required": false; }; "isDispatchStatus": { "alias": "isDispatchStatus"; "required": false; }; "currentStatus": { "alias": "currentStatus"; "required": false; }; "currentStatusTime": { "alias": "currentStatusTime"; "required": false; }; }, { "onNextStatus": "onNextStatus"; "onPreviousStatus": "onPreviousStatus"; }, never, never, true, never>;
}

interface IDropdownItem {
    id?: number;
    title: string;
    count: number;
    isSelected: boolean;
    isCountHidden?: boolean;
    avatar?: string;
    icon?: string;
    iconColor?: string;
    avatarColor?: {
        background?: string;
        color?: string;
    };
}

declare class CaToolbarDropdownComponent implements OnInit, AfterViewInit, OnDestroy {
    private formBuilder;
    componentWrapperRef: ElementRef<HTMLInputElement>;
    set dropdownOptions(value: IDropdownItem[]);
    hasInitials: boolean;
    onDropdownItemSelect: EventEmitter<IDropdownItem>;
    searchForm: UntypedFormGroup;
    searchTerm: string;
    searchFormControl: AbstractControl | null;
    isExpanded: boolean;
    isTitleHovered: boolean;
    dropdownItemHoverId: number | undefined;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    dropDownOptions: IDropdownItem[];
    parentWidth: number;
    parentHeight: number;
    eAnimationState: typeof eAnimationState;
    ePosition: typeof ePosition;
    eGeneralActions: typeof eGeneralActions;
    eUnit: typeof eUnit;
    eColor: typeof eColor;
    private destroy$;
    selectedItem: IDropdownItem | null;
    constructor(formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private getParentElementDimensions;
    private createForm;
    onDocumentClick(event: Event): void;
    toggleOptionsVisibility(): void;
    onSelectDropdownItem(selectedItem: IDropdownItem): void;
    onDropdownItemHover(id: number | undefined): void;
    clearSearch(): void;
    onTitleHover(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaToolbarDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaToolbarDropdownComponent, "ca-toolbar-dropdown", never, { "dropdownOptions": { "alias": "dropdownOptions"; "required": false; }; "hasInitials": { "alias": "hasInitials"; "required": false; }; }, { "onDropdownItemSelect": "onDropdownItemSelect"; }, never, never, true, never>;
}

interface IFile {
    fileId: number;
    fileName: string;
    fileSize: number;
    tagGeneratedByUser: boolean;
    tags: string[];
    updatedAt: string;
    url: string;
    hover: boolean;
    ext?: string;
}

interface IModalData {
    title?: string;
    count?: number;
    status?: LoadStatusResponse;
    loadNumber?: string;
    truckNumber?: string;
    file?: IFile;
}

declare enum eModalButtonClassType {
    PRIMARY_POSITIVE = "primary-positive",
    PRIMARY_NEUTRAL = "primary-neutral",
    PRIMARY_NEGATIVE = "primary-negative",
    PRIMARY_WHITE = "primary-white",
    SECONDARY_POSITIVE = "secondary-positive",
    SECONDARY_NEUTRAL = "secondary-neutral",
    SECONDARY_NEGATIVE = "secondary-negative",
    PLAIN_TEXT = "plain-text",
    SPECIAL_POSITIVE = "special-positive",
    SPECIAL_NEUTRAL = "special-neutral"
}

declare enum eModalButtonSize {
    SMALL = "modal-small",
    NORMAL = "modal-normal",
    FULL_WIDTH = "modal-full-width",
    BIG_FULL_WIDTH = "modal-big-full-width",
    SPECIAL_SMALL = "special-small",
    SPECIAL_DEFAULT = "special-default",
    SPECIAL_DEFAULT_FULL_WIDTH = "special-default-full-width"
}

declare class CaDeleteModalComponent {
    private ngbActiveModal;
    modalData: IModalData;
    template: TemplateRef<null>;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eModalButtonClassType: typeof eModalButtonClassType;
    eModalButtonSize: typeof eModalButtonSize;
    constructor(ngbActiveModal: NgbActiveModal);
    onModalAction(isDoAction?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaDeleteModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaDeleteModalComponent, "app-ca-delete-modal", never, { "modalData": { "alias": "modalData"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaShowMoreComponent {
    displayedDataCount: number;
    totalDataCount: number;
    onShowMore: EventEmitter<boolean>;
    eGeneralActions: typeof eGeneralActions;
    constructor();
    onShowMoreClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaShowMoreComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaShowMoreComponent, "app-ca-show-more", never, { "displayedDataCount": { "alias": "displayedDataCount"; "required": false; }; "totalDataCount": { "alias": "totalDataCount"; "required": false; }; }, { "onShowMore": "onShowMore"; }, never, never, true, never>;
}

interface IComment {
    id: number;
    commentId?: number;
    companyUser: ICompanyUser;
    commentContent: string;
    isEdited: boolean;
    isNew?: boolean;
    isMe?: boolean;
    isCommenting?: boolean;
    downRatingCount?: number;
    upRatingCount?: number;
    currentCompanyUserRating?: number;
    isDriver?: boolean;
    createdAt: string;
    updatedAt?: string;
}

declare class CaCommentsComponent {
    isDarkmode: boolean;
    isSearchDisplayed: boolean;
    isDriverTab: boolean;
    isModal: boolean;
    commentCount: number;
    set comments(value: IComment[]);
    set currentUser(value: IUser);
    set hasNewComment(value: boolean);
    onCommentDelete: EventEmitter<number>;
    onCommentAdded: EventEmitter<IComment>;
    onCommentEdited: EventEmitter<IComment>;
    onCommentCancel: EventEmitter<any>;
    onCommentSearchCancel: EventEmitter<any>;
    _comments: IComment[];
    _currentUser: IUser;
    eSharedString: typeof eSharedString;
    eAnimationState: typeof eAnimationState;
    eDateTimeFormats: typeof eDateTimeFormats;
    eGeneralActions: typeof eGeneralActions;
    eColor: typeof eColor;
    ePosition: typeof ePosition;
    eStringPlaceholder: typeof eStringPlaceholder;
    sortDirection: eSharedString.ASC | eSharedString.DSC;
    commentExpanded: IComment | null;
    commentAddOrEdit: IComment | null;
    commentAction: eGeneralActions.ADD | eGeneralActions.EDIT | null;
    commentContentFormControl: FormControl<any>;
    searchCommentFormControl: FormControl<any>;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    constructor();
    onToggleSort(): void;
    onDeleteComment(comment: IComment): void;
    onExpandComment(comment: IComment): void;
    onAddNewComment(): void;
    onEditComment(comment: IComment): void;
    clearCommentAddOrEdit(): void;
    onClearSearch(event: Event): void;
    confirmComment(comment: IComment): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaCommentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaCommentsComponent, "ca-comments", never, { "isDarkmode": { "alias": "isDarkmode"; "required": false; }; "isSearchDisplayed": { "alias": "isSearchDisplayed"; "required": false; }; "isDriverTab": { "alias": "isDriverTab"; "required": false; }; "isModal": { "alias": "isModal"; "required": false; }; "commentCount": { "alias": "commentCount"; "required": false; }; "comments": { "alias": "comments"; "required": false; }; "currentUser": { "alias": "currentUser"; "required": false; }; "hasNewComment": { "alias": "hasNewComment"; "required": false; }; }, { "onCommentDelete": "onCommentDelete"; "onCommentAdded": "onCommentAdded"; "onCommentEdited": "onCommentEdited"; "onCommentCancel": "onCommentCancel"; "onCommentSearchCancel": "onCommentSearchCancel"; }, never, ["*"], true, never>;
}

type SortOrder = 'Ascending' | 'Descending';
declare const SortOrder: {
    Ascending: SortOrder;
    Descending: SortOrder;
};

interface ITableColumn {
    id?: number;
    key: string;
    width?: number;
    minWidth?: number;
    maxWidth?: number;
    label: string;
    pinned?: 'left' | 'right';
    hasSort?: boolean;
    direction?: SortOrder | null;
    isResizable?: boolean;
    isAlignedRight?: boolean;
    columns?: ITableColumn[];
    isDisabled?: boolean;
    isChecked?: boolean;
    labelToolbar?: string;
    sortName?: string;
    removeSort?: boolean;
}

declare class CaSortingCardDropdownComponent {
    options: ITableColumn[];
    isDisabled: boolean;
    onSortChange: EventEmitter<ITableColumn | null>;
    onSelectItem: EventEmitter<ITableColumn | null>;
    dropdownPopover: NgbPopover | null;
    selectedItem: ITableColumn | null;
    hoveredItem: ITableColumn | null;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eSharedString: typeof eSharedString;
    ePosition: typeof ePosition;
    eColor: typeof eColor;
    eGeneralActions: typeof eGeneralActions;
    sortDirection: eSharedString;
    get isDropdownActive(): boolean | undefined;
    onSortClick(event: MouseEvent): void;
    handleDropdownOpenCloseClick(dropdownPopover: NgbPopover): void;
    onSelectItemClick(item: ITableColumn): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaSortingCardDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaSortingCardDropdownComponent, "app-ca-sorting-card-dropdown", never, { "options": { "alias": "options"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; }, { "onSortChange": "onSortChange"; "onSelectItem": "onSelectItem"; }, never, never, true, never>;
}

declare class CaActivateModalComponent {
    private ngbActiveModal;
    modalData: IModalData;
    template: TemplateRef<null>;
    isOpenBusinessModal: boolean;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eModalButtonClassType: typeof eModalButtonClassType;
    eModalButtonSize: typeof eModalButtonSize;
    constructor(ngbActiveModal: NgbActiveModal);
    onModalAction(isDoAction?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaActivateModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaActivateModalComponent, "app-ca-active-modal", never, { "modalData": { "alias": "modalData"; "required": false; }; "template": { "alias": "template"; "required": false; }; "isOpenBusinessModal": { "alias": "isOpenBusinessModal"; "required": false; }; }, {}, never, never, true, never>;
}

interface IConfirmationModalButtons {
    label: string;
    type: eModalButtonClassType;
    actionValue?: boolean;
}

declare class CaDeactivateModalComponent {
    private ngbActiveModal;
    modalData: IModalData;
    template: TemplateRef<null>;
    isCloseBusinessModal: boolean;
    isInfoIcon: boolean;
    modalButtons: IConfirmationModalButtons[];
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eModalButtonClassType: typeof eModalButtonClassType;
    eModalButtonSize: typeof eModalButtonSize;
    constructor(ngbActiveModal: NgbActiveModal);
    onModalAction(isDoAction?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaDeactivateModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaDeactivateModalComponent, "app-ca-deactivate-modal", never, { "modalData": { "alias": "modalData"; "required": false; }; "template": { "alias": "template"; "required": false; }; "isCloseBusinessModal": { "alias": "isCloseBusinessModal"; "required": false; }; "isInfoIcon": { "alias": "isInfoIcon"; "required": false; }; "modalButtons": { "alias": "modalButtons"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaVoidModalComponent {
    private ngbActiveModal;
    modalData: IModalData;
    template: TemplateRef<null>;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eModalButtonClassType: typeof eModalButtonClassType;
    eModalButtonSize: typeof eModalButtonSize;
    constructor(ngbActiveModal: NgbActiveModal);
    onModalAction(isDoAction?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaVoidModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaVoidModalComponent, "app-ca-void-modal", never, { "modalData": { "alias": "modalData"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaMoveModalComponent {
    private ngbActiveModal;
    modalData: IModalData;
    template: TemplateRef<null>;
    isRemoveModal: boolean;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eModalButtonClassType: typeof eModalButtonClassType;
    eModalButtonSize: typeof eModalButtonSize;
    constructor(ngbActiveModal: NgbActiveModal);
    onModalAction(isDoAction?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaMoveModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaMoveModalComponent, "app-ca-move-modal", never, { "modalData": { "alias": "modalData"; "required": false; }; "template": { "alias": "template"; "required": false; }; "isRemoveModal": { "alias": "isRemoveModal"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaResetTableModalComponent {
    private ngbActiveModal;
    modalData: IModalData;
    template: TemplateRef<null>;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eModalButtonClassType: typeof eModalButtonClassType;
    eModalButtonSize: typeof eModalButtonSize;
    constructor(ngbActiveModal: NgbActiveModal);
    onModalAction(isDoAction?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaResetTableModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaResetTableModalComponent, "app-ca-reset-table-modal", never, { "modalData": { "alias": "modalData"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaFilesCountComponent {
    rowId: number | null;
    filesCount: number;
    hasCount: boolean;
    isCardView: boolean;
    onFilesCountAction: EventEmitter<number | null>;
    ePosition: typeof ePosition;
    eColor: typeof eColor;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    onFilesCountClick(rowId: number | null): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaFilesCountComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaFilesCountComponent, "app-ca-files-count", never, { "rowId": { "alias": "rowId"; "required": false; }; "filesCount": { "alias": "filesCount"; "required": false; }; "hasCount": { "alias": "hasCount"; "required": false; }; "isCardView": { "alias": "isCardView"; "required": false; }; }, { "onFilesCountAction": "onFilesCountAction"; }, never, never, true, never>;
}

interface PMTrailerShortResponse {
    trailerId?: number | null;
    id?: number;
    title?: string | null;
    status?: EnumValue;
    logoName?: string | null;
}

interface PMTruckShortResponse {
    truckId?: number | null;
    id?: number;
    title?: string | null;
    status?: EnumValue;
    logoName?: string | null;
}

interface IItemsDropdownList {
    [key: string]: any;
    id: number;
    description?: string;
    nickname?: string;
    pmTruck: PMTruckShortResponse;
    pmTrailer: PMTrailerShortResponse;
}

interface IItemsDropdownConfig {
    gridItems: (string | number)[] | null;
    gridValues: string | null;
    gridResponsePropertiesToDisplay?: string[] | null;
    hasTotal?: boolean;
    isAlignRightDisabled?: boolean;
}

declare class CaItemsDropdownComponent<T extends IItemsDropdownList> {
    set itemsDropdownConfig(value: IItemsDropdownConfig | null);
    itemsDropdownList: T[];
    itemsSpecialStylesIndexArray?: number[];
    minimisedVariationDropdownTemplate: TemplateRef<{
        data: T[];
    }>;
    columnWidth: number;
    dropdownWidth: number;
    tooltipText: string;
    itemsDropdownAction: EventEmitter<boolean>;
    _itemsDropdownConfig: IItemsDropdownConfig | null;
    dropdownItemsToDisplay: string | number[][];
    ePosition: typeof ePosition;
    eColor: typeof eColor;
    eStringPlaceholder: typeof eStringPlaceholder;
    eUnit: typeof eUnit;
    private updateDropdownItemsToDisplay;
    handleDropdownOpenCloseClick(dropdownPopover: NgbPopover): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaItemsDropdownComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaItemsDropdownComponent<any>, "ca-items-dropdown", never, { "itemsDropdownConfig": { "alias": "itemsDropdownConfig"; "required": false; }; "itemsDropdownList": { "alias": "itemsDropdownList"; "required": false; }; "itemsSpecialStylesIndexArray": { "alias": "itemsSpecialStylesIndexArray"; "required": false; }; "minimisedVariationDropdownTemplate": { "alias": "minimisedVariationDropdownTemplate"; "required": false; }; "columnWidth": { "alias": "columnWidth"; "required": false; }; "dropdownWidth": { "alias": "dropdownWidth"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; }, { "itemsDropdownAction": "itemsDropdownAction"; }, never, never, true, never>;
}

declare enum eToastType {
    ADD = "add",
    EDIT = "edit",
    DELETE = "delete",
    ACTIVATE = "activate"
}

declare class CaToastMessagesComponent {
    type: eToastType;
    toastTitle: string;
    toastMessage: string;
    additionalMessage: string;
    isFailedMessage: boolean;
    isStorybookExample: boolean;
    set toastIndex(value: number);
    set toastLength(value: number);
    removeToast: EventEmitter<void>;
    tryAgain: EventEmitter<void>;
    private autoCloseTimer;
    isVisible: boolean;
    isHoverActive: boolean;
    _toastIndex: number;
    _toastLength: number;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    constructor();
    handleToastHover(isHover: boolean): void;
    startCloseAnimation(): void;
    onAnimationDone(): void;
    private startAutoCloseTimer;
    onTryAgain(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaToastMessagesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaToastMessagesComponent, "app-ca-toast-messages", never, { "type": { "alias": "type"; "required": false; }; "toastTitle": { "alias": "toastTitle"; "required": false; }; "toastMessage": { "alias": "toastMessage"; "required": false; }; "additionalMessage": { "alias": "additionalMessage"; "required": false; }; "isFailedMessage": { "alias": "isFailedMessage"; "required": false; }; "isStorybookExample": { "alias": "isStorybookExample"; "required": false; }; "toastIndex": { "alias": "toastIndex"; "required": false; }; "toastLength": { "alias": "toastLength"; "required": false; }; }, { "removeToast": "removeToast"; "tryAgain": "tryAgain"; }, never, never, true, never>;
}

declare enum eFleetFilterItemType {
    TRUCK = "truck",
    TRAILER = "trailer"
}

interface IFleetFilterTrailerType {
    id?: number;
    companyId?: number | null;
    hasVolume?: boolean;
    logoName?: string;
    name?: string;
}

interface IFleetFilterTrailer {
    id?: number;
    trailerNumber?: string;
    trailerType?: IFleetFilterTrailerType;
}

interface IFleetFilterTruckType {
    id?: number;
    companyId?: number | null;
    logoName?: string;
    name?: string;
}

interface IFleetFilterTruck {
    id?: number;
    truckNumber?: string;
    truckType?: IFleetFilterTruckType;
}

interface IFleetFilterData {
    trailerCount: number;
    truckCount: number;
    trailers: IFleetFilterTrailer[];
    trucks: IFleetFilterTruck[];
}

interface IFleetFilterItemEmit {
    itemId: number;
    type: eFleetFilterItemType;
}

declare class FleetFilterSvgRoutes {
    static truckIcon: string;
    static trailerIcon: string;
    static trucksFolder: string;
    static trailersFolder: string;
}

declare class CaFleetFilterComponent implements OnInit, OnDestroy {
    private formBuilder;
    set fleetFilterData(value: IFleetFilterData);
    onItemClick: EventEmitter<IFleetFilterItemEmit>;
    private destroy$;
    private activeSortName;
    private activeSortDirection;
    truckCount: number;
    trailerCount: number;
    trucks: IFleetFilterTruck[];
    trailers: IFleetFilterTrailer[];
    filteredTrucks: IFleetFilterTruck[];
    filteredTrailers: IFleetFilterTrailer[];
    fleetFilterPopover: NgbPopover | null;
    searchForm: UntypedFormGroup;
    isTruckCardOpen: boolean;
    isTrailerCardOpen: boolean;
    isSearchActive: boolean;
    sortColumns: SortColumn[];
    dropdownMenuSvgRoutes: typeof FleetFilterSvgRoutes;
    eSharedString: typeof eSharedString;
    eFleetFilterItemType: typeof eFleetFilterItemType;
    searchInputConfig: ICaInput$1;
    constructor(formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    private createFormAndSort;
    private watchSearchFormValueChanges;
    onFleetFilterOpenCloseClick(fleetFilterPopover: NgbPopover): void;
    clearInput(event: boolean): void;
    handleSortClick(event: {
        column: SortColumn;
        sortName: string;
        direction: string;
    }): void;
    onOpenCard(isOpen: boolean, type: eSharedString): void;
    onItemClickEmit(itemId: number | undefined, type: eFleetFilterItemType): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaFleetFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaFleetFilterComponent, "app-ca-fleet-filter", never, { "fleetFilterData": { "alias": "fleetFilterData"; "required": false; }; }, { "onItemClick": "onItemClick"; }, never, never, true, never>;
}

/**
 * Custom horizontal scrollbar that stays in sync with a scrollable element.
 * Use when you need a sticky scrollbar (e.g. below the content) instead of the native one.
 *
 * Usage:
 *   - Give the scrollable element a template ref (e.g. #scrollableEl).
 *   - Pass it: [scrollableElement]="scrollableElRef?.nativeElement"
 *   - Optionally: [trackRightOffsetPx]="70" to shorten the track from the right.
 */
declare class CaCustomHorizontalScrollbarComponent {
    scrollableElement: i0.InputSignal<HTMLElement | null | undefined>;
    trackRightOffsetPx: i0.InputSignal<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaCustomHorizontalScrollbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaCustomHorizontalScrollbarComponent, "app-ca-custom-horizontal-scrollbar", never, { "scrollableElement": { "alias": "scrollableElement"; "required": false; "isSignal": true; }; "trackRightOffsetPx": { "alias": "trackRightOffsetPx"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface IModalItemsConfig {
    cardName?: string;
    cardSubText?: string;
    hasNoCardVariation?: boolean;
    isDisabled?: boolean;
    isAlwaysOpen?: boolean;
    isDividerHidden?: boolean;
    stickyGridTemplateColumnValues?: string;
    gridTemplateColumnValues?: string;
    singleListItemGridTemplateColumnValues?: string;
    headerItems: string[];
    headerItemsRequiredIndex?: number[];
    stickyHeaderItemsRequiredIndex?: number[];
    headerItemsAlignRightIndex?: number[];
    headerItemsAlignLeftIndex?: number[];
    headerItemsJustifyCenterIndex?: number[];
    noDataImage?: string;
    noDataImageDimensions?: {
        width: string;
        height: string;
    };
}

interface IItemsRowTemplate {
    $implicit: AbstractControl;
    index: number;
    hoverIndex: number;
    parentFormArrayIndex: number | null;
}

declare class CaModalItemsComponent implements OnInit {
    scrollableColumnsRef?: ElementRef<HTMLElement>;
    set itemsConfig(value: IModalItemsConfig);
    itemsRowTemplate: TemplateRef<IItemsRowTemplate>;
    stickyItemsRowTemplate: TemplateRef<IItemsRowTemplate>;
    itemsFormArray: UntypedFormArray;
    itemsTotalValue: number;
    parentFormArrayIndex?: number | null;
    onItemsAction: EventEmitter<string>;
    _itemsConfig: IModalItemsConfig;
    scrollbarTrackRightOffsetPx: number;
    hoverIndex: number;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eGeneralActions: typeof eGeneralActions;
    eStringPlaceholder: typeof eStringPlaceholder;
    private DEFAULT_LIST_LENGTH;
    listLength: number;
    displayedListLength: number;
    scrollableElement: HTMLElement | null;
    constructor();
    ngOnInit(): void;
    private initializeListLength;
    onShowMore(): void;
    onItemsRowAdd(): void;
    onItemsRowHover(index: number): void;
    onItemsRowReorder(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaModalItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaModalItemsComponent, "app-ca-modal-items", never, { "itemsConfig": { "alias": "itemsConfig"; "required": false; }; "itemsRowTemplate": { "alias": "itemsRowTemplate"; "required": false; }; "stickyItemsRowTemplate": { "alias": "stickyItemsRowTemplate"; "required": false; }; "itemsFormArray": { "alias": "itemsFormArray"; "required": false; }; "itemsTotalValue": { "alias": "itemsTotalValue"; "required": false; }; "parentFormArrayIndex": { "alias": "parentFormArrayIndex"; "required": false; }; }, { "onItemsAction": "onItemsAction"; }, never, never, true, never>;
}

interface IRangeSliderConfig {
    title: string;
    unit: string;
    min: number;
    max: number;
    step: number;
}

declare class CaRangeSliderComponent implements ControlValueAccessor {
    rangeSliderConfig: IRangeSliderConfig;
    isDisabled: boolean;
    rangeSliderChange: EventEmitter<number>;
    value: number;
    constructor();
    private onChange;
    private onTouched;
    writeValue(value: number): void;
    registerOnChange(fn: (value: number) => void): void;
    registerOnTouched(fn: () => void): void;
    onRangeSliderChange(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaRangeSliderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaRangeSliderComponent, "app-ca-range-slider", never, { "rangeSliderConfig": { "alias": "rangeSliderConfig"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; }, { "rangeSliderChange": "rangeSliderChange"; }, never, never, true, never>;
}

interface IFuelPricesRangeConfig {
    value: number;
    minValue: number;
    maxValue: number;
    isOutdated: boolean;
}

declare class CaFuelPricesRangeComponent {
    fuelPricesRangeConfig: IFuelPricesRangeConfig;
    isCardVariation: boolean;
    isFuelLastPriceHovered: boolean;
    fuelPricesRangeCircleSvgClassColor: Record<string, string>;
    fuelPricesRangeArrowSvgClassColor: Record<string, string>;
    fuelPricesRangeColor: string[];
    sharedSvgRoutes: typeof SharedSvgRoutes;
    eUnit: typeof eUnit;
    constructor();
    onHoverFuelLastPrice(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaFuelPricesRangeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaFuelPricesRangeComponent, "app-ca-fuel-prices-range", never, { "fuelPricesRangeConfig": { "alias": "fuelPricesRangeConfig"; "required": false; }; "isCardVariation": { "alias": "isCardVariation"; "required": false; }; }, {}, never, never, true, never>;
}

interface IMapState {
    color?: string;
    state?: string;
    value?: string | null;
    percent?: string | null;
}
interface IMapStates {
    [stateAbbreviation: string]: IMapState;
}

interface ITopListByStateItem {
    id: number;
    index: number;
    stateCode: string;
    state: string;
    value?: string;
    numberValue?: number;
    percent?: string;
    color?: string;
    isActive?: boolean;
}

declare enum ePlacement {
    AUTO = "auto",
    TOP = "top",
    TOP_START = "top-start",
    TOP_LEFT = "top-left",
    TOP_END = "top-end",
    TOP_RIGHT = "top-right",
    BOTTOM = "bottom",
    BOTTOM_START = "bottom-start",
    BOTTOM_LEFT = "bottom-left",
    BOTTOM_END = "bottom-end",
    BOTTOM_RIGHT = "bottom-right",
    START = "start",
    LEFT = "left",
    START_TOP = "start-top",
    LEFT_TOP = "left-top",
    START_BOTTOM = "start-bottom",
    LEFT_BOTTOM = "left-bottom",
    END = "end",
    RIGHT = "right",
    END_TOP = "end-top",
    RIGHT_TOP = "right-top",
    END_BOTTOM = "end-bottom",
    RIGHT_BOTTOM = "right-bottom"
}

declare class CaHeatmapUsaComponent {
    svgElement: ElementRef<SVGElement>;
    set stateItems(value: ITopListByStateItem[]);
    /** Input to receive hovered state code from external source (e.g., table) */
    set hoveredStateCode(stateCode: string | null);
    /** Emits the currently hovered state when hovering on the map */
    stateHover: EventEmitter<{
        item: ITopListByStateItem;
        isHovered: boolean;
    }>;
    private renderer;
    private _hoveredStateCode;
    usaStates: IMapStates;
    _stateItems: ITopListByStateItem[];
    currentlyHoveredElement: SVGPathElement | null;
    currentlyHoveredState: IMapState | null;
    ePlacement: typeof ePlacement;
    get hoveredStateCode(): string | null;
    private mapUsaStates;
    private applyHover;
    private clearHover;
    private clearHoverStyling;
    private handleExternalHover;
    onStateHover(stateCode: string, isRemovingHover: boolean, event?: MouseEvent, stateElement?: Element): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaHeatmapUsaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaHeatmapUsaComponent, "app-ca-heatmap-usa", never, { "stateItems": { "alias": "stateItems"; "required": false; }; "hoveredStateCode": { "alias": "hoveredStateCode"; "required": false; }; }, { "stateHover": "stateHover"; }, never, never, true, never>;
}

declare class CaComponentsLibModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CaComponentsLibModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CaComponentsLibModule, never, [typeof i1.CommonModule, typeof CaProfileImageComponent, typeof CaProgressBarV2Component, typeof CaRatingReviewComponent, typeof CaAppTooltipV2Component, typeof CaDetailsDropdownComponent, typeof CaFilterComponent, typeof CaFilterDropdownComponent, typeof CaFilterStateDropdownComponent, typeof CaFilterListDropdownComponent, typeof CaInputComponent, typeof CaInputDatetimePickerComponent, typeof CaInputRadiobuttonsComponent, typeof CaInputDropdownComponent, typeof CaMapComponent, typeof CaMapDropdownComponent, typeof CaNoteComponent, typeof CaNoteContainerComponent, typeof CaPayrollListSummaryOverviewComponent, typeof CaPayrollListSummaryOverviewTableComponent, typeof PickupDeliveryBlockComponent, typeof ProgressBarComponent, typeof CaSearchMultipleStatesComponent, typeof CaSearchMultipleStates2Component, typeof CaTableCardViewComponent, typeof CaSpinnerComponent, typeof CaTodoComponent, typeof CaTruckTrailerProgresBarComponent, typeof CaPeriodContentComponent, typeof CaInputNoteComponent, typeof CaInputAddressDropdownComponent, typeof CaMainTableComponent, typeof CaActivityLogListComponent, typeof CaRightSidePanelMenuComponent, typeof CaRightSidePanelTopBarComponent, typeof CaRightSidePanelComponent, typeof CaChartComponent, typeof CaChartManagerComponent, typeof CaDropdownMenuComponent, typeof CaUploadFilesComponent, typeof CaRightSidePanelCompanyComponent, typeof CaTooltipListComponent, typeof InputTestComponent, typeof CaVehicleListComponent, typeof CaLastFuelPriceProgressComponent, typeof CaCheckboxComponent, typeof CaLoadStatusComponent, typeof CaCheckboxSelectedCountComponent, typeof CaDetailsTitleCardComponent, typeof CaCustomCardComponent, typeof CaLoadStatusLogComponent, typeof CaStatusChangeDropdownComponent, typeof CaToolbarDropdownComponent, typeof CaDeleteModalComponent, typeof CaShowMoreComponent, typeof CaCommentsComponent, typeof CaSortingCardDropdownComponent, typeof CaActivateModalComponent, typeof CaDeactivateModalComponent, typeof CaVoidModalComponent, typeof CaMoveModalComponent, typeof CaResetTableModalComponent, typeof CaFilesCountComponent, typeof CaItemsDropdownComponent, typeof CaToastMessagesComponent, typeof CaFleetFilterComponent, typeof CaCustomHorizontalScrollbarComponent, typeof CaModalItemsComponent, typeof CaRangeSliderComponent, typeof CaFuelPricesRangeComponent, typeof CaHeatmapUsaComponent], [typeof CaProgressBarV2Component, typeof CaProfileImageComponent, typeof CaAppTooltipV2Component, typeof CaDetailsDropdownComponent, typeof CaRatingReviewComponent, typeof CaFilterComponent, typeof CaFilterDropdownComponent, typeof CaFilterStateDropdownComponent, typeof CaFilterListDropdownComponent, typeof CaInputComponent, typeof CaInputDatetimePickerComponent, typeof CaInputRadiobuttonsComponent, typeof CaInputDropdownComponent, typeof CaMapComponent, typeof CaMapDropdownComponent, typeof CaNoteComponent, typeof CaNoteContainerComponent, typeof CaPayrollListSummaryOverviewComponent, typeof CaPayrollListSummaryOverviewTableComponent, typeof PickupDeliveryBlockComponent, typeof ProgressBarComponent, typeof CaSearchMultipleStatesComponent, typeof CaSearchMultipleStates2Component, typeof CaSpinnerComponent, typeof CaTruckTrailerProgresBarComponent, typeof CaPeriodContentComponent, typeof CaInputNoteComponent, typeof CaMainTableComponent, typeof CaActivityLogListComponent, typeof CaRightSidePanelMenuComponent, typeof CaRightSidePanelTopBarComponent, typeof CaRightSidePanelComponent, typeof CaChartComponent, typeof CaChartManagerComponent, typeof CaDropdownMenuComponent, typeof CaUploadFilesComponent, typeof CaRightSidePanelCompanyComponent, typeof CaTooltipListComponent, typeof CaInputAddressDropdownComponent, typeof InputTestComponent, typeof CaVehicleListComponent, typeof CaLastFuelPriceProgressComponent, typeof CaCheckboxComponent, typeof CaLoadStatusComponent, typeof CaCheckboxSelectedCountComponent, typeof CaDetailsTitleCardComponent, typeof CaCustomCardComponent, typeof CaLoadStatusLogComponent, typeof CaStatusChangeDropdownComponent, typeof CaToolbarDropdownComponent, typeof CaDeleteModalComponent, typeof CaCommentsComponent, typeof CaShowMoreComponent, typeof CaSortingCardDropdownComponent, typeof CaActivateModalComponent, typeof CaDeactivateModalComponent, typeof CaVoidModalComponent, typeof CaMoveModalComponent, typeof CaResetTableModalComponent, typeof CaFilesCountComponent, typeof CaItemsDropdownComponent, typeof CaToastMessagesComponent, typeof CaFleetFilterComponent, typeof CaModalItemsComponent, typeof CaRangeSliderComponent, typeof CaFuelPricesRangeComponent, typeof CaHeatmapUsaComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CaComponentsLibModule>;
}

interface IOptionModel {
    id?: number;
    number?: number;
    name?: string;
    fullName?: string;
    type?: string;
    companyName?: string;
    colorId?: number;
    color?: string;
    colorD?: string;
    code?: string;
    class?: string;
    phone?: string;
    count?: number;
    description?: string;
    businessName?: string;
    address?: any;
    longLat?: number;
    logoName?: string;
    dropLabel?: string;
    trailer?: ArrayStatus;
    truck?: ArrayStatus;
    driver?: DriverMinimalResponse;
    isFranchise?: boolean;
    dnu?: boolean;
    ban?: boolean;
    status?: any;
    active?: boolean;
    disabled?: boolean;
    duplicateId?: boolean;
    canOpenModal?: boolean;
    open?: boolean;
    groups?: {
        id?: number;
        name?: string;
    }[];
    contacts?: {
        fullName?: string;
        id?: number;
        name?: string;
        originalPhone?: string;
        phone?: string;
        phoneExt?: string;
        phoneExtension?: string;
        shipperId?: number;
    }[];
    stores?: {
        id?: number | string;
        name?: string;
        address?: string;
    }[];
    folder?: string;
    subFolder?: string;
    isDriver?: boolean;
    additionalText?: string;
    svg?: string;
    referenceNumber?: number | string;
    totalBill?: number | string;
    totalMiles?: number | string;
    totalEarnings?: number | string;
    brokerName?: string;
    hiredAt?: number | string;
    groupName?: string;
    items?: {
        id?: number;
        name?: string;
    }[];
    hoverCode?: string;
    payType?: string;
    itemIndex?: number | string;
    availableCreditType?: {
        id?: number | string;
        name?: string;
    };
    department?: {
        id?: number | string;
        name?: string;
    };
    loadsCount?: number | string;
    hover?: boolean;
    ein?: string | number;
    brand?: string;
    account?: string;
    stopType?: string;
    valueForRequest?: string;
    availableCredit?: string | number;
    creditLimit?: string | number;
    suffix?: string | number;
    truckType?: {
        name?: string;
    };
    activeCounter?: string | number;
    totalCounter?: string | number;
    avatarFile?: FileResponse$1 | null;
    stop?: UntypedFormGroup;
}

type SelectDropdownValueType = {
    option: IOptionModel;
    optionValue?: string;
    label?: string;
    setNotFoundError?: boolean;
};

declare class InputDropdownSvgRoutes {
    static trailersSvgRoute: string;
    static trucksSvgRoute: string;
    static repairPmSvgRoute: string;
    static inputDropdownArrowSvg: string;
    static xClearSvg: string;
    static plusSvg: string;
    static dynamicLabelSvg: string;
    static ownerBadgeBlackSvg: string;
    static arrowDownUpdatedSvg: string;
    static specConfirmSvg: string;
}

declare enum DropdownTemplateTypeEnum {
    SVG_TEMPLATE = "svg-template",
    SVGTEXT_TEMPLATE = "svgtext-template",
    SVGTEXT_DISPATCH_TEMPLATE = "svgtext-dispatch-template",
    DETAILS_TEMPLATE = "details-template",
    GROUPS = "groups",
    MULTISELECT = "multiselect",
    LABELS = "labels",
    DISPATCH = "dispatch",
    LOAD_DISPATCHER = "load-dispatcher",
    LOAD_DISPATCHES_TTD = "load-dispatches-ttd",
    LOAD_BROKER = "load-broker",
    LOAD_BROKER_CONTACT = "load-broker-contact",
    LOAD_SHIPPER = "load-shipper",
    TEXT_COUNTER = "text-counter",
    FUEL_FRANCHISE = "fuel-franchise",
    DOUBLE_TEXT_TEMPLATE = "double-text-template",
    DOUBLE_COLUMN_TEMPLATE = "double-column-template",
    TRIPLE_COLUMN_TEMPLATE = "triple-column-template",
    PAYROLL_TRUCKS = "payroll-trucks"
}

declare class CaInputDropdownTestComponent implements OnInit, AfterViewInit, OnDestroy, ControlValueAccessor, AfterViewInit {
    superControl: NgControl;
    private cdRef;
    private renderer;
    inputRef: InputTestComponent;
    popoverRef: NgbPopover;
    dropdownComponentRef: any;
    label: keyof IOptionModel;
    optionValue: string;
    inputHoveredItem: number;
    isDropDownIsOpen: boolean;
    _template: string;
    _canAddNew: boolean;
    set template(value: string);
    multiselectTemplate: string;
    inputConfig: ICaInput;
    set canAddNew(value: boolean);
    get canAddNew(): boolean;
    canOpenModal: boolean;
    _sort: string;
    set sort(value: string);
    get sort(): string;
    _activeItem: IOptionModel | null;
    set activeItem(value: IOptionModel | null);
    get activeItem(): IOptionModel | null;
    activeItemColor: IOptionModel | null;
    labelMode: 'Label' | 'Color';
    _options: IOptionModel[];
    set options(values: IOptionModel[]);
    set preloadMultiselectItems(values: IOptionModel[]);
    isDetailsPages: boolean;
    isIncorrectValue: boolean;
    isAddressDropdown: boolean;
    selectedItem: EventEmitter<IOptionModel | null>;
    selectedItems: EventEmitter<IOptionModel[] | null>;
    selectedItemColor: EventEmitter<IOptionModel | null>;
    selectedLabelMode: EventEmitter<string>;
    closeDropdown: EventEmitter<boolean>;
    saveItem: EventEmitter<{
        data: IOptionModel | null;
        action: string;
    }>;
    incorrectEvent: EventEmitter<boolean>;
    placeholderIconEvent: EventEmitter<boolean>;
    paginationEvent: EventEmitter<number>;
    activeGroupEvent: EventEmitter<IOptionModel>;
    clearInputEvent: EventEmitter<boolean>;
    searchInputEvent: EventEmitter<string>;
    searchInputText: EventInputManager$1<string>;
    originalOptions: IOptionModel[];
    paginationNumber: number;
    multiselectItems: IOptionModel[];
    isMultiSelectInputFocus: boolean;
    multiSelectLabel: string | undefined;
    lastActiveMultiselectItem: IOptionModel | null;
    isInAddMode: boolean;
    private dropdownPosition;
    clearTimeoutDropdown: string | number | ReturnType<typeof setTimeout> | undefined;
    hoveringIndex: number;
    inputDropdownSvgRoutes: typeof InputDropdownSvgRoutes;
    dropdownTemplateTypeEnum: typeof DropdownTemplateTypeEnum;
    private destroy$;
    constructor(superControl: NgControl, cdRef: ChangeDetectorRef, renderer: Renderer2);
    get getSuperControl(): _angular_forms.AbstractControl<any, any, any> | null;
    inputFormControl: FormControl;
    lastValidOption: IOptionModel;
    firstWriteValue: any;
    writeValue(value: string | number): void;
    writeValueToFormControlTimer: ReturnType<typeof setTimeout>;
    writeValueToFormControl(value: string | number): void;
    setNotFoundInvalidFlag(value: boolean): void;
    onTouched: () => void;
    onChange(_: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: () => void): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onScrollDropdown(event: EventTarget | null): void;
    onActiveItem(option: IOptionModel, group?: any): void;
    onActiveItemGroup(event: {
        option: IOptionModel;
        group: any;
    }): void;
    onClearSearch(): void;
    clearDropdownLabel(): void;
    commandEvent(event: CommandsEvent$1): void;
    addNewItem(): void;
    updateItem(): void;
    addNewConfig(): void;
    onIncorrectInput(event: boolean): void;
    identity(index: number, item: IOptionModel): number | undefined;
    toggleNestedList(option: IOptionModel): void;
    onBlurInput(event: boolean): void;
    onClearInputEvent(event: boolean): void;
    handleHiddenDropdown(): void;
    handleOpenDropdown(): void;
    showHideDropdown(action: boolean): void;
    getMainGroup(): IOptionModel[];
    dropDownKeyNavigation({ keyCode, data, }: {
        keyCode: number;
        data: any;
    }): void;
    setDropdownValue({ option, optionValue, label, setNotFoundError, }: SelectDropdownValueType): void;
    onMultiselectSelect(option: IOptionModel): void;
    removeMultiSelectItem(index: number): void;
    deleteAllMultiSelectItems(currentLabel?: string): void;
    toggleMultiselectDropdown(): void;
    dropdownValue: string | undefined;
    setControlValue(value?: string, dropdownInputValue?: string): void;
    /**
     * Navigate through dropdown with keyboard arrows
     */
    private dropdownNavigation;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaInputDropdownTestComponent, [{ self: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaInputDropdownTestComponent, "ca-input-dropdown-test", never, { "label": { "alias": "label"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; "template": { "alias": "template"; "required": false; }; "multiselectTemplate": { "alias": "multiselectTemplate"; "required": false; }; "inputConfig": { "alias": "inputConfig"; "required": false; }; "canAddNew": { "alias": "canAddNew"; "required": false; }; "canOpenModal": { "alias": "canOpenModal"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "activeItem": { "alias": "activeItem"; "required": false; }; "activeItemColor": { "alias": "activeItemColor"; "required": false; }; "labelMode": { "alias": "labelMode"; "required": false; }; "options": { "alias": "options"; "required": false; }; "preloadMultiselectItems": { "alias": "preloadMultiselectItems"; "required": false; }; "isDetailsPages": { "alias": "isDetailsPages"; "required": false; }; "isIncorrectValue": { "alias": "isIncorrectValue"; "required": false; }; "isAddressDropdown": { "alias": "isAddressDropdown"; "required": false; }; }, { "selectedItem": "selectedItem"; "selectedItems": "selectedItems"; "selectedItemColor": "selectedItemColor"; "selectedLabelMode": "selectedLabelMode"; "closeDropdown": "closeDropdown"; "saveItem": "saveItem"; "incorrectEvent": "incorrectEvent"; "placeholderIconEvent": "placeholderIconEvent"; "paginationEvent": "pagination"; "activeGroupEvent": "activeGroup"; "clearInputEvent": "clearInputEvent"; "searchInputEvent": "searchInputEvent"; }, never, never, true, never>;
}

declare class CaMapListComponent<T> implements AfterViewInit {
    private cdRef;
    private renderer;
    private formBuilder;
    mapListContainerRef: ElementRef<HTMLElement>;
    mapListRef: ElementRef<HTMLElement>;
    mapListBodyRef: ElementRef<HTMLElement>;
    sortColumns: SortColumn[];
    activeSortColumn: SortColumn | null;
    set mapListData(values: T);
    onSearchEvent: EventEmitter<string | number | null>;
    onCloseSearchEvent: EventEmitter<void>;
    onSortEvent: EventEmitter<{
        column: SortColumn;
        sortName: string;
    }>;
    onMapListScrollEvent: EventEmitter<void>;
    private fullContentHeight;
    isHoveredList: boolean;
    isExpandButtonShown: boolean;
    isMapListExpanded: boolean;
    previousScrollTime: number;
    searchForm: UntypedFormGroup;
    searchInputConfig: CaiInputConfig;
    eGeneralActions: typeof eGeneralActions;
    svgRoutes: typeof SharedSvgRoutes;
    constructor(cdRef: ChangeDetectorRef, renderer: Renderer2, formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private createSearchForm;
    onHoverList(isHovered: boolean): void;
    onCloseSearch(): void;
    onSearch(searchText: string | number | null): void;
    onSortChange(event: {
        column: SortColumn;
        sortName: string;
    }): void;
    mapListScroll(event: Event): void;
    resizeMapList(): void;
    checkResizeButton(): void;
    clearSearch(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaMapListComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaMapListComponent<any>, "app-ca-map-list", never, { "sortColumns": { "alias": "sortColumns"; "required": false; }; "activeSortColumn": { "alias": "activeSortColumn"; "required": false; }; "mapListData": { "alias": "mapListData"; "required": false; }; }, { "onSearchEvent": "onSearchEvent"; "onCloseSearchEvent": "onCloseSearchEvent"; "onSortEvent": "onSortEvent"; "onMapListScrollEvent": "onMapListScrollEvent"; }, never, ["*"], true, never>;
}

declare class CaMapListCardComponent<T> {
    cardData: T;
    cardTitleTemplate: TemplateRef<any>;
    cardMiddleContentTemplate: TemplateRef<any>;
    cardBottomContentTemplate: TemplateRef<any>;
    isSelected: boolean;
    onCardClickEvent: EventEmitter<T>;
    onCardClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaMapListCardComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaMapListCardComponent<any>, "app-ca-map-list-card", never, { "cardData": { "alias": "cardData"; "required": false; }; "cardTitleTemplate": { "alias": "cardTitleTemplate"; "required": false; }; "cardMiddleContentTemplate": { "alias": "cardMiddleContentTemplate"; "required": false; }; "cardBottomContentTemplate": { "alias": "cardBottomContentTemplate"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; }, { "onCardClickEvent": "onCardClickEvent"; }, never, never, true, never>;
}

interface LoadDelivery {
    count: string | number;
    location: string;
    date?: string;
    time?: string;
    stopType?: EnumValue;
}
interface LoadPickup extends LoadDelivery {
    delivery?: boolean;
}
interface LoadListLoadStopResponse {
    loadStops?: Array<LoadStopLoadListResponse> | null;
    totalMiles?: number | null;
    firstPickup?: {
        [key: string]: number;
    } | null;
    completedPercentage?: number | null;
    truckMovement?: MovementResponse;
}
interface MovementResponse {
    truckInfo?: LiveTrackingBaseResponse;
}
interface LiveTrackingBaseResponse {
    id?: number;
    deviceId?: string | null;
    latitude?: number | null;
    longitude?: number | null;
    coordinates?: string | null;
    altitude?: number | null;
    speed?: number | null;
    heading?: number | null;
    headingString?: string | null;
    location?: string | null;
    motionStatus?: number | null;
    motionStatusPeriod?: string | null;
    type?: GpsType;
    updateTime?: string | null;
    startDate?: string | null;
    stopDate?: string | null;
    dateString?: string | null;
    companyId?: number | null;
    unitType?: number | null;
}
interface LoadStopLoadListResponse {
    stopType?: EnumValue;
    dateFrom?: string | null;
    dateTo?: string | null;
    timeFrom?: string | null;
    timeTo?: string | null;
    timeType?: EnumValue | null;
    stopOrder?: number;
    stopLoadOrder?: number;
    arrive?: string | null;
    depart?: string | null;
    legMiles?: number | null;
    wait?: {
        [key: string]: number;
    } | null;
    shipper?: ShipperShortResponse;
    avgWaitTime?: number | null;
    isVisited?: boolean | null;
    isCheckedIn?: boolean | null;
}
type GpsType = 'DEVICE' | 'MOBILE';
declare const GpsType: {
    Device: GpsType;
    Mobile: GpsType;
};

type LoadType = eSharedString.TEMPLATE | eSharedString.PENDING | eSharedString.ACTIVE | eSharedString.CLOSED;

declare class CaLoadPickupDeliveryComponent {
    pickup: LoadPickup;
    delivery: LoadDelivery;
    isHoveringRow: boolean;
    loadType: LoadType;
    set stopsData(value: LoadListLoadStopResponse);
    set columnWidth(value: number);
    onPickupDeliveryClick: EventEmitter<number>;
    _stopsData: LoadListLoadStopResponse | null;
    _columnWidth: number | null;
    stopTypeCounts: Record<string, number> | null;
    isPopoverOpen: boolean;
    hoveredStopIndex: number;
    gpsIcon: string | null;
    gpsLocationIcon: string | null;
    gpsTitle: string | null;
    gpsTitleClass: string | null;
    eColor: typeof eColor;
    eSharedString: typeof eSharedString;
    ePosition: typeof ePosition;
    eDateTimeFormats: typeof eDateTimeFormats;
    eThousandSeparatorFormat: typeof eThousandSeparatorFormat;
    eUnit: typeof eUnit;
    eStringPlaceholder: typeof eStringPlaceholder;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    constructor();
    openPopover(t2: NgbPopover): void;
    closePopover(t2: NgbPopover): void;
    onHoverStop(index: number): void;
    private handleStopsData;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaLoadPickupDeliveryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaLoadPickupDeliveryComponent, "app-ca-load-pickup-delivery", never, { "pickup": { "alias": "pickup"; "required": false; }; "delivery": { "alias": "delivery"; "required": false; }; "isHoveringRow": { "alias": "isHoveringRow"; "required": false; }; "loadType": { "alias": "loadType"; "required": false; }; "stopsData": { "alias": "stopsData"; "required": false; }; "columnWidth": { "alias": "columnWidth"; "required": false; }; }, { "onPickupDeliveryClick": "onPickupDeliveryClick"; }, never, never, true, never>;
}

declare class ProgressExpirationAbsPipe implements PipeTransform {
    transform(value: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressExpirationAbsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ProgressExpirationAbsPipe, "progressExpirationAbs", true>;
}

declare class ProgressExpirationWidthPipe implements PipeTransform {
    transform(expireDate: Date, startDate?: Date, completedDate?: Date): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressExpirationWidthPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ProgressExpirationWidthPipe, "progressExpirationWidth", true>;
}

declare class TemplateContainerDirective {
    template: TemplateRef<any>;
    id: string;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateContainerDirective, "[templateContainer]", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaProgressExpirationComponent {
    private progressExpirationWidthPipe;
    private progressExpirationAbsPipe;
    private cdr;
    templateRef: QueryList<TemplateContainerDirective>;
    set config(data: ProgressExpiration[]);
    _config: ProgressExpiration;
    title: ProgressExpirationTitle;
    _configArray: ProgressExpiration[];
    totalDays: number;
    leftDays: number;
    progressWidth: string;
    progressBackgroundColor: ProgressExpirationColor;
    constructor(progressExpirationWidthPipe: ProgressExpirationWidthPipe, progressExpirationAbsPipe: ProgressExpirationAbsPipe, cdr: ChangeDetectorRef);
    private calculateDays;
    private setProgressWidth;
    private setTitleBasedOnConfig;
    private generateTitle;
    private setTitle;
    private setBackgroundColor;
    getTemplate<T>(template: string): TemplateRef<T>;
    identify(index: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaProgressExpirationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaProgressExpirationComponent, "lib-ca-progress-expiration", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CaModalComponent {
    customClass: string;
    partClass: string;
    modalTitle: string;
    customHeaderTemplate: TemplateRef<null>;
    headerSvgTemplate: TemplateRef<null>;
    leftHeaderTemplate: TemplateRef<null>;
    rightHeaderTemplate: TemplateRef<null>;
    footerTemplate: TemplateRef<null>;
    additionalPartTemplate: TemplateRef<null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaModalComponent, "app-ca-modal", never, { "customClass": { "alias": "customClass"; "required": false; }; "partClass": { "alias": "partClass"; "required": false; }; "modalTitle": { "alias": "modalTitle"; "required": false; }; "customHeaderTemplate": { "alias": "customHeaderTemplate"; "required": false; }; "headerSvgTemplate": { "alias": "headerSvgTemplate"; "required": false; }; "leftHeaderTemplate": { "alias": "leftHeaderTemplate"; "required": false; }; "rightHeaderTemplate": { "alias": "rightHeaderTemplate"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; "additionalPartTemplate": { "alias": "additionalPartTemplate"; "required": false; }; }, {}, never, ["[origin]"], true, never>;
}

declare class MapMarkerIconHelper {
    static getRoutingMarkerElement: (stopNumber: number | string, stopType: string, isStopChecked?: boolean, isLightMode?: boolean, labelName?: string, isIconMarker?: boolean, isShowLabelOnHover?: boolean, index?: number) => HTMLElement;
    static getMilesMarkerElement: (stopNumber: number | string, stopType: string, labelName?: string, index?: number) => HTMLElement;
    static getRoutingMarkerIcon: (stopNumber: number | string, stopType: string, isStopChecked?: boolean, isLightMode?: boolean) => string;
    static getRoutingMarkerSvg: (stopNumber: number | string, stopType: string, isLightMode?: boolean) => string;
    static getMilesMarkerSvg: (stopNumber: number | string, stopType: string) => string;
    static getRoutingCheckedMarkerSvg: (stopType: string, isLightMode?: boolean) => string;
    static getRoutingMarkerIconSvg: (stopType: string) => string;
    static getMapMarker(isFavorite?: boolean, isClosed?: boolean): string;
    static getClusterMarker(count: number, isSelected?: boolean, isFuelMarker?: boolean): string;
    static getCurrentLocationMarkerSvg(motionStatus: eGpsMotionStatus): string;
    static getGpsMarkerElement(motionStatus: eGpsMotionStatus, headingDirection: string, isIgnition?: boolean, index?: number, labelName?: string, secondLabelName?: string): HTMLElement;
    static getGpsMarkerSvg(motionStatus: eGpsMotionStatus, headingDirection: string, isIgnition?: boolean): string;
    static getGpsMovingMarkerSvg(headingDirection: string): string;
    static getGpsStopMarkerSvg(motionStatus: eGpsMotionStatus, isIgnition?: boolean): string;
    static getGpsAtStopMarkerElement(motionStatus: eGpsMotionStatus, stopNumber: number | string, stopType: string, isIgnition?: boolean, labelName?: string, isShowLabelOnHover?: boolean, id?: number): HTMLElement;
    static getRoutingCircleMarkerSvg(stopType: string, stopNumber: number | string): string;
    static createRoutingMarkerLabelElement(markerElement: HTMLElement, labelName: string, isShowLabelOnHover?: boolean): void;
    static getLtlMarkerElement(stopType: string, labelName: string, index: number): HTMLElement;
    static getLtlMarkerSvg(stopType: string, index: number): string;
    static getDispatchRouteMarkerElement(stopType: string, id?: number): HTMLElement;
    static getDispatchRouteMarkerSvg(stopType: string): string;
    static getStopType(stopType: {
        id?: number;
        name?: string;
    }, stopStatusId?: number): string;
}

declare class MapHelper {
    static getIconForUnitViewStops: (color: string, id: number | string) => string;
    static getIconForDriveMiles: (color: string, id: number | string) => string;
    static getLocationIcon(color: string): string;
    static getFillColorForState(stateDensity: number, View: string): {
        fillColor: string;
        fillOpacity: number;
    };
    static getMapCenterAndZoom(markers: IMapMarkers[]): {
        mapCenter: IRoutePath;
        bounds?: google.maps.LatLngBounds | null;
        mapZoom?: number | null;
    };
    static getMapScaleDistance(map: google.maps.Map): {
        roundedMiles: number;
        pixelLength: number;
    };
    static getRoundedMiles(miles: number): number;
}

interface IIconDropdownItem {
    label: string;
    value: string;
    isSelected?: boolean;
}

interface IIconDropdownConfig {
    icon: string;
    iconColor?: string;
    iconBackgroundColor?: string;
    iconHoverColor?: string;
    iconHoverBackgroundColor?: string;
    iconActiveColor?: string;
    iconActiveBackgroundColor?: string;
    dropdownWidth?: string;
    dropdownItems: IIconDropdownItem[];
    tooltipLabel?: string;
    placement: ePlacement[];
}

declare class IconDropdownSvgRoutes {
    static colorDrop: string;
}

declare class CaIconDropdownComponent {
    popover: NgbPopover;
    iconDropdownConfig: IIconDropdownConfig;
    selectedItem: EventEmitter<any>;
    isHovered: boolean;
    iconDropdownSvgRoutes: typeof IconDropdownSvgRoutes;
    /**
     * Gets the icon color based on the dropdown state.
     *
     * Logic:
     * - If the dropdown is open, returns `iconActiveColor`, regardless of hover state.
     * - If hovered (and dropdown is closed), returns `iconHoverColor`.
     * - Otherwise, returns `iconColor`.
     *
     * @returns {string} The computed icon color as a CSS string.
     */
    get iconColor(): string;
    /**
     * Gets the background color based on the dropdown state.
     *
     * Logic:
     * - If the dropdown is open, returns `iconActiveBackgroundColor`.
     * - If hovered, returns `iconHoverBackgroundColor`.
     * - Otherwise, returns `iconBackgroundColor`.
     *
     * @returns {string} The computed background color as a CSS string.
     */
    get backgroundColor(): string;
    /**
     * Selects an item from the dropdown, marks it as selected, and closes the dropdown.
     *
     * @param {IIconDropdownItem} item - The dropdown item that was selected.
     * @param {NgbPopover} popover - The popover instance to close after selection.
     * @returns {void}
     */
    selectItem(item: IIconDropdownItem, popover: NgbPopover): void;
    /**
     * Updates the hover state of the icon.
     *
     * @param {boolean} isHovered - `true` if the icon is hovered, `false` otherwise.
     * @returns {void}
     */
    setHoveredIconState(isHovered: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaIconDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaIconDropdownComponent, "app-ca-icon-dropdown", never, { "iconDropdownConfig": { "alias": "iconDropdownConfig"; "required": false; }; }, { "selectedItem": "selectedItem"; }, never, never, true, never>;
}

declare class MapInfoWindowOptionsConstants {
    static mapInfoWindowOptions: google.maps.InfoWindowOptions;
}

declare class MapOptionsConstants {
    static DEFAULT_MAP_ZOOM: number;
    static DEFAULT_MAP_CENTER: IRoutePath;
    static DEFAULT_MAP_OPTIONS: IMapOptions;
    static DEFAULT_MAP_CONFIG: ICaMapProps;
    static MAP_LIST_PAGINATION: IMapPagination;
    static AREA_FILTER_DATA: IMapAreaFilter;
    static ROUTING_MARKER_DARK_COLORS: Record<string, string>;
    static ROUTING_MARKER_LIGHT_COLORS: Record<string, string>;
    static ROUTING_PATH_DARK_COLORS: Record<string, string>;
    static ROUTING_PATH_COLORS: Record<string, string>;
    static ROUTING_DASHED_LINE_PATH: IMapDashedRouteIcon;
    static ROUTING_DASHED_LINE_ICON: IMapDashedRouteStyle[];
    static ROUTING_MARKER_OUTLINE_COLORS: Record<string, string>;
    static ROUTING_MARKER_DOT_COLORS: Record<string, string>;
    static LTL_MARKER_COLORS: string[];
    static DISPATCH_ROUTE_MARKER_COLORS: Record<string, string>;
    static ROUTING_MARKER_ICON_PATHS: Record<string, string>;
    static MILES_MARKER_ICON_PATHS: Record<string, string>;
    static ROUTING_MARKER_PATH_FILL_COLORS: Record<string, string>;
    static ROUTING_MARKER_DOT_FILL_COLORS: Record<string, string>;
}

declare class MapMarkerIconsConstants {
    static defaultMarker: string;
    static favoriteMarker: string;
    static closedMarker: string;
    static clusterIcon: string;
}

declare class MapConstants {
    static GOOGLE_MAP_STYLES: google.maps.MapTypeStyle[];
    static GOOGLE_MAP_DARK_STYLES: google.maps.MapTypeStyle[];
    static NORTH_AMERICA_BOUNDS: {
        north: number;
        south: number;
        west: number;
        east: number;
    };
}

declare class SortDropdownSvgRoutes {
    static sortDropArrowRoute: string;
    static sortDirectionRouteASC: string;
    static sortDirectionRouteDESC: string;
    static checkRoute: string;
}

declare enum SortDropdownEnum {
    DESC = "desc",
    ASC = "asc",
    TOP = "top",
    BOTTOM = "bottom",
    RIGHT = "right",
    RIGHT_TOP = "right-top"
}

type sortDirectionType = {
    asc: SortDropdownEnum.DESC;
    desc: SortDropdownEnum.ASC;
};

interface ISortDropdownAction {
    column: SortColumn;
    sortName: string;
    direction: SortDropdownEnum;
}

declare class CaSortDropdownComponent implements OnDestroy {
    set sortColumns(values: SortColumn[]);
    activeSortColumn: SortColumn;
    dropdownPosition: string;
    dropdownWidth: number;
    isDarkVariation: boolean;
    isLargeVariation: boolean;
    customPopoverClass: string;
    onSortChange: EventEmitter<ISortDropdownAction>;
    isSortPopoverOpened: EventEmitter<boolean>;
    private destroy$;
    sortDropdownSvgRoutes: typeof SortDropdownSvgRoutes;
    sortDirection: SortDropdownEnum.ASC | SortDropdownEnum.DESC;
    sortDirectionsRotate: sortDirectionType;
    sortDropdownPopover: NgbPopover | null;
    isDropdownOpen: boolean;
    _sortColumns: SortColumn[];
    eStringPlaceholder: typeof eStringPlaceholder;
    eColor: typeof eColor;
    sortDirectionChange(): void;
    sortChangeEvent(column?: SortColumn): void;
    emitPopoverState(): void;
    onHide(): void;
    openClosePopover(popover: NgbPopover): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaSortDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaSortDropdownComponent, "app-ca-sort-dropdown", never, { "sortColumns": { "alias": "sortColumns"; "required": false; }; "activeSortColumn": { "alias": "activeSortColumn"; "required": false; }; "dropdownPosition": { "alias": "dropdownPosition"; "required": false; }; "dropdownWidth": { "alias": "dropdownWidth"; "required": false; }; "isDarkVariation": { "alias": "isDarkVariation"; "required": false; }; "isLargeVariation": { "alias": "isLargeVariation"; "required": false; }; "customPopoverClass": { "alias": "customPopoverClass"; "required": false; }; }, { "onSortChange": "onSortChange"; "isSortPopoverOpened": "isSortPopoverOpened"; }, never, never, true, never>;
}

declare class CaModalButtonComponent {
    type: eModalButtonClassType;
    size: eModalButtonSize;
    text: string;
    loadingText: string;
    isValid: boolean;
    isSpinnerShown: boolean;
    isModalButton: boolean;
    hasBothSpinnerAndText: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaModalButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaModalButtonComponent, "app-ca-modal-button", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "text": { "alias": "text"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "isValid": { "alias": "isValid"; "required": false; }; "isSpinnerShown": { "alias": "isSpinnerShown"; "required": false; }; "isModalButton": { "alias": "isModalButton"; "required": false; }; "hasBothSpinnerAndText": { "alias": "hasBothSpinnerAndText"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FilterBySearchTermPipe implements PipeTransform {
    transform(items: IDropdownItem[], searchTerm?: string): IDropdownItem[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterBySearchTermPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterBySearchTermPipe, "filterBySearchTerm", true>;
}

declare class SelectedItemPipe implements PipeTransform {
    transform(items: IDropdownItem[]): IDropdownItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectedItemPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SelectedItemPipe, "selectedItem", true>;
}

interface ScrollBarOptions {
    showVerticalScrollBar: boolean;
    showHorizontalScrollBar: boolean;
    dataLength?: number;
    modalStyle?: any;
}

declare enum ScrollEventAction {
    IS_SCROLL_SHOWING = "isScrollShowing",
    SCROLLING = "scrolling"
}

interface ScrollEvent {
    eventAction: ScrollEventAction;
    isScrollBarShowing?: boolean;
    scrollPosition?: number;
}

declare class CaCustomScrollbarComponent implements OnInit, AfterViewInit, OnDestroy {
    private ngZone;
    private elRef;
    private cdr;
    private bar;
    scrollEvent: EventEmitter<ScrollEvent>;
    set scrollBarOptions(value: ScrollBarOptions);
    set horizontalScrollHeight(value: number);
    _scrollBarOptions: ScrollBarOptions;
    _horizontalScrollHeight: number;
    private scrollTop;
    showScrollbar: boolean;
    scrollHeight: number;
    private scrollRatio;
    private scrollRatioFull;
    isMouseDown: boolean;
    private barClickPosition;
    private barClickRestHeight;
    private destroy$;
    private calculateSizeHeightTimer?;
    private tableNotPinedContainer;
    tableNotPinedBoundingRect: DOMRect | null;
    private tableBarClickPosition;
    private tableBarClickRestWidth;
    private tableScrollRatio;
    private tableScrollRatioFull;
    tableScrollWidth: number;
    private resizeHandlerCount;
    constructor(ngZone: NgZone, elRef: ElementRef, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private initializeEventListeners;
    private initializeTableScroll;
    private setScrollEvent;
    setDraggingStart(event: MouseEvent): void;
    private calculateBarSizeAndPosition;
    private calculateTableScroll;
    private calculateRegularScroll;
    private onMouseUpHandler;
    private onResizeHandler;
    private onMouseMoveHandler;
    private handleRegularScroll;
    private handleTableScroll;
    projectContentChanged(): void;
    private removeEventListeners;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaCustomScrollbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaCustomScrollbarComponent, "app-ca-custom-scrollbar", never, { "scrollBarOptions": { "alias": "scrollBarOptions"; "required": false; }; "horizontalScrollHeight": { "alias": "horizontalScrollHeight"; "required": false; }; }, { "scrollEvent": "scrollEvent"; }, never, ["*"], true, never>;
}

declare class LastFuelPriceProgressHelper {
    static getSvgClassFromValue(minValue: number, maxValue: number, totalValue: number, isOutdated?: boolean, isTableVariation?: boolean, isCardVariation?: boolean): string;
    static calculateSvgPosition(minValue: number, maxValue: number, totalValue: number, isOutdated?: boolean, isTableVariation?: boolean, isCardVariation?: boolean): {
        svgPosition: number;
        svgClass: string;
    };
}

declare function emptyValueValidator(errorMessage: string): ValidatorFn;

interface IContact {
    id?: number;
    fullName?: string | null;
    phone?: string | null;
    phoneExt?: string | null;
    email?: string | null;
}

interface IContactDepartment {
    id?: number;
    name: string;
    contacts: IContact[];
}

interface Tabs {
    id: number;
    name?: string;
    checked?: boolean;
    disabled?: boolean;
}

interface CustomPeriodRange {
    fromDate: string;
    toDate: string;
    subPeriod: string;
}

interface DropdownListItem {
    id?: number;
    name?: string | null;
}

declare class CaTabSwitchComponent implements AfterViewInit {
    private renderer;
    private cdRef;
    tabSwitchHolder: ElementRef<HTMLElement>;
    set tabs(tabs: Tabs[]);
    type: string;
    hasDashboardHeight?: boolean;
    subPeriodDropdownList?: DropdownListItem[];
    selectedSubPeriod?: DropdownListItem;
    isClearCustomPeriodRangeValue?: boolean;
    isDisabled?: boolean;
    isBold: boolean;
    isMarginTopDisabled: boolean;
    switchClicked: EventEmitter<{
        id: number;
        name?: string;
    }>;
    customPeriodRangeEmitter: EventEmitter<CustomPeriodRange>;
    customPeriodRangeSubperiodEmitter: EventEmitter<number>;
    popoverClosedEmitter: EventEmitter<any>;
    indexSwitch: number;
    private selectedItem;
    private isAnimating;
    _tabs: Tabs[];
    get tabs(): Tabs[];
    constructor(renderer: Renderer2, cdRef: ChangeDetectorRef);
    ngAfterViewInit(): void;
    private setSwitchActive;
    private animateTabSwitch;
    private finalizeTabSwitch;
    switchTab(e: MouseEvent, indx: number, item: {
        id: number;
    }): void;
    handleSetCustomPeriodRangeClick(customPeriodRange: CustomPeriodRange): void;
    handleCustomPeriodRangeSubperiodEmit(selectedDaysRange: number): void;
    handlePopoverClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaTabSwitchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaTabSwitchComponent, "app-ca-tab-switch", never, { "tabs": { "alias": "tabs"; "required": false; }; "type": { "alias": "type"; "required": false; }; "hasDashboardHeight": { "alias": "hasDashboardHeight"; "required": false; }; "subPeriodDropdownList": { "alias": "subPeriodDropdownList"; "required": false; }; "selectedSubPeriod": { "alias": "selectedSubPeriod"; "required": false; }; "isClearCustomPeriodRangeValue": { "alias": "isClearCustomPeriodRangeValue"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "isBold": { "alias": "isBold"; "required": false; }; "isMarginTopDisabled": { "alias": "isMarginTopDisabled"; "required": false; }; }, { "switchClicked": "switchClicked"; "customPeriodRangeEmitter": "customPeriodRangeEmitter"; "customPeriodRangeSubperiodEmitter": "customPeriodRangeSubperiodEmitter"; "popoverClosedEmitter": "popoverClosedEmitter"; }, never, never, true, never>;
}

declare class PmItemPipe implements PipeTransform {
    transform<T extends {
        pmTruck: PMTruckShortResponse;
        pmTrailer: PMTrailerShortResponse;
    }>(item: T): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PmItemPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PmItemPipe, "pmItem", true>;
}

declare class DropdownWidthPipe implements PipeTransform {
    transform(columnWidth: number): {
        [key: string]: string;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownWidthPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DropdownWidthPipe, "dropdownWidth", true>;
}

declare enum eModalItems {
    ADD_ITEM = "ADD_ITEM",
    DELETE_ITEM = "DELETE_ITEM"
}

declare class FuelPricesRangePipe implements PipeTransform {
    transform(lastFuelPriceData: {
        minValue: number;
        maxValue: number;
        totalValue: number;
        isOutdated?: boolean;
        isCardVariation?: boolean;
    }): {
        svgPosition: number;
        svgClass: string;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<FuelPricesRangePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FuelPricesRangePipe, "fuelPricesRange", true>;
}

declare class FuelPricesRangeConstants {
    static FUEL_PRICES_RANGE_CIRCLE_SVG_CLASS_COLOR: Record<string, string>;
    static FUEL_PRICES_RANGE_ARROW_SVG_CLASS_COLOR: Record<string, string>;
    static FUEL_PRICES_RANGE_BACKGROUND_CLASS_COLOR: Record<string, string>;
}

declare class ConfirmationModalButtonConstants {
    static readonly NO_BUTTON: IConfirmationModalButtons;
    static readonly YES_BUTTON: IConfirmationModalButtons;
    static readonly CANCEL_BUTTON: IConfirmationModalButtons;
    static readonly REMOVE_BUTTON: IConfirmationModalButtons;
}

declare enum eFactoringPdfFormat {
    SINGLE = "single",
    MULTIPLE = "multiple"
}

declare enum eFactoringPdfOrganize {
    BY_LOAD = "byLoad",
    BY_TAG = "byTag"
}

declare enum eFactoringFormControl {
    SCHEDULE_NO = "scheduleNo",
    PDF_FORMAT = "pdfFormat",
    ORGANIZE_PDF = "organizePdf",
    INCLUDE_UNTAGGED = "includeUntagged"
}

interface IFactoringCheckboxItem {
    name: string;
    label: string;
    isChecked: boolean;
}

interface IFactoringExportItem {
    scheduleNumber?: string;
    origin?: boolean;
    destination?: boolean;
    payTerm?: boolean;
    pdfFormat?: eFactoringPdfFormat;
    pdfOrganize?: eFactoringPdfOrganize;
    includeUntagged?: boolean;
    loadIds?: number[];
    dateCreated?: string;
}

declare class CaFactoringDropdownComponent implements OnInit {
    private formBuilder;
    itemsCount: number;
    set isExportFinished(isExportFinished: boolean);
    onFactoringExport: EventEmitter<IFactoringExportItem>;
    onFactoringUploadToRts: EventEmitter<IFactoringExportItem>;
    checkBoxItems: IFactoringCheckboxItem[];
    factoringDropdownPopover: NgbPopover | null;
    factoringDropdownForm: UntypedFormGroup;
    isByTagDisabled: boolean;
    checkedCount$: Observable<number>;
    sharedSvgRoutes: typeof SharedSvgRoutes;
    checkboxSvgRputes: typeof CheckboxSvgRoutes;
    scheduleNoInputConfig: CaiInputConfig;
    eFactoringFormControl: typeof eFactoringFormControl;
    eFactoringPdfFormat: typeof eFactoringPdfFormat;
    eFactoringPdfOrganize: typeof eFactoringPdfOrganize;
    eSharedString: typeof eSharedString;
    ePosition: typeof ePosition;
    isInProgressUpload: boolean;
    isInProgressExport: boolean;
    isExportClicked: boolean;
    constructor(formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    private createForm;
    onFactoringDropdownOpenCloseClick(factoringDropdownPopover: NgbPopover, event?: MouseEvent): void;
    onCLoseDropdown(): void;
    onCheckboxRowClick(name: string): void;
    onRadioPdfFormatClick(value: eFactoringPdfFormat, event: MouseEvent): void;
    onRadioOrganizePdfClick(value: eFactoringPdfOrganize, event: MouseEvent): void;
    onExportClick(event?: MouseEvent): void;
    onExportBatch(isUpload: boolean, event?: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaFactoringDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaFactoringDropdownComponent, "app-ca-factoring-dropdown", never, { "itemsCount": { "alias": "itemsCount"; "required": false; }; "isExportFinished": { "alias": "isExportFinished"; "required": false; }; }, { "onFactoringExport": "onFactoringExport"; "onFactoringUploadToRts": "onFactoringUploadToRts"; }, never, never, true, never>;
}

declare class CaContactsCardComponent {
    private clipboard;
    departmentContacts: IContactDepartment[];
    searchText: string;
    onEditClick: EventEmitter<number>;
    onDeleteClick: EventEmitter<number>;
    hoveredContactId: number | null;
    hoveredTextIndex: number;
    copiedIndex: number;
    eGeneralActions: typeof eGeneralActions;
    eColor: typeof eColor;
    ePosition: typeof ePosition;
    eStringPlaceholder: typeof eStringPlaceholder;
    svgRoutes: typeof SharedSvgRoutes;
    constructor(clipboard: Clipboard);
    copyToClipboard(text: string, index: number): void;
    onHoverContact(contactId?: number): void;
    onHoverText(index?: number): void;
    onEditEvent(contactId: number): void;
    onDeleteEvent(contactId: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaContactsCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaContactsCardComponent, "app-ca-contacts-card", never, { "departmentContacts": { "alias": "departmentContacts"; "required": false; }; "searchText": { "alias": "searchText"; "required": false; }; }, { "onEditClick": "onEditClick"; "onDeleteClick": "onDeleteClick"; }, never, never, true, never>;
}

declare class DropdownMenuContentHelper {
    static getPayrollDropdownContent(isOpenPayroll: boolean): IDropdownMenuItem[];
    static getPickupDeliveryDropdownContent(loadStatus: string): IDropdownMenuItem[];
}

declare class DropdownMenuContentConditionalItemsHelper {
    static getConditionalItems(requestedItemTitles: string[], isSharedConditionalItems: boolean, modifiers?: Partial<IDropdownMenuItem>[]): IDropdownMenuItem[];
    static getPickupDeliveryModifierItems(loadStatus: string): Partial<IDropdownMenuItem>[];
}

declare class MethodsCalculationsHelper {
    static calculateParkingSlot: (value: string, formControl: AbstractControl) => number | undefined;
    static convertDateToBackend: (date: string) => string;
    static convertDateFromBackend: (date: string) => string;
    static convertDateToTimeFromBackend: (date: string, show_am_ap?: boolean) => string | null;
    static convertTimeFromBackend: (time: string) => Date;
    static convertDateFromBackendToTime: (date: string) => string;
    static combineDateAndTimeToBackend: (date: string, time: string) => string;
    static convertDateFromBackendToDateAndTime: (date: Date | string) => string;
    static convertThousanSepInNumber: (value: string) => number;
    static convertNumberInThousandSep: (value: number) => string | 0;
    static convertThousandToShortFormat: (value: number) => string;
    static convertNumberWithCurrencyFormatterToBackend: (value: number, hasDollar?: boolean) => string;
}

declare function uuidv4(): string;

declare class UserHelper {
    static getUserFromLocalStorage(): IUser | null;
}

declare class DateTimeHelper {
    static sortByCreatedAt<T extends {
        createdAt?: string | Date;
    }>(data: T[], sortDirection: eSharedString.ASC | eSharedString.DSC, dateFormat?: string): T[];
}

declare class GpsLocationHelper {
    static getGpsIcon: (motionStatus: eGpsMotionStatus, headingDirection: eGpsHeadingDirection, isIgnition?: boolean) => string;
    static getGpsCurrentLocationIcon: (motionStatus: eGpsMotionStatus) => string;
    static getGpsSvg: (motionStatus: eGpsMotionStatus, innerSvgContent: string) => string;
    static getGpsSvgClasses: (motionStatus: eGpsMotionStatus) => string;
    static getGpsSvgInnerContent: (motionStatus: eGpsMotionStatus, headingDirection: eGpsHeadingDirection, isIgnition?: boolean) => string;
    static getGpsTitle: (motionStatus: eGpsMotionStatus, headingDirection?: eGpsHeadingDirection, isIgnition?: boolean) => string;
    static getGpsTitleColorClass: (motionStatus: eGpsMotionStatus, isDarkMode?: boolean) => string;
    static getMovingIconPath: (headingDirection: eGpsHeadingDirection) => string;
    static getStoppedIconPath: (isIgnition?: boolean) => string;
    static getNoGpsDeviceIconPath: () => string;
}

declare class DropdownMenuContentConstants {
    static DROPDOWN_MENU_SHARED_ITEMS: Record<string, IDropdownMenuItem>;
    static DROPDOWN_MENU_CONDITIONAL_ITEMS: Record<string, IDropdownMenuItem>;
}

declare class GpsLocationConstants {
    static GPS_DEVICE_COLORS: Record<eGpsMotionStatus, string>;
    static GPS_DEVICE_HOVER_COLORS: Record<eGpsMotionStatus, string>;
    static GPS_SVG_CLASSES: Record<eGpsMotionStatus, {
        fill: string;
        hover: string;
    }>;
    static GPS_SVG_FILL_COLORS: Record<eGpsMotionStatus, string>;
    static GPS_TITLES: Record<eGpsMotionStatus, string>;
    static GPS_TITLE_COLOR_CLASSES: Record<eGpsMotionStatus, string>;
    static GPS_TITLE_DROPDOWN_COLOR_CLASSES: Record<eGpsMotionStatus, string>;
    static GPS_HEADING_ROTATION_ANGLE: Record<eGpsHeadingDirection, number>;
    static GPS_MOTION_TEXT: Record<eGpsMotionStatus, {
        text: string;
        textColorClass: string;
    }>;
    static GPS_IGNITION_SVG_CLASSES: Record<eGpsMotionStatus, string>;
}

declare class SearchMultipleStatesConstant {
    static COLOR_CLASSES: string[];
}

declare class CaModalSpinnerComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CaModalSpinnerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaModalSpinnerComponent, "app-ca-modal-spinner", never, {}, {}, never, never, true, never>;
}

declare class TimeFilterHelper {
    static convertTimeToDate(period: string, year?: number): {
        fromDate: string;
        toDate: string;
    };
}

declare enum eToolbarVariant {
    Large = 1,
    Small = 2
}

interface IToolbarTabs {
    title?: string;
    name?: string;
    length?: number;
    isDisabled?: boolean;
}

type ToolbarVariantType = eToolbarVariant.Large | eToolbarVariant.Small;

declare class CaToolbarTabSwitchComponent implements AfterViewInit {
    private renderer;
    indicator: ElementRef<HTMLDivElement>;
    tabItems: QueryList<ElementRef<HTMLDivElement>>;
    set selectedTab(value: string | undefined);
    set data(value: IToolbarTabs[] | undefined);
    variant: ToolbarVariantType;
    tabSelected: EventEmitter<string>;
    get data(): IToolbarTabs[] | undefined;
    get selectedTab(): string | undefined;
    private _selectedTab?;
    private _data?;
    isAnimating: boolean;
    toolbarVariant: typeof eToolbarVariant;
    constructor(renderer: Renderer2);
    ngAfterViewInit(): void;
    private updateIndicatorPosition;
    private animateIndicatorTransition;
    onTabClick(event: MouseEvent, tabName: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaToolbarTabSwitchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaToolbarTabSwitchComponent, "ca-toolbar-tab-switch", never, { "selectedTab": { "alias": "selectedTab"; "required": false; }; "data": { "alias": "data"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, { "tabSelected": "tabSelected"; }, never, never, true, never>;
}

export { CaActivateModalComponent, CaActivityLogListComponent, CaAppTooltipV2Component, CaChartComponent, CaChartManagerComponent, CaCheckboxComponent, CaCheckboxSelectedCountComponent, CaCommentsComponent, CaComponentsLibModule, CaContactsCardComponent, CaCustomCardComponent, CaCustomScrollbarComponent, CaDeactivateModalComponent, CaDeleteModalComponent, CaDetailsDropdownComponent, CaDetailsTitleCardComponent, CaDropdownMenuComponent, CaFactoringDropdownComponent, CaFilesCountComponent, CaFilterComponent, CaFilterDropdownComponent, CaFilterListDropdownComponent, CaFilterStateDropdownComponent, CaFleetFilterComponent, CaFuelPricesRangeComponent, CaHeatmapUsaComponent, CaIconDropdownComponent, CaInputAddressDropdownComponent, CaInputComponent, CaInputDatetimePickerComponent, CaInputDropdownComponent, CaInputDropdownTestComponent, CaInputNoteComponent, CaInputRadiobuttonsComponent, CaItemsDropdownComponent, CaLastFuelPriceProgressComponent, CaLoadPickupDeliveryComponent, CaLoadStatusComponent, CaLoadStatusLogComponent, CaMainTableComponent, CaMapComponent, CaMapDropdownComponent, CaMapListCardComponent, CaMapListComponent, CaModalButtonComponent, CaModalComponent, CaModalItemsComponent, CaModalSpinnerComponent, CaMoveModalComponent, CaNoteComponent, CaNoteContainerComponent, CaPayrollListSummaryOverviewComponent, CaPayrollListSummaryOverviewTableComponent, CaPeriodContentComponent, CaProfileImageComponent, CaProgressBarV2Component, CaProgressExpirationComponent, CaRangeSliderComponent, CaRatingReviewComponent, CaResetTableModalComponent, CaRightSidePanelCompanyComponent, CaRightSidePanelComponent, CaRightSidePanelMenuComponent, CaRightSidePanelTopBarComponent, CaSearchMultipleStates2Component, CaSearchMultipleStatesComponent, CaSearchMultipleStatesService, CaShowMoreComponent, CaSortDropdownComponent, CaSortingCardDropdownComponent, CaSpinnerComponent, CaStatusChangeDropdownComponent, CaSvgPipe, CaTabSwitchComponent, CaTableCardViewComponent, CaToastMessagesComponent, CaTodoComponent, CaToolbarDropdownComponent, CaToolbarTabSwitchComponent, CaTooltipListComponent, CaTruckTrailerProgresBarComponent, CaUploadFilesComponent, CaVehicleListComponent, CaVoidModalComponent, ChartColorsStringEnum, ChartEventTypesStringEnum, ChartFontPropertiesStringEnum, ChartImagesStringEnum, ChartPluginIdsStringEnum, ConfirmationModalButtonConstants, CubicInterpolationStringEnum, DateFormatPipe, DateFromStringPipe, DateTimeHelper, DateWaitTimePipe, DispatchStatusColorPipe, DropdownLoadStatusColorPipe, DropdownMenuContentConditionalItemsHelper, DropdownMenuContentConstants, DropdownMenuContentHelper, DropdownWidthPipe, EChartAnnotation, EChartAnnotationType, EChartEventProperties, FilterBySearchTermPipe, FormatCityStatePipe, FormatCurrencyPipe, FormatDurationPipe, FuelPricesRangeConstants, FuelPricesRangePipe, GoogleMapEnum, GpsLocationConstants, GpsLocationHelper, GpsType, HighlightSearchPipe, InputTestComponent, LastFuelPriceProgressHelper, LoadStatusBackgroundColorPipe, LoadStatusColorPipe, LoadStatusColorsPipe, MapConstants, MapDropdownSvgRoutes, MapHelper, MapInfoWindowOptionsConstants, MapMarkerIconHelper, MapMarkerIconService, MapMarkerIconsConstants, MapOptionsConstants, MethodsCalculationsHelper, NFormatterPipe, NameInitialsPipe, PayrollTypeEnum, PickupDeliveryBlockComponent, PmItemPipe, ProgressBarComponent, ProgressBarLinePipe, SafeHtmlPipe, SearchMultipleStatesConstant, SelectedItemPipe, SortDropdownEnum, SortOrder, TableHighlightSearchTextPipe, ThousandFormatterPipe, ThousandSeparatorPipe, ThousandToShortFormatPipe, TimeFilterHelper, ToLowerCasePipe, ToolbarFilterStringEnum, TruckTrailerColorFinderPipe, TruncatePipe, UnitPositionPipe, UserHelper, UserNameInitialsPipe, eAnimationState, eChartTypesString, eColor, eCommonElement, eDateTimeFormats, eDispatchStatus, eDropZoneFileType, eDropdownMenu$1 as eDropdownMenu, eFileAction, eFileDropZoneAction, eFileSize, eFileType, eFileUploadPage, eFilterColor, eFilterDropdownEnum, eFilterSortingKey, eFilterTime, eFleetFilterItemType, eGeneralActions, eGpsHeadingDirection, eGpsMotionStatus, eLoadFilter, eLoadStatus, eMapMarkerStopType, eMapMarkerString, eModalButtonClassType, eModalButtonSize, eModalItems, ePeriodTitleType, ePlacement, ePosition, eReviewState, eSharedString, eStringPlaceholder, eStyleProperty, eStyling, eTemplateType, eThousandSeparatorFormat, eToastType, eTrailerName, eTruckNameString, eUnit, eVehicleList, emptyValueValidator, userInfoEnum, uuidv4 };
export type { AddressData, AddressList, ColumnConfig, CommandProperties, CommandsHandler, IBaseDataset, ICaInput, ICaInputDateTimePicker, ICaInputWithDropdown, ICaMapProps, IChartAnnotation, IChartBoundaries, IChartCenterLabel, IChartConfiguration, IChartData, IChartDatasetHover, IChartLegendConfig, IChartLegendProperty, IColumnCheckAction, IComment, ICompanyUser, IConfirmationModalButtons, IContact, IContactDepartment, ICountry, IDocumentReviewInputEvent, IDropBackgroundEvent, IDropZoneConfig, IDropZoneOptionConfig, IDropZoneSettings, IDropdownItem, IDropdownMenuItem, IDropdownMenuOptionEmit, IFactoringCheckboxItem, IFactoringExportItem, IFileConfig, IFileEvent, IFileOptionConfig, IFilterAction, IFilterDropdownConfiguration, IFilterDropdownList, IFleetFilterData, IFleetFilterItemEmit, IFleetFilterTrailer, IFleetFilterTrailerType, IFleetFilterTruck, IFleetFilterTruckType, IGpsCurrentLocation, IGpsHeadingInfo, IGpsProgress, IIconDropdownConfig, IIconDropdownItem, IItemsDropdownConfig, IItemsDropdownList, IItemsRowTemplate, ILineDataset, IMapAreaFilter, IMapBounds, IMapBoundsZoom, IMapColor, IMapDashedRouteIcon, IMapDashedRouteStyle, IMapList, IMapMarkers, IMapMarkersIcon, IMapOptions, IMapPagination, IMapRoutePath, IMapSelectedMarkerData, IMapStyles, IMarkerLabel, IModalData, IModalItemsConfig, IMultipleInput, IProgressBarColorConfig, IProgressBarData, IRangeSliderConfig, IReviewFileConfig, IRouteLocation, IRoutePath, ISearchQueryItem, ISlider, ISortDropdownAction, ISortEmit, IState, ITableColumn, ITimeOptions, IUSerAvatarFile, IUploadFilesConfig, IUser, IVehicleListActionsEmit, IVehicleListConfig, InputAddressCommandsString, LiveTrackingBaseResponse, LoadDelivery, LoadListLoadStopResponse, LoadPickup, LoadStatusHistoryResponse, LoadStopLoadListResponse, LoadType, LongLat$1 as LongLat, MapDropdownClusterItem, MapDropdownContent, MapDropdownContentItem, MovementResponse, PayrollListSummaryOverview, RepairUnitType, SentAddressData, SortColumn, TableCardBodyActions, Tabs, VehicleListResponse };