import { BreakpointObserver } from '@angular/cdk/layout';
import * as i0 from '@angular/core';
import { OnInit, AfterViewInit, OnDestroy, ElementRef, ViewContainerRef, Renderer2, EventEmitter, ChangeDetectorRef, Type, OnChanges, SimpleChanges, TemplateRef, PipeTransform, AfterContentInit } from '@angular/core';
import * as i27 from '@angular/common';
import { Location } from '@angular/common';
import * as i1 from '@angular/router';
import { Router, ActivatedRoute } from '@angular/router';
import * as i29 from '@ngx-translate/core';
import { TranslateLoader } from '@ngx-translate/core';
import * as i31 from '@angular/common/http';
import { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';
import * as i28 from '@naniteninja/ionic-lib';
import { SelectOption, LibMenuItem } from '@naniteninja/ionic-lib';
import * as i30 from '@angular/forms';
import { FormGroup, FormBuilder, FormArray, FormControl } from '@angular/forms';
import * as i6 from '@ionic/angular';
import * as i7 from '@angular/material/dialog';
import { MatDialogRef } from '@angular/material/dialog';
import { BehaviorSubject, Observable, Subject } from 'rxjs';
import { Socket } from 'socket.io-client';

declare enum ItinerariesRoutesEnum {
    DASHBOARD = "dashboard",
    ITINERARY = "itineraries",
    ITINERARY_EXPLORE = "itineraries/explore",
    ITINERARY_FAVOURITES = "itineraries/favorites",
    ITINERARY_BUILDER = "itineraries/builder",
    SEARCH = "search",
    REQUESTS = "requests",
    INFO = "info",
    PROFILE = "profile",
    ARCHIVES = "archives/archives",
    COMMENTS = "itineraries/comments",
    EXPLORE = "explore",
    BUILDER = "builder",
    CREATE_ITINERARY = "create",
    CREATE_ITINERARY_ORIGIN = "origin",
    CREATE_ITINERARY_DESTINATION = "destination",
    SELECT_ITINERARY_EVENTS = "select-events",
    SELECT_ITINERARY_ADD_PLACE = "add-place",
    SELECT_ITINERARY_PLACE_BASIC_INFO = "info",
    SELECT_ITINERARY_PLACE_DATETIME = "datetime",
    SELECT_ITINERARY_PLACE_MEMBERS = "members",
    CREATE_ITINERARY_USER_SEARCH = "user-search",
    CREATE_ITINERARY_MEMBER_DETAILS = "member-detail",
    CREATE_ITINERARY_DRAW_MODE = "draw",
    CREATE_ITINERARY_DRAW_MODE_CREATE = "create",
    CREATE_ITINERARY_DRAW_MODE_PREVIEW = "preview",
    CREATE_ITINERARY_NO_VISUAL_FILTER_MODE = "no-filters",
    CREATE_ITINERARY_NO_VISUAL_FILTER_MODE_CREATE = "create",
    CREATE_ITINERARY_NO_VISUAL_FILTER_MODE_PREVIEW = "preview",
    CREATED_ITINERARY = "created-itinerary",
    FAVORITES = "favorites",
    STORIES = "stories",
    COMMENTS_ROUTE = "comments",
    NOTIFICATIONS = "notifications",
    COMMENT_UPDATE_REQUEST = "comment-update-request",
    ITINERARY_MEMBERS = "members",
    ALL_INVITES_SENT = "invites",
    All_PEOPLE = "people",
    ITINERARY_FRIENDS = "friends",
    LIST_FRIENDS = "list-friends",
    ITINERARY_DETAIL = "detail",
    ITINERARY_USERS = "users",
    ITINERARY_UPVOTE_USERS = "upvote-users",
    ITINERARY_WATCHING_USERS = "watching-users",
    ITINERARY_AUTHOR_HISTORY = "author-history",
    ITINERARY_SUMMARY = "summary",
    ITINERARY_MAP = "map",
    ITINERARY_MORE_DETAIL = "more",
    BRANCHED_ITINERARIES = "branch",
    COMMENT_SEARCH = "comment-search",
    FRIEND_REQUESTS = "friend-requests",
    SEARCH_FRIEND = "search-friend",
    COMMENT_REPLIES = "comment-replies",
    ADVANCED_FILTERS = "advanced-filters",
    LOCATION_PICKER = "location-picker",
    SUGGESTED_EVENTS_LOCATION = "suggested-events-location",
    SUGGESTED_EVENTS_ROUTE_TYPE = "suggested-events-route-type",
    SUGGESTED_EVENTS_ROUTE_RADIUS = "suggested-events-route-radius",
    CREATED_ITINERARY_PREVIEW = "created-itinerary-preview",
    CREATED_ITINERARY_DETAIL = "detail",
    CREATED_ITINERARY_MAP = "map"
}

interface IBottomNavigationList {
    id: number;
    label: string;
    iconPath: string;
    clickedIconPath: string;
    routerLink: string;
    cssClass: string;
    height: string;
    width: string;
    selected: boolean;
}

interface Iicon {
    [key: string]: string;
}

declare class NavigationHelperService {
    private router;
    constructor(router: Router);
    /**
     * Navigate to a route while preserving the current base path context
     * @param routePath - The route path or array of path segments
     * @param route - The ActivatedRoute to use for relative navigation (optional)
     * @param options - Additional navigation options
     */
    navigate(routePath: string | string[], route?: ActivatedRoute, options?: any): void;
    /**
     * Navigate to a route with parameters
     */
    navigateWithParams(routePath: string | string[], params: any, route?: ActivatedRoute): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationHelperService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationHelperService>;
}

declare class BottomNavigationService {
    private navHelper;
    isShowNavigation: boolean;
    ICONS: Iicon;
    bottomNavList: {
        id: number;
        label: string;
        iconPath: string;
        clickedIconPath: string;
        routerLink: ItinerariesRoutesEnum;
        cssClass: string;
        height: string;
        width: string;
        selected: boolean;
    }[];
    constructor(navHelper: NavigationHelperService);
    onNavigationChange(data: IBottomNavigationList[], nav: IBottomNavigationList): void;
    setActive(nav: IBottomNavigationList): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BottomNavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BottomNavigationService>;
}

declare class ItineraryLibComponent implements OnInit, AfterViewInit, OnDestroy {
    private breakpointObserver;
    private renderer;
    el: ElementRef;
    location: Location;
    navService: BottomNavigationService;
    isSmallScreen: boolean;
    private breakpointSubscription;
    dynamicModal: ViewContainerRef;
    private popupModalService;
    constructor(breakpointObserver: BreakpointObserver, renderer: Renderer2, el: ElementRef, location: Location, navService: BottomNavigationService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    handleScreenSizeChange(): void;
    onResize(): void;
    checkWindowWidth(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ItineraryLibComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ItineraryLibComponent, "lib-itinerary-lib", never, {}, {}, never, never, false, never>;
}

/**
 * Translation languages type matching cyranoserver
 */
interface TranslationLanguages {
    en?: string;
    es?: string;
    fr?: string;
    de?: string;
    [key: string]: string | undefined;
}
interface IInterest {
    _id: string;
    name: TranslationLanguages;
    active: boolean;
}

interface IUser {
    _id: string;
    name: string;
    email: string;
    createdAt: Date;
    updatedAt: Date;
    isActive: boolean;
    pictureUrl?: string;
    interests?: IInterest[];
    dateOfBirth?: string;
    location?: string;
    bio?: string;
}

interface IGatewayRequest<T, P = void> {
    namespace: string;
    endpoint: string;
    accessToken?: string;
    userId?: string;
    username?: string;
    userType?: string;
    payload?: T;
    parameters?: P;
    avoidResponse?: boolean;
    blackboxRequest?: boolean;
}

interface IGatewayResponse<T> {
    endpoint: string;
    response: T;
    error: string;
}

declare enum AccountTypes {
    matcher = "matcher",
    unmatched = "unmatched",
    admin = "admin"
}

interface InputValue {
    userId: string;
    username: string;
    userType: AccountTypes;
    modelId: string;
}

declare class InputService {
    private inputValue$;
    constructor();
    setInputValue(value: InputValue | undefined): void;
    get inputValue(): BehaviorSubject<InputValue | undefined>;
    get currentValue(): InputValue | undefined;
    get userId(): string | undefined;
    get username(): string | undefined;
    get userType(): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InputService>;
}

declare class SocketService {
    private inputService;
    private socket;
    private readonly responseSubject;
    readonly response$: Observable<IGatewayResponse<any>>;
    constructor(inputService: InputService);
    getSocket(): Socket;
    private initializeSocket;
    sendRequest<Req, Res>(req: IGatewayRequest<Req, any>): Observable<Res>;
    disconnect(): void;
    isConnected(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SocketService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SocketService>;
}

declare class UserService {
    private socketService;
    private readonly namespace;
    constructor(socketService: SocketService);
    getAllUsers(): Observable<IUser[]>;
    getUserById(id: string): Observable<IUser>;
    getUninvitedUsers(userId: string): Observable<IUser[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
}

declare class ProfileComponent {
    private location;
    private userService;
    ICONS: Iicon;
    user: IUser;
    passions: SelectOption<string>[];
    loadingUser: boolean;
    constructor(location: Location, userService: UserService, route: ActivatedRoute);
    back: () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProfileComponent, "app-profile", never, {}, {}, never, never, false, never>;
}

declare class UserRoutingModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserRoutingModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UserRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UserRoutingModule>;
}

interface ICardData {
    id: string;
    upVotes: string;
    downVotes: number;
    title: string;
    userName: string;
    timeAgo: string;
    location: string;
    views: number;
    comments: number;
    shares: number;
    users: number;
    imageSrc: string;
    userimageSrc: string;
    isDraft: boolean;
}

interface ApiRequestOptions {
    headers?: HttpHeaders;
    params?: HttpParams;
    [key: string]: any;
}
interface ApiRequestBody {
    [key: string]: any;
}
declare class ApiService {
    private http;
    private readonly baseUrl;
    constructor(http: HttpClient);
    get<T>(endpoint: string, params?: HttpParams): Observable<T>;
    post<T>(endpoint: string, body: ApiRequestBody, options?: ApiRequestOptions): Observable<T>;
    put<T>(endpoint: string, body: ApiRequestBody, options?: ApiRequestOptions): Observable<T>;
    delete<T>(endpoint: string, options?: ApiRequestOptions): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiService>;
}

declare class CardComponent implements OnInit {
    private apiService;
    libMenuItem: LibMenuItem[];
    isDraft: boolean;
    cardData: ICardData | undefined;
    processedCardData: ICardData | undefined;
    ICONS: Iicon;
    itineraryStarted: boolean;
    StartItineraryClick: EventEmitter<void>;
    TitleClicked: EventEmitter<void>;
    forkClicked: EventEmitter<void>;
    messageClicked: EventEmitter<void>;
    cardDataForLocations: {
        locationColumn1: {
            icon: string;
            name: string;
        }[];
        locationColumn2: {
            icon: string;
            name: string;
        }[];
    };
    constructor(apiService: ApiService);
    ngOnInit(): void;
    private nullCheck;
    private processCardData;
    handleMenueItemSelect(): void;
    handleMenuItemChange(): void;
    handleMenuClick(): void;
    handleForkClick(): void;
    handleStartItineraryClick(): void;
    handleTitleClick(): void;
    handleMessageClicked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "app-card-component", never, { "libMenuItem": { "alias": "libMenuItem"; "required": false; }; "isDraft": { "alias": "isDraft"; "required": false; }; "itineraryStarted": { "alias": "itineraryStarted"; "required": false; }; }, { "StartItineraryClick": "StartItineraryClick"; "TitleClicked": "TitleClicked"; "forkClicked": "forkClicked"; "messageClicked": "messageClicked"; }, never, never, false, never>;
}

declare class CustomHeadingWithButtonComponent {
    heading: string;
    buttonText: string;
    buttonIcon: string;
    cssClass: string;
    buttonClick: EventEmitter<MouseEvent>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomHeadingWithButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CustomHeadingWithButtonComponent, "app-custom-heading-with-button", never, { "heading": { "alias": "heading"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "buttonIcon": { "alias": "buttonIcon"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, false, never>;
}

interface LocationReview {
    id: string;
    review: string;
    rating: number;
}

interface ItineraryLocation {
    id: string;
    title: string;
    description?: string;
    locationType: string;
    visitIndex: number;
    reviews: LocationReview[];
    position: [number, number];
    members: string[] | IUser[];
    timeToSpendInMinutes?: number;
}

interface IItinerary {
    _id?: string;
    name: string;
    startLocation?: [number, number];
    startLocationAddress?: string;
    endLocation?: [number, number];
    endLocationAddress?: string;
    routeTypes?: string[];
    routeRadius?: number;
    distanceInMeters?: number;
    visitingPlaces?: ItineraryLocation[];
    defaultInterestedMembers?: string[] | IUser[];
    isDraft?: boolean;
    isStarted?: boolean;
    isCompleted?: boolean;
    matchFull?: boolean;
    anotherSettings?: boolean;
    shares?: number;
    createdAt?: string;
    createdBy?: string | IUser;
    description?: string;
    stats?: IItineraryStatsDto;
}

declare class BaseModel {
    _id?: string;
    createdAt?: Date;
    updatedAt?: Date;
    isDeleted?: boolean;
    deleteProtection?: boolean;
}

interface IVote extends BaseModel {
    modelId: string;
    userId: string;
    vote: 'up' | 'down';
    isDeleted?: boolean;
}

interface IItineraryStatsDto {
    itinerary: IItinerary;
    upvotes: number;
    downvotes: number;
    views: number;
    comments: number;
    votes?: IVote[];
}

declare class AppService {
    private inputService;
    private socketService;
    private readonly namespace;
    private user$;
    constructor(inputService: InputService, socketService: SocketService);
    private initializeUserFromInput;
    get user(): Observable<IUser | undefined>;
    get currentUser(): IUser | undefined;
    setUser(user: IUser): void;
    getCurrentUser(id: string): Observable<IUser>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
}

interface IVoteCountDTO {
    up: number;
    down: number;
    score: number;
}
interface IUserVoteCountDTO {
    up: number;
    down: number;
    total: number;
}

declare class VoteService {
    private socketService;
    private readonly namespace;
    push$: Subject<IGatewayResponse<any>>;
    constructor(socketService: SocketService);
    private initializeListeners;
    getCountByModelId(modelId: string): Observable<IVoteCountDTO>;
    getCountByUserId(userId: string): Observable<IUserVoteCountDTO>;
    getVotesByModelId(modelId: string): Observable<IVote[]>;
    upVote(modelId: string, userId: string): Observable<IVote>;
    downVote(modelId: string, userId: string): Observable<IVote>;
    onVoteAdded(): Observable<IVote>;
    onVoteRemoved(): Observable<IVote>;
    onVoteChanged(): Observable<IVote>;
    static ɵfac: i0.ɵɵFactoryDeclaration<VoteService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VoteService>;
}

interface IItineraryFavourite extends BaseModel {
    itineraryId: string;
    userId: string;
}

declare class ItineraryFavouriteService {
    private socketService;
    private readonly namespace;
    push$: Subject<IGatewayResponse<boolean | IItineraryFavourite>>;
    constructor(socketService: SocketService);
    private initializeListeners;
    addToFavourite(itineraryId: string, userId: string): Observable<IItineraryFavourite>;
    removeFromFavourite(itineraryId: string, userId: string): Observable<boolean>;
    getByUserId(userId: string): Observable<IItineraryStatsDto[]>;
    isFavourite(itineraryId: string, userId: string): Observable<boolean>;
    onFavouriteAdded(): Observable<IItineraryFavourite>;
    onFavouriteRemoved(): Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ItineraryFavouriteService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ItineraryFavouriteService>;
}

declare class CutomCardComponent implements OnInit, OnDestroy {
    private appService;
    private voteService;
    private favouriteService;
    private cdr;
    loading: boolean;
    libMenuItems: LibMenuItem[];
    itineraryStats: IItineraryStatsDto;
    itnerary: IItinerary | undefined;
    images: string[];
    itineraryStarted: boolean;
    StartItineraryClick: EventEmitter<void>;
    TitleClicked: EventEmitter<void>;
    forkClicked: EventEmitter<void>;
    messageClicked: EventEmitter<void>;
    userProfileClicked: EventEmitter<void>;
    itineraryWatchingUsersClicked: EventEmitter<void>;
    imageClicked: EventEmitter<void>;
    eyeClicked: EventEmitter<void>;
    menuClicked: EventEmitter<IItineraryStatsDto>;
    ICONS: Iicon;
    user: IUser | undefined;
    isFavourite: boolean;
    private destroy$;
    cardDataForLocations: {
        locationColumn1: {
            icon: string;
            name: string;
        }[];
        locationColumn2: {
            icon: string;
            name: string;
        }[];
    };
    constructor(appService: AppService, voteService: VoteService, favouriteService: ItineraryFavouriteService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    private loadVotes;
    /** Check if this itinerary is in user's favorites */
    private checkFavouriteStatus;
    ngOnDestroy(): void;
    private handleVoteChange;
    /** Check if current user has upvoted */
    hasUpvoted(): boolean;
    /** Check if current user has downvoted */
    hasDownvoted(): boolean;
    /** Handle upvote click - toggles vote */
    handleUpvoteClick(): void;
    /** Handle downvote click - toggles vote */
    handleDownvoteClick(): void;
    asUser(value: IUser | string): IUser;
    asStats(value?: IItineraryStatsDto | string): IItineraryStatsDto | undefined;
    handleMenueItemSelect(): void;
    handleMenuItemChange(): void;
    handleMenuClick(): void;
    handleForkClick: () => void;
    handleStartItineraryClick: () => void;
    handleTitleClick: () => void;
    handleMessageClicked: () => void;
    handleUserProfileClicked: () => void;
    handleImageClick: () => void;
    handleEyeClicked: () => void;
    handleItineraryWatchingClicked(): void;
    /** Handle add/remove from favorites click - toggles favorite status */
    handleAddToFavoritesClick(): void;
    /** Update the menu item title based on favourite status */
    private updateFavouriteMenuTitle;
    static ɵfac: i0.ɵɵFactoryDeclaration<CutomCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CutomCardComponent, "app-cutom-card", never, { "loading": { "alias": "loading"; "required": false; }; "libMenuItems": { "alias": "libMenuItems"; "required": false; }; "itineraryStats": { "alias": "itineraryStats"; "required": false; }; "itnerary": { "alias": "itnerary"; "required": false; }; "images": { "alias": "images"; "required": false; }; "itineraryStarted": { "alias": "itineraryStarted"; "required": false; }; }, { "StartItineraryClick": "StartItineraryClick"; "TitleClicked": "TitleClicked"; "forkClicked": "forkClicked"; "messageClicked": "messageClicked"; "userProfileClicked": "userProfileClicked"; "itineraryWatchingUsersClicked": "itineraryWatchingUsersClicked"; "imageClicked": "imageClicked"; "eyeClicked": "eyeClicked"; "menuClicked": "menuClicked"; }, never, never, false, never>;
}

declare class CustomStoryCardComponent implements OnInit {
    private apiService;
    private cdr;
    private location;
    libMenuItem: LibMenuItem[];
    isDraft: boolean;
    cardData: ICardData | undefined;
    private scrollTimeout;
    private isScrolling;
    processedCardData: ICardData | undefined;
    ICONS: Iicon;
    cardDataForLocations: {
        locationColumn1: {
            icon: string;
            name: string;
        }[];
        locationColumn2: {
            icon: string;
            name: string;
        }[];
    };
    images: string[];
    image: string;
    constructor(apiService: ApiService, cdr: ChangeDetectorRef, location: Location);
    onWheel(event: WheelEvent): void;
    ngOnInit(): void;
    private InvalidDataCheck;
    private processCardData;
    loadCardData(): void;
    createDummyCard(): ICardData;
    handleMenueItemSelect(): void;
    handleMenuItemChange(): void;
    handleMenuClick(): void;
    goBack(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomStoryCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CustomStoryCardComponent, "app-custom-story-card", never, { "libMenuItem": { "alias": "libMenuItem"; "required": false; }; "isDraft": { "alias": "isDraft"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CommentImageService {
    constructor();
    image: string[];
    index: number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommentImageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CommentImageService>;
}

interface IImage extends BaseModel {
    modelId: string;
    userId: string;
    value: string;
}

interface IComment extends BaseModel {
    itinerary: string | IItinerary;
    comment: string;
    images?: IImage[];
    parentComment?: string | null;
    user: IUser | string;
    isEdited?: boolean;
    isFeatured?: boolean;
    votes: IVote[];
}

declare class CommentComponent implements OnInit {
    private cdr;
    private commentImageService;
    libMenuItem: LibMenuItem[];
    comment: IComment | undefined;
    index: number;
    ICONS: Iicon;
    isOpen: boolean;
    user: IUser | undefined;
    imageComponent: Type<unknown>;
    upClick: EventEmitter<void>;
    downClick: EventEmitter<void>;
    menuClick: EventEmitter<void>;
    menuItemSelect: EventEmitter<void>;
    constructor(cdr: ChangeDetectorRef, commentImageService: CommentImageService, appService: AppService);
    ngOnInit(): void;
    asUser(value: IUser | string): IUser;
    asImage(value: IImage | string): IImage;
    handleMenueItemSelect(event: Event): void;
    handleMenuItemChange(): void;
    handleMenuClick(): void;
    close: () => void;
    showImage(images: IImage[], currentIndex: number): void;
    getUpVotes(): IVote[] | undefined;
    getVoteUpIcon(): string;
    getVoteDownIcon(): string;
    isUpVote(): boolean;
    isDownVote(): boolean;
    onDownClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommentComponent, "app-comment", never, { "libMenuItem": { "alias": "libMenuItem"; "required": false; }; "comment": { "alias": "comment"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, { "upClick": "upClick"; "downClick": "downClick"; "menuClick": "menuClick"; "menuItemSelect": "menuItemSelect"; }, never, never, false, never>;
}

declare class NotificationTileComponent {
    libMenuItem: LibMenuItem[];
    content: string;
    btnText: string;
    isBtnVisible: boolean;
    notificationAttended: boolean;
    btnClick: EventEmitter<void>;
    ICONS: Iicon;
    constructor();
    handleMenueItemSelect(): void;
    handleMenuItemChange(): void;
    handleMenuClick(): void;
    handleBtnClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationTileComponent, "app-notification-tile", never, { "libMenuItem": { "alias": "libMenuItem"; "required": false; }; "content": { "alias": "content"; "required": false; }; "btnText": { "alias": "btnText"; "required": false; }; "isBtnVisible": { "alias": "isBtnVisible"; "required": false; }; "notificationAttended": { "alias": "notificationAttended"; "required": false; }; }, { "btnClick": "btnClick"; }, never, never, false, never>;
}

declare class UsersStackComponent implements OnChanges {
    private cdr;
    images: string[];
    maxVisible: number;
    size: number;
    loading: boolean;
    class: string;
    isSelectableVisible: boolean;
    selectableOption: SelectOption<string>;
    constructor(cdr: ChangeDetectorRef);
    ngOnChanges(_changes: SimpleChanges): void;
    get visibleImages(): string[];
    get remainingCount(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<UsersStackComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UsersStackComponent, "app-users-stack", never, { "images": { "alias": "images"; "required": false; }; "maxVisible": { "alias": "maxVisible"; "required": false; }; "size": { "alias": "size"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "class": { "alias": "class"; "required": false; }; "isSelectableVisible": { "alias": "isSelectableVisible"; "required": false; }; "selectableOption": { "alias": "selectableOption"; "required": false; }; }, {}, never, never, false, never>;
}

declare class UserStackTileComponent implements OnChanges {
    private cdr;
    ICONS: Iicon;
    class: string;
    buttonText: string;
    label: string;
    onClick: EventEmitter<void>;
    images: string[];
    maxVisible: number;
    size: number;
    isSelectableVisible: boolean;
    selectableOption: SelectOption<string>;
    constructor(cdr: ChangeDetectorRef);
    ngOnChanges(_changes: SimpleChanges): void;
    handleBtnClick: () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserStackTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserStackTileComponent, "app-user-stack-tile", never, { "class": { "alias": "class"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "label": { "alias": "label"; "required": false; }; "images": { "alias": "images"; "required": false; }; "maxVisible": { "alias": "maxVisible"; "required": false; }; "size": { "alias": "size"; "required": false; }; "isSelectableVisible": { "alias": "isSelectableVisible"; "required": false; }; "selectableOption": { "alias": "selectableOption"; "required": false; }; }, { "onClick": "onClick"; }, never, never, false, never>;
}

declare class UserTileComponent {
    sufixTemplate: TemplateRef<unknown> | null;
    name: string;
    email: string;
    image: string;
    class: string;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<UserTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserTileComponent, "app-user-tile", never, { "sufixTemplate": { "alias": "sufixTemplate"; "required": false; }; "name": { "alias": "name"; "required": false; }; "email": { "alias": "email"; "required": false; }; "image": { "alias": "image"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, false, never>;
}

interface INotification {
    id: string;
    userProfile: string;
    notificationContent: string;
    dateTime: string;
    attended: boolean;
}

interface Page {
    url: string;
    breadCrumb: string;
}

interface ISearchPopup {
    key: string;
    pages: Page[];
    childerns: ISearchPopup[];
}

interface MatchingClients {
    memberName: string;
    clientName: string;
    memberEmail: string;
    clientEmail: string;
    memberPic: string;
    clientPic: string;
    matchPercentage: number;
}

declare class AssetsService {
    private http;
    constructor(http: HttpClient);
    getGlobalSearch(): Observable<ISearchPopup[]>;
    getNotifications(): Observable<INotification[]>;
    getTranslation(fileName: 'en' | 'es' | 'fr'): Observable<Record<string, string>>;
    getMatchingClients(): Observable<MatchingClients[]>;
    clearSearchHistory(): Observable<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AssetsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AssetsService>;
}

declare class ModalService {
    toggleModal: boolean;
    bottomToggleModal: boolean;
    toggleGlobalSearch: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
}

declare class SearchPopupComponent {
    private router;
    private modalService;
    private assetService;
    private cdr;
    ICONS: Iicon;
    searchTerm: string;
    i18nTranslation: Record<string, string>;
    loading: boolean;
    constructor(router: Router, modalService: ModalService, assetService: AssetsService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    handleSearchStringChange(_$event: string): void;
    clear(): void;
    navigate(url: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchPopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchPopupComponent, "app-search-popup", never, {}, {}, never, never, false, never>;
}

declare class CommentImagesComponent {
    images: string[];
    index: number;
    constructor(commentImage: CommentImageService);
    static ɵfac: i0.ɵɵFactoryDeclaration<CommentImagesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommentImagesComponent, "app-comment-images", never, { "images": { "alias": "images"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ShadowRootHandlerService {
    accessShadowRoot(targetNode: HTMLElement, componentName: string, callback: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShadowRootHandlerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ShadowRootHandlerService>;
}

declare class FooterComponent implements OnInit, AfterViewInit {
    private el;
    private shadowrootHandler;
    bottomNavigationService: BottomNavigationService;
    private cdr;
    private readonly router;
    enableBack: boolean;
    constructor(el: ElementRef, shadowrootHandler: ShadowRootHandlerService, bottomNavigationService: BottomNavigationService, cdr: ChangeDetectorRef, router: Router);
    ngOnInit(): void;
    findNavItem(url: string): IBottomNavigationList | undefined;
    ngAfterViewInit(): void;
    navigate(bottomNavList: IBottomNavigationList[], item: IBottomNavigationList): void;
    initShadowrootHandler(): void;
    applyStylesToDialog(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FooterComponent, "app-footer", never, {}, {}, never, never, false, never>;
}

declare class HeaderComponent {
    heading: string;
    headerRightIcon: string;
    titleIcon: string;
    cssClass: string;
    firstButton: EventEmitter<MouseEvent>;
    titleIconClick: EventEmitter<MouseEvent>;
    headerSuffixTemplate: TemplateRef<unknown>;
    ICONS: Iicon;
    firstButtonClick(): void;
    onTitleIconClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "app-header", never, { "heading": { "alias": "heading"; "required": false; }; "headerRightIcon": { "alias": "headerRightIcon"; "required": false; }; "titleIcon": { "alias": "titleIcon"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "headerSuffixTemplate": { "alias": "headerSuffixTemplate"; "required": false; }; }, { "firstButton": "firstButton"; "titleIconClick": "titleIconClick"; }, never, never, false, never>;
}

interface MenuItem {
    label?: string;
    icon?: string;
    routerLink?: string;
}

declare class TabBarComponent implements OnInit, OnDestroy {
    private router;
    private cdr;
    private route;
    private destroy$;
    tabMenuItems: MenuItem[];
    activeItemChange: EventEmitter<MenuItem>;
    activeItem: MenuItem;
    constructor(router: Router, cdr: ChangeDetectorRef, route: ActivatedRoute);
    ngOnInit(): void;
    private updateActiveItem;
    ngOnDestroy(): void;
    onActiveItemChange(event: MenuItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabBarComponent, "app-tab-bar", never, { "tabMenuItems": { "alias": "tabMenuItems"; "required": false; }; }, { "activeItemChange": "activeItemChange"; }, never, never, false, never>;
}

declare class ImageViewerComponent {
    dialogRef: MatDialogRef<ImageViewerComponent>;
    data: {
        imageUrl: string;
    };
    isLoading: boolean;
    constructor(dialogRef: MatDialogRef<ImageViewerComponent>, data: {
        imageUrl: string;
    });
    onImageLoad(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImageViewerComponent, "app-image-viewer", never, {}, {}, never, never, false, never>;
}

interface Image {
    idx: number;
    src: string;
}
declare class SwiperDialogComponent {
    data: {
        images: string[];
        currentIndex: number;
    };
    private dialogRef;
    images: Image[];
    currentIndex: number;
    isLoading: boolean;
    constructor(data: {
        images: string[];
        currentIndex: number;
    }, dialogRef: MatDialogRef<SwiperDialogComponent>);
    onImageLoad(): void;
    updateCurrentIndex(img: Image): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwiperDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwiperDialogComponent, "app-swiper-dialog", never, {}, {}, never, never, false, never>;
}

declare class BottomNavigationItemsComponent {
    label: string;
    iconPath: string;
    routerLink: string;
    cssClass: string;
    selected: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BottomNavigationItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BottomNavigationItemsComponent, "app-bottom-navigation-items", never, { "label": { "alias": "label"; "required": false; }; "iconPath": { "alias": "iconPath"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, {}, never, never, false, never>;
}

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

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

declare class ActionCardComponent {
    actionCardClicked: EventEmitter<string>;
    icon: string;
    title: string;
    description: string;
    actionName: string;
    handleClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActionCardComponent, "lib-action-card", never, { "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "actionName": { "alias": "actionName"; "required": false; }; }, { "actionCardClicked": "actionCardClicked"; }, never, never, false, never>;
}

declare class IconButtonComponent {
    buttonIcon: string;
    disableTextShadow: boolean;
    class: string;
    libMenuItems: LibMenuItem[];
    buttonText: string;
    buttonClick: EventEmitter<void>;
    select: EventEmitter<void>;
    change: EventEmitter<void>;
    handleSelect(): void;
    handleChange(): void;
    handleClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconButtonComponent, "app-icon-button", never, { "buttonIcon": { "alias": "buttonIcon"; "required": false; }; "disableTextShadow": { "alias": "disableTextShadow"; "required": false; }; "class": { "alias": "class"; "required": false; }; "libMenuItems": { "alias": "libMenuItems"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; }, { "buttonClick": "buttonClick"; "select": "select"; "change": "change"; }, never, never, false, never>;
}

declare class MatchingClientsComponent implements OnInit, OnDestroy {
    private assetService;
    private cdr;
    private fb;
    loading: boolean;
    matches: Array<MatchingClients>;
    dynamicForm: FormGroup;
    private formChangesSubscription;
    clientSelectionChanged: EventEmitter<Array<MatchingClients>>;
    constructor(assetService: AssetsService, cdr: ChangeDetectorRef, fb: FormBuilder);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onSubmit(): boolean;
    private addCheckboxesToForm;
    private subscribeToFormChanges;
    get itemsFormArray(): FormArray;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatchingClientsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatchingClientsComponent, "lib-matching-clients", never, {}, { "clientSelectionChanged": "clientSelectionChanged"; }, never, never, false, never>;
}

declare class PopupModalComponent implements OnInit, OnChanges, OnDestroy, AfterContentInit {
    isOpen: boolean;
    icon: string | null;
    title: string;
    message: string;
    extendedMessage: string;
    cancelButton: string;
    confirmButton: string;
    checkboxText: string;
    progBarCurrentStep: number;
    progBarTotalSteps: number;
    customClass: string;
    backdropDismiss: boolean;
    modalComponent: Type<unknown>;
    modalComponentData: unknown;
    modalConfirm: EventEmitter<boolean>;
    modalDismiss: EventEmitter<boolean>;
    afterCloseEvent: EventEmitter<unknown>;
    ngOnInit(): void;
    ngOnChanges(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    onModalConfirm(confirmed: boolean): void;
    onModalDismiss(dismissed: boolean): void;
    onAfterCloseEvent(event: unknown): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopupModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PopupModalComponent, "app-popup-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; "extendedMessage": { "alias": "extendedMessage"; "required": false; }; "cancelButton": { "alias": "cancelButton"; "required": false; }; "confirmButton": { "alias": "confirmButton"; "required": false; }; "checkboxText": { "alias": "checkboxText"; "required": false; }; "progBarCurrentStep": { "alias": "progBarCurrentStep"; "required": false; }; "progBarTotalSteps": { "alias": "progBarTotalSteps"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "backdropDismiss": { "alias": "backdropDismiss"; "required": false; }; "modalComponent": { "alias": "modalComponent"; "required": false; }; "modalComponentData": { "alias": "modalComponentData"; "required": false; }; }, { "modalConfirm": "modalConfirm"; "modalDismiss": "modalDismiss"; "afterCloseEvent": "afterCloseEvent"; }, never, ["*"], false, never>;
}

declare class SelectableComponent implements OnInit, OnChanges, OnDestroy, AfterContentInit {
    options: SelectOption<string>[];
    formControl?: FormControl;
    singleSelectionOnly: boolean;
    maxSelectionPossible: number;
    customClass: string;
    click: EventEmitter<void>;
    selectionchange: EventEmitter<void>;
    ngOnInit(): void;
    ngOnChanges(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    onClick(): void;
    onSelectionChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectableComponent, "app-selectable", never, { "options": { "alias": "options"; "required": false; }; "formControl": { "alias": "formControl"; "required": false; }; "singleSelectionOnly": { "alias": "singleSelectionOnly"; "required": false; }; "maxSelectionPossible": { "alias": "maxSelectionPossible"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; }, { "click": "click"; "selectionchange": "selectionchange"; }, never, ["*"], false, never>;
}

declare class SelectableBadgeComponent {
    label: string;
    selected: boolean;
    selectionChanged: EventEmitter<boolean>;
    toggleSelection(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableBadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectableBadgeComponent, "lib-selectable-badge", never, { "label": { "alias": "label"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "selectionChanged": "selectionChanged"; }, never, never, false, never>;
}

declare class SearchBarComponent {
    searchIcon: string;
    placeholderText: string;
    searchStringChange: EventEmitter<string>;
    cleared: EventEmitter<void>;
    handleSearchStringChange(event: string): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchBarComponent, "app-search-bar", never, { "searchIcon": { "alias": "searchIcon"; "required": false; }; "placeholderText": { "alias": "placeholderText"; "required": false; }; }, { "searchStringChange": "searchStringChange"; "cleared": "cleared"; }, never, never, false, never>;
}

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

declare class SharedModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedModule, [typeof CardComponent, typeof CustomHeadingWithButtonComponent, typeof CutomCardComponent, typeof CustomStoryCardComponent, typeof CommentComponent, typeof NotificationTileComponent, typeof UsersStackComponent, typeof UserStackTileComponent, typeof UserTileComponent, typeof SearchPopupComponent, typeof CommentImagesComponent, typeof FooterComponent, typeof HeaderComponent, typeof TabBarComponent, typeof ImageViewerComponent, typeof SwiperDialogComponent, typeof BottomNavigationItemsComponent, typeof VotesPipe, typeof CapitalizeFirstPipe, typeof ActionCardComponent, typeof IconButtonComponent, typeof MatchingClientsComponent, typeof PopupModalComponent, typeof SelectableComponent, typeof SelectableBadgeComponent, typeof SearchBarComponent], [typeof i27.CommonModule, typeof i28.BaseCardModule, typeof i29.TranslateModule, typeof i28.SearchBarModule, typeof i28.ButtonsModule, typeof i28.DashedCheckboxModule, typeof i28.FormFieldModule, typeof i30.FormsModule, typeof i28.ImageCardModule, typeof i28.InfoCardModule, typeof i28.InfoCardListModule, typeof i28.InfoCardPlaceholderModule, typeof i28.InputDateFieldModule, typeof i28.LibMapModule, typeof i28.PopperModule, typeof i28.SearchBarModule, typeof i31.HttpClientModule, typeof i27.NgOptimizedImage, typeof i28.LibTabMenuModule, typeof i28.LibModalModule, typeof i6.IonicModule, typeof i28.ContentViewCardModule, typeof i28.NotificationsModule, typeof i28.LibToastrModule, typeof i28.SelectableModule, typeof i28.ImageDeckComponent, typeof i28.ImageDeckComponent, typeof i1.RouterLink, typeof i30.ReactiveFormsModule, typeof TimeAgoPipe, typeof i28.FormGeneratorModule, typeof i28.GridModule, typeof i28.InputFieldSelectModule, typeof i28.OtpInputModule], [typeof CardComponent, typeof CustomHeadingWithButtonComponent, typeof CutomCardComponent, typeof CustomStoryCardComponent, typeof CommentComponent, typeof NotificationTileComponent, typeof UsersStackComponent, typeof UserStackTileComponent, typeof UserTileComponent, typeof SearchPopupComponent, typeof ImageViewerComponent, typeof TabBarComponent, typeof HeaderComponent, typeof FooterComponent, typeof BottomNavigationItemsComponent, typeof VotesPipe, typeof ActionCardComponent, typeof IconButtonComponent, typeof MatchingClientsComponent, typeof PopupModalComponent, typeof SelectableBadgeComponent, typeof SearchBarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SharedModule>;
}

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

declare class UserModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UserModule, [typeof ProfileComponent], [typeof UserRoutingModule, typeof i28.SectionSeparatorComponent, typeof SharedModule, typeof i29.TranslateModule, typeof i28.SelectableModule, typeof i27.DatePipe, typeof AgePipe], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UserModule>;
}

declare class ItineraryLibRoutingModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ItineraryLibRoutingModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ItineraryLibRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ItineraryLibRoutingModule>;
}

declare function httpLoaderFactory(http: HttpClient): TranslateLoader;
declare class ItineraryLibModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ItineraryLibModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ItineraryLibModule, [typeof ItineraryLibComponent], [typeof i27.CommonModule, typeof i29.TranslateModule, typeof i28.ButtonsModule, typeof i30.FormsModule, typeof i6.IonicModule, typeof i6.IonicModule, typeof i30.ReactiveFormsModule, typeof i28.LibModalModule, typeof i28.ToggleModule, typeof i28.RangeSelectorModule, typeof i7.MatDialogModule, typeof UserModule, typeof ItineraryLibRoutingModule], [typeof ItineraryLibComponent, typeof ItineraryLibRoutingModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ItineraryLibModule>;
}

export { AccountTypes, AppService, InputService, ItineraryLibComponent, ItineraryLibModule, ItineraryLibRoutingModule, httpLoaderFactory };
export type { IUser, InputValue };