import * as i30 from '@ngx-translate/core';
import { TranslateLoader } from '@ngx-translate/core';
import * as i32 from '@angular/common/http';
import { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';
import * as i0 from '@angular/core';
import { OnInit, AfterViewInit, OnDestroy, ElementRef, ViewContainerRef, Renderer2, ChangeDetectorRef, EventEmitter, Type, OnChanges, SimpleChanges, TemplateRef, PipeTransform, AfterContentInit } from '@angular/core';
import { BreakpointObserver } from '@angular/cdk/layout';
import * as i28 from '@angular/common';
import { Location } from '@angular/common';
import * as i29 from '@naniteninja/ionic-lib';
import { PopupModalService, SelectOption, LibMenuItem } from '@naniteninja/ionic-lib';
import * as i1 from '@angular/router';
import { Router, ActivatedRoute } from '@angular/router';
import * as rxjs from 'rxjs';
import { Observable, Subject } from 'rxjs';
import * as i31 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';

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 BottomNavigationService {
    private router;
    isShowNavigation: boolean;
    ICONS: Iicon;
    bottomNavList: {
        id: number;
        label: string;
        iconPath: string;
        clickedIconPath: string;
        routerLink: ItinerariesRoutesEnum;
        cssClass: string;
        height: string;
        width: string;
        selected: boolean;
    }[];
    constructor(router: Router);
    onNavigationChange(data: IBottomNavigationList[], nav: IBottomNavigationList): void;
    setActive(nav: IBottomNavigationList): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BottomNavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BottomNavigationService>;
}

/**
 * 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;
}

declare class AppService {
    private http;
    private userVal;
    constructor(http: HttpClient);
    get user(): IUser | undefined;
    getUser(id: string): Promise<IUser>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
}

declare class ItineraryLibService {
    private appService;
    private userInitializedSubject;
    userInitialized$: rxjs.Observable<IUser>;
    constructor(appService: AppService);
    initialize(userId: string): Promise<IUser>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ItineraryLibService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ItineraryLibService>;
}

declare class ItineraryLibComponent implements OnInit, AfterViewInit, OnDestroy {
    private breakpointObserver;
    private renderer;
    el: ElementRef;
    location: Location;
    navService: BottomNavigationService;
    private popupModalService;
    private itineraryLibService;
    private cdr;
    isSmallScreen: boolean;
    isLoading: boolean;
    private destroy$;
    dynamicModal: ViewContainerRef;
    constructor(breakpointObserver: BreakpointObserver, renderer: Renderer2, el: ElementRef, location: Location, navService: BottomNavigationService, popupModalService: PopupModalService, itineraryLibService: ItineraryLibService, cdr: ChangeDetectorRef);
    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>;
}

declare class UserService {
    private socket;
    private readonly namespace;
    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;
    views: number;
    comments: number;
    votes: IVote[];
}

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

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

declare class VoteService {
    private socket;
    private readonly namespace;
    push$: Subject<IGatewayResponse<any>>;
    constructor();
    private initializeListeners;
    /** Internal helper to send/receive gateway messages */
    private sendRequest;
    /** Get votes (up/down/score) for a given model ID */
    getCountByModelId(modelId: string): Observable<IVoteCountDTO>;
    /** Get vote summary (up/down/total) for a given user ID */
    getCountByUserId(userId: string): Observable<IUserVoteCountDTO>;
    /** Get all votes for a given model ID */
    getVotesByModelId(modelId: string): Observable<IVote[]>;
    /** Cast or toggle an up‑vote on a model */
    upVote(modelId: string, userId: string): Observable<IVote>;
    /** Cast or toggle a down‑vote on a model */
    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 socket;
    private readonly namespace;
    push$: Subject<IGatewayResponse<boolean | IItineraryFavourite>>;
    constructor();
    private initializeListeners;
    /** Internal helper to send/receive gateway messages */
    private sendRequest;
    /**
     * Add an itinerary to user's favorites
     */
    addToFavourite(itineraryId: string, userId: string): Observable<IItineraryFavourite>;
    /**
     * Remove an itinerary from user's favorites
     */
    removeFromFavourite(itineraryId: string, userId: string): Observable<boolean>;
    /**
     * Get all favorite itineraries for a user
     * Returns IItineraryStatsDto[] with vote counts
     */
    getByUserId(userId: string): Observable<IItineraryStatsDto[]>;
    /**
     * Check if an itinerary is in user's favorites
     */
    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;
    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;
    cardDataForLocations: {
        locationColumn1: {
            icon: string;
            name: string;
        }[];
        locationColumn2: {
            icon: string;
            name: string;
        }[];
    };
    private destroy$;
    constructor(appService: AppService, voteService: VoteService, favouriteService: ItineraryFavouriteService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    asUser(value: IUser | string): IUser;
    asStats(value?: IItineraryStatsDto | string): IItineraryStatsDto | undefined;
    getUpvotesCount(): number;
    hasUpvoted(): boolean;
    hasDownvoted(): boolean;
    handleMenueItemSelect(): void;
    handleMenuItemChange(): void;
    handleMenuClick(): void;
    handleForkClick: () => void;
    handleStartItineraryClick: () => void;
    handleTitleClick: () => void;
    handleMessageClicked: () => void;
    handleUserProfileClicked: () => void;
    handleImageClick: () => void;
    handleEyeClicked: () => void;
    handleItineraryWatchingClicked(): void;
    handleUpvoteClick(): void;
    handleDownvoteClick(): void;
    handleAddToFavoritesClick(): void;
    private checkFavouriteStatus;
    private handleVoteChange;
    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; }; "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;
    private appService;
    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;
    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(): 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;
    private route;
    ICONS: Iicon;
    searchTerm: string;
    i18nTranslation: Record<string, string>;
    loading: boolean;
    constructor(router: Router, modalService: ModalService, assetService: AssetsService, cdr: ChangeDetectorRef, route: ActivatedRoute);
    ngOnInit(): 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, OnChanges, OnDestroy {
    private route;
    private router;
    private cdr;
    tabMenuItems: MenuItem[];
    activeItemChange: EventEmitter<MenuItem>;
    activeItem: MenuItem;
    private destroy$;
    constructor(route: ActivatedRoute, router: Router, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    onActiveItemChange(event: MenuItem): void;
    activateLatestChild(): 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>;
}

type MarkerSize = 'small' | 'large';
declare class AwsMapComponent implements OnInit, OnDestroy, OnChanges {
    private cdr;
    mapContainer: ElementRef<HTMLDivElement>;
    center: number[];
    startPosition: number[] | null;
    endPosition: number[] | null;
    initialZoom: number;
    routePlaces: number[][];
    showLocationLabel: boolean;
    fullHeight: boolean;
    markerSize: MarkerSize;
    showStartEndOnly: boolean;
    showCurrentLocationOnly: boolean;
    private mapInstance;
    private prevCenter;
    private isFlying;
    private markers;
    private currentLocationMarker;
    private currentZoom;
    private fittedCenter;
    private locationClient;
    isMapLoaded: boolean;
    isRouteLoading: boolean;
    locationLabel: string;
    private readonly markerSizes;
    constructor(cdr: ChangeDetectorRef);
    ngOnInit(): void;
    private zoomToCenterLocation;
    private initializeLocationClient;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private clearMarkers;
    private initializeMap;
    private handleCenterChange;
    recenterMap(): void;
    getLocationLabel(): string;
    private fetchLocationLabel;
    private addMarkersAndRoute;
    private addCurrentLocationMarker;
    private addRoutePlacesMarkers;
    private createRouteMarker;
    private fetchAndDrawRouteForPlaces;
    private calculateRouteBetweenPoints;
    private fetchAndDrawRoute;
    private calculateRouteWithCognito;
    private drawRouteOnMap;
    private drawStraightFallbackRoute;
    private removeExistingRoute;
    private fitBoundsToAllMarkers;
    private fitBoundsToMarkers;
    static ɵfac: i0.ɵɵFactoryDeclaration<AwsMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AwsMapComponent, "app-aws-map", never, { "center": { "alias": "center"; "required": false; }; "startPosition": { "alias": "startPosition"; "required": false; }; "endPosition": { "alias": "endPosition"; "required": false; }; "initialZoom": { "alias": "initialZoom"; "required": false; }; "routePlaces": { "alias": "routePlaces"; "required": false; }; "showLocationLabel": { "alias": "showLocationLabel"; "required": false; }; "fullHeight": { "alias": "fullHeight"; "required": false; }; "markerSize": { "alias": "markerSize"; "required": false; }; "showStartEndOnly": { "alias": "showStartEndOnly"; "required": false; }; "showCurrentLocationOnly": { "alias": "showCurrentLocationOnly"; "required": false; }; }, {}, 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 AwsMapComponent], [typeof i28.CommonModule, typeof i29.BaseCardModule, typeof i30.TranslateModule, typeof i29.SearchBarModule, typeof i29.ButtonsModule, typeof i29.DashedCheckboxModule, typeof i29.FormFieldModule, typeof i31.FormsModule, typeof i29.ImageCardModule, typeof i29.InfoCardModule, typeof i29.InfoCardListModule, typeof i29.InfoCardPlaceholderModule, typeof i29.InputDateFieldModule, typeof i29.LibMapModule, typeof i29.PopperModule, typeof i29.SearchBarModule, typeof i32.HttpClientModule, typeof i28.NgOptimizedImage, typeof i29.LibTabMenuModule, typeof i29.LibModalModule, typeof i6.IonicModule, typeof i29.ContentViewCardModule, typeof i29.NotificationsModule, typeof i29.LibToastrModule, typeof i29.SelectableModule, typeof i29.ImageDeckComponent, typeof i29.ImageDeckComponent, typeof i1.RouterLink, typeof i31.ReactiveFormsModule, typeof TimeAgoPipe, typeof i29.FormGeneratorModule, typeof i29.GridModule, typeof i29.InputFieldSelectModule, typeof i29.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, typeof AwsMapComponent]>;
    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 i29.SectionSeparatorComponent, typeof SharedModule, typeof i30.TranslateModule, typeof i29.SelectableModule, typeof i28.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 i28.CommonModule, typeof i30.TranslateModule, typeof i29.ButtonsModule, typeof i31.FormsModule, typeof i6.IonicModule, typeof i6.IonicModule, typeof i31.ReactiveFormsModule, typeof i29.LibModalModule, typeof i29.ToggleModule, typeof i29.RangeSelectorModule, typeof i7.MatDialogModule, typeof UserModule, typeof ItineraryLibRoutingModule], [typeof ItineraryLibComponent, typeof ItineraryLibRoutingModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ItineraryLibModule>;
}

interface ItineraryPrimaryInfoDto {
    name: string;
    matchFull: boolean;
    anotherSettings: boolean;
    createdBy: string;
}

interface IItineraryMember extends BaseModel {
    itineraryId: string;
    userId: string;
    invitedUserId: IUser | string;
    status: 'accepted' | 'rejected' | 'pending';
}

interface ItineraryMemberCompleteDTO {
    itinerary: IItinerary;
    members: IItineraryMember[];
}

declare class ItineraryService {
    private socket;
    private readonly namespace;
    constructor();
    getByUserId(userId: string): Observable<IItinerary[]>;
    createOrUpdate(dto: ItineraryPrimaryInfoDto, id?: string): Observable<IItinerary>;
    getById(id: string): Observable<IItinerary>;
    findOneWithMembers(id: string): Observable<ItineraryMemberCompleteDTO>;
    getWithStatsByIds(ids: string[]): Observable<IItineraryStatsDto[]>;
    getAll(searchQuery?: string): Observable<IItineraryStatsDto[]>;
    private executeGetAllRequest;
    updateCommentsCount(id: string, increment: number): Observable<IItinerary>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ItineraryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ItineraryService>;
}

declare class ItineraryDetailComponent implements OnInit {
    private location;
    private route;
    private router;
    private itineraryService;
    ICONS: Iicon;
    itineraryWithStats: IItineraryStatsDto;
    id: string;
    tabMenuItems: MenuItem[];
    dropdownMenuItems: LibMenuItem[];
    isModalOpen: boolean;
    constructor(location: Location, route: ActivatedRoute, router: Router, itineraryService: ItineraryService);
    ngOnInit(): void;
    initializeTabMenuItems(): void;
    onModalConfirmed(): void;
    onModalDismissed(): void;
    back(): void;
    navToMembers(): void;
    onActiveItemChange(event: MenuItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ItineraryDetailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ItineraryDetailComponent, "app-itinerary-detail", never, {}, {}, never, never, false, never>;
}

export { ItineraryDetailComponent, ItineraryLibComponent, ItineraryLibModule, ItineraryLibRoutingModule, ItineraryLibService, httpLoaderFactory };