import { AuthConfig, OAuthService } from 'angular-oauth2-oidc';
import { ReplaySubject, BehaviorSubject, Subscription, Observable, Subject, PartialObserver, TeardownLogic, Subscribable } from 'rxjs';
import * as i0 from '@angular/core';
import { OnInit, EventEmitter, TemplateRef, OnDestroy, OnChanges, ElementRef, SimpleChanges, PipeTransform, AfterViewInit, ChangeDetectorRef, ViewContainerRef, ComponentFactoryResolver, ModuleWithProviders } from '@angular/core';
import * as i48 from '@ngx-translate/core';
import { TranslateService, TranslateModule } from '@ngx-translate/core';
import * as i43 from '@angular/common';
import { KeyValue, DatePipe } from '@angular/common';
import * as i45 from '@angular/router';
import { Params, ActivatedRoute, Router, ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree } from '@angular/router';
import * as i46 from '@ng-bootstrap/ng-bootstrap';
import { NgbDateParserFormatter, NgbDate, NgbCalendar, NgbDateStruct, NgbTimeStruct, NgbPopover, NgbPopoverConfig, NgbModal, NgbModalOptions, NgbModalRef } from '@ng-bootstrap/ng-bootstrap';
import * as i44 from '@angular/forms';
import { ControlValueAccessor, NgForm } from '@angular/forms';
import * as i47 from '@ng-select/ng-select';
import { DropdownPosition, NgSelectComponent } from '@ng-select/ng-select';
import { HttpClient, HttpParams, HttpRequest, HttpProgressEvent, HttpResponse, HttpErrorResponse, HttpParameterCodec, HttpInterceptor, HttpHandler, HttpEvent } from '@angular/common/http';

interface AppConfig {
    notAuthorizedRoute: string[];
    supportEmailAddress?: string;
}

interface HttpConfig {
    encoderUriPatterns: string[];
    authUriPatterns: string[];
    includeLanguageParam?: boolean;
}

interface ServiceConfig {
    appCode: number[];
    apiEndpoint: string;
}

declare class WorldskillsAngularLibService {
    defaultSupportEmailAddress: string;
    appConfigSubject: ReplaySubject<AppConfig>;
    httpConfigSubject: ReplaySubject<HttpConfig>;
    serviceConfigSubject: ReplaySubject<ServiceConfig>;
    authConfigSubject: ReplaySubject<AuthConfig>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WorldskillsAngularLibService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WorldskillsAngularLibService>;
}

declare class WorldskillsAngularLibComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorldskillsAngularLibComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WorldskillsAngularLibComponent, "ws-worldskills-angular-lib", never, {}, {}, never, never, false, never>;
}

declare enum AlertType {
    error = "alert-danger",
    info = "alert-info",
    success = "alert-success",
    warning = "alert-warning"
}

interface Alert {
    id: string;
    type: AlertType;
    title: string;
    message: string;
    closable: boolean;
    wsAlertComponentId: string;
}

declare class AlertService {
    alerts: Alert[];
    constructor();
    remove(id: string): void;
    setAlert(id: string, type: AlertType, title?: string, message?: string, closable?: boolean, wsAlertComponentId?: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AlertService>;
}

declare class AlertComponent implements OnInit {
    alertService: AlertService;
    alert: Alert;
    closeStyle: string;
    constructor(alertService: AlertService);
    ngOnInit(): void;
    ngOnChanges(): void;
    hasMessage(): boolean;
    hasTitle(): boolean;
    canClose(): boolean;
    dismiss(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AlertComponent, "ws-alert", never, { "alert": { "alias": "alert"; "required": false; }; "closeStyle": { "alias": "closeStyle"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AlertsComponent implements OnInit {
    alertService: AlertService;
    wsAlertComponentId: string;
    closeStyle: string;
    constructor(alertService: AlertService);
    ngOnInit(): void;
    get hasAlerts(): boolean;
    getMyAlertList(): Alert[];
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AlertsComponent, "ws-alerts", never, { "wsAlertComponentId": { "alias": "wsAlertComponentId"; "required": false; }; "closeStyle": { "alias": "closeStyle"; "required": false; }; }, {}, never, never, false, never>;
}

interface Breadcrumb {
    key: string;
    label: string;
    params?: Params;
    url: string;
}

declare class BreadcrumbsService {
    protected breadcrumbs: Breadcrumb[];
    breadcrumbsSubject: BehaviorSubject<Breadcrumb[]>;
    homeItemRoute: string;
    isAtHome: boolean;
    targetOutlet: string;
    replacements: KeyValue<string, string>[];
    showHomeItem: boolean;
    linkHomeItem: boolean;
    constructor();
    build(route: ActivatedRoute, url?: string, first?: boolean): void;
    createOrUpdateReplacement(key: string, value: string): number;
    replaceLabel(key: string, value: string): void;
    remove(key: string): void;
    add(breadcrumb: Breadcrumb): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BreadcrumbsService>;
}

declare class BreadcrumbsComponent implements OnInit {
    service: BreadcrumbsService;
    private router;
    private route;
    showHomeItem: boolean;
    homeItemRoute: string;
    homeItemText: string;
    replacementSubscription: Subscription;
    rebuildSubscription: Subscription;
    breadcrumbs: Breadcrumb[];
    isAtHome: boolean;
    constructor(service: BreadcrumbsService, router: Router, route: ActivatedRoute);
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbsComponent, "ws-breadcrumbs", never, { "showHomeItem": { "alias": "showHomeItem"; "required": false; }; "homeItemRoute": { "alias": "homeItemRoute"; "required": false; }; "homeItemText": { "alias": "homeItemText"; "required": false; }; }, {}, never, never, false, never>;
}

interface DateRange {
    start: Date;
    end: Date;
}

declare class DateRangeComponent implements ControlValueAccessor {
    private calendar;
    formatter: NgbDateParserFormatter;
    disabled: boolean;
    get opacity(): number;
    hoveredDate: NgbDate | null;
    fromDate: NgbDate | null;
    toDate: NgbDate | null;
    value: DateRange;
    change: EventEmitter<DateRange>;
    constructor(calendar: NgbCalendar, formatter: NgbDateParserFormatter);
    onDateSelection(date: NgbDate): void;
    isHovered(date: NgbDate): boolean;
    isInside(date: NgbDate): boolean;
    isRange(date: NgbDate): boolean;
    validateInput(currentValue: NgbDate | null, input: string): NgbDate | null;
    onChange: (range: DateRange) => void;
    onTouched: () => void;
    writeValue(obj: DateRange): void;
    toNgbDate(date: Date): NgbDate;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangeComponent, "ws-date-range", never, { "disabled": { "alias": "disabled"; "required": false; }; }, { "change": "change"; }, never, never, false, never>;
}

interface NgbDatetimeStruct extends NgbDateStruct, NgbTimeStruct {
}
declare class Datetime implements NgbDatetimeStruct {
    year: number;
    month: number;
    day: number;
    hour: number;
    minute: number;
    second: number;
    timeZoneOffset: number;
    constructor(init?: Partial<Datetime>);
    static asToday(): Datetime;
    static fromLocalString(dateString: string): Datetime;
    private isInteger;
    toString(): string;
}

declare class DatetimePickerComponent implements ControlValueAccessor {
    private config;
    disabled: boolean;
    readonly: boolean;
    get opacity(): number;
    inputDatetimeFormat: string;
    hourStep: number;
    minuteStep: number;
    secondStep: number;
    seconds: boolean;
    maxDate: NgbDateStruct;
    minDate: NgbDateStruct;
    showTimePickerToggle: boolean;
    value: Datetime;
    model: NgbDate | null;
    popover: NgbPopover;
    change: EventEmitter<Datetime>;
    onChange: (value: Datetime) => void;
    onTouched: () => void;
    constructor(config: NgbPopoverConfig);
    writeValue(obj: Datetime): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    onInputChange($event: any): void;
    toggleDateTimeState(): void;
    onDateChange(date: NgbDate): void;
    onTimeChange(event: NgbTimeStruct): void;
    onAccept(): void;
    inputBlur($event: any): void;
    toNgbDate(date: Date): NgbDate;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatetimePickerComponent, "ws-datetime-picker", never, { "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "inputDatetimeFormat": { "alias": "inputDatetimeFormat"; "required": false; }; "hourStep": { "alias": "hourStep"; "required": false; }; "minuteStep": { "alias": "minuteStep"; "required": false; }; "secondStep": { "alias": "secondStep"; "required": false; }; "seconds": { "alias": "seconds"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; }, { "change": "change"; }, never, never, false, never>;
}

interface EntityFetchParams {
    limit?: number;
    offset?: number;
    depth?: number;
    member_of?: number;
    name?: string;
    role?: string;
    roleApp?: number;
    sort?: 'name' | 'name_desc';
}

interface I18nText {
    lang_code: string;
    text: string;
    translations?: Map<string, string>;
}

declare class EntityTreeView {
    id: number;
    name: I18nText;
    parent_id: number;
    children: Array<EntityTreeView>;
    constructor(obj?: any);
}

declare class EntityTreeListView {
    total_count: number;
    ws_entity_list: Array<EntityTreeView>;
    constructor(obj?: any);
}

declare class CacheStorageService {
    constructor();
    get<T>(key: string, defaultValue?: T, engine?: Storage): T;
    set(key: string, value: any, engine?: Storage): void;
    setExpire(key: string, value: any, expire: Date): void;
    remove(key: string, engine?: Storage): void;
    fetchObservable<T>(fetchFn: () => Observable<T>, key: string, expire: Date, defaultValue?: T): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CacheStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CacheStorageService>;
}

declare class EntityTreeService {
    private cache;
    protected wsi: WorldskillsAngularLibService;
    protected http: HttpClient;
    constructor(cache: CacheStorageService, wsi: WorldskillsAngularLibService, http: HttpClient);
    private subjects;
    endpoint: string;
    subject: BehaviorSubject<EntityTreeListView>;
    static equals(a: EntityFetchParams, b: EntityFetchParams): boolean;
    clearCache(params?: EntityFetchParams): void;
    getCachedSubject(params?: EntityFetchParams, fetchOnCreate?: boolean): BehaviorSubject<EntityTreeListView>;
    list(params?: EntityFetchParams, legacyCaching?: boolean): Observable<EntityTreeListView>;
    listCached(params?: EntityFetchParams, cacheTime?: number): Observable<EntityTreeListView>;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityTreeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EntityTreeService>;
}

interface EntityTreeSelectLabels {
    clearAllText?: string;
    loadingText?: string;
    notFoundText?: string;
    typeToSearchText?: string;
    placeholder?: string;
}

interface EntityTreeSelectControls {
    wrapper?: TemplateRef<{
        $implicit: TemplateRef<void>;
    }>;
    expand?: TemplateRef<{
        enabled: boolean;
        click: () => void;
    }>;
    expandAll?: TemplateRef<{
        click: () => void;
    }>;
    collapse?: TemplateRef<{
        enabled: boolean;
        click: () => void;
    }>;
    collapseAll?: TemplateRef<{
        click: () => void;
    }>;
    separator?: TemplateRef<void>;
    showing?: TemplateRef<{
        showing: number;
        total: number;
    }>;
}

type TreeEntity = Omit<EntityTreeView, 'children'> & {
    parent: TreeEntity;
    children: TreeEntity[];
    fullPathName: string;
    paths: Array<string>;
    allPaths: Array<string>;
    selectable: boolean;
    filtered: boolean;
    type: 'treeEntity';
};

declare class EntityTreeSelectComponent implements OnInit, OnDestroy, OnChanges, ControlValueAccessor {
    private entityTreeService;
    /** labels for ng-select */
    labels: EntityTreeSelectLabels;
    /** control templates for the toolbar buttons */
    controls: EntityTreeSelectControls;
    /** query parameters to scope the available entities */
    query: Omit<EntityFetchParams, 'limit' | 'offset' | 'depth'>;
    /** entities input array */
    entities: Array<any>;
    /** force disable the following entities */
    disableEntities: Array<any>;
    /** always make children selectable of passed entities */
    selectableChildren: boolean;
    /** show unselectable parents */
    showUnselectableParents: boolean;
    /** whether or not to show the full path for selected entities */
    showFullPath: boolean;
    /** whether or not to show the header controls */
    showControls: boolean;
    /** whether to use api caching or not, caching is done per query request object, see EntityTreeService for more details */
    cache: boolean;
    /** implement the cache style for the entity tree. legacy = no changes; any other value uses the modern strategy */
    cacheStyle: string;
    /** time before cachce needs to be refreshed */
    cacheTimerMS: number;
    /** if the tree is expanded by default */
    defaultExpand: boolean;
    private expandedSearch;
    private flattenedEntities;
    private flattenedTreeEntities;
    private lastTerm;
    private lastSearch;
    private refreshing;
    private update;
    private htmlId;
    private fetchedTreeEntities;
    private cachedWriteValueSubject;
    private treeEntitiesSubject;
    private writeValueSubscription;
    hasFocus: boolean;
    loading: boolean;
    treeEntities: Array<TreeEntity>;
    expanded: Array<number>;
    /** ng-select input */
    appendTo: any;
    /** ng-select input */
    closeOnSelect: boolean;
    /** ng-select input */
    clearable: boolean;
    /** ng-select input */
    clearOnBackspace: boolean;
    /** ng-select input */
    dropdownPosition: DropdownPosition;
    /** ng-select input */
    markFirst: boolean;
    /** ng-select input */
    isOpen: boolean;
    /** ng-select input */
    maxSelectedItems: number;
    /** ng-select input */
    hideSelected: boolean;
    /** ng-select input */
    multiple: boolean;
    /** ng-select input */
    searchable: boolean;
    /** ng-select input */
    readonly: boolean;
    /** ng-select input */
    searchWhileComposing: boolean;
    /** ng-select input */
    selectOnTab: boolean;
    /** ng-select input */
    openOnEnter: boolean;
    /** ng-select input */
    virtualScroll: boolean;
    /** ng-select input */
    inputAttrs: {
        [key: string]: string;
    };
    /** ng-select input */
    tabIndex: number;
    /** ng-select output */
    blur: EventEmitter<any>;
    /** ng-select output */
    focus: EventEmitter<any>;
    /** ng-select output */
    change: EventEmitter<any>;
    /** ng-select output */
    open: EventEmitter<any>;
    /** ng-select output */
    close: EventEmitter<any>;
    /** ng-select output */
    search: EventEmitter<{
        term: string;
        items: TreeEntity[];
    }>;
    /** ng-select output */
    clear: EventEmitter<any>;
    /** ng-select output */
    add: EventEmitter<any>;
    /** ng-select output */
    remove: EventEmitter<any>;
    /** ng-select output */
    scroll: EventEmitter<{
        start: number;
        end: number;
    }>;
    /** ng-select output */
    scrollToEnd: EventEmitter<any>;
    ngSelectComponent: NgSelectComponent;
    ngSelectComponentRef: ElementRef;
    wrapperControl: TemplateRef<{
        $implicit: TemplateRef<void>;
    }>;
    expandControl: TemplateRef<{
        enabled: boolean;
        click: () => void;
    }>;
    expandAllControl: TemplateRef<{
        click: () => void;
    }>;
    collapseControl: TemplateRef<{
        enabled: boolean;
        click: () => void;
    }>;
    collapseAllControl: TemplateRef<{
        click: () => void;
    }>;
    separatorControl: TemplateRef<void>;
    showingControl: TemplateRef<{
        showing: number;
        total: number;
    }>;
    /** compare function for ng-select */
    compareWith: (a: any, b: any) => boolean;
    /** the id callback function for the Input entities */
    entityIdCallback: (entity: any) => number;
    constructor(entityTreeService: EntityTreeService);
    get currentMarkedEntity(): TreeEntity;
    get filtered(): number;
    get total(): number;
    get queryParams(): EntityFetchParams;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    private createTreeEntities;
    private deepCopyEntity;
    ngOnDestroy(): void;
    isDomIdentifier(name: string): boolean;
    getDomIdentifier(name: string): string;
    stripDomIdentifier(name: string): string;
    private flatten;
    private setParentsForEntities;
    private setPathNamesAndTypes;
    private setSelectable;
    private setSelectableForChildren;
    private clearSafeChildren;
    private clearUnselectableTrees;
    private clearUnselectableTree;
    private flattenUnselectableParents;
    isExpandable(entity: TreeEntity): boolean;
    expandFn(entity: TreeEntity): any;
    expand(entity: TreeEntity): void;
    expandAllFn(): any;
    expandAll(entities: Array<TreeEntity>, update?: boolean): void;
    expandArray(entities: Array<TreeEntity>): void;
    expandTree(entity: TreeEntity): void;
    expandTrees(entities: Array<TreeEntity>): void;
    collapseFn(entity: TreeEntity): any;
    collapse(entity: TreeEntity): void;
    collapseAllFn(): any;
    collapseAll(entities: Array<TreeEntity>, update?: boolean): void;
    toggleExpanded(entity: TreeEntity): void;
    toggleExpandedById(id: number): void;
    isTreeExpanded(entity: TreeEntity): boolean;
    isExpanded(entity: TreeEntity): boolean;
    isCollapsed(entity: TreeEntity): boolean;
    isVisible(entity: TreeEntity): boolean;
    trackByFn(entity: TreeEntity): any;
    onClear(event: any): void;
    onOpen(event: any): void;
    onSearch(event: {
        term: string;
        items: TreeEntity[];
    }): void;
    searchFn(term: string, entity: TreeEntity): boolean;
    private entityContainsSearchTerm;
    private childrenContainSearchTerm;
    onChange(entity: TreeEntity | Array<TreeEntity>): void;
    onClick(event: Event): void;
    onKeyDown(event: KeyboardEvent): void;
    private getFiltered;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    writeValue(obj: any): void;
    toId(obj: any): any;
    toTreeEntity(obj: any): any;
    toEntity(obj: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityTreeSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EntityTreeSelectComponent, "ws-entity-tree-select", never, { "labels": { "alias": "labels"; "required": false; }; "controls": { "alias": "controls"; "required": false; }; "query": { "alias": "query"; "required": false; }; "entities": { "alias": "entities"; "required": false; }; "disableEntities": { "alias": "disableEntities"; "required": false; }; "selectableChildren": { "alias": "selectableChildren"; "required": false; }; "showUnselectableParents": { "alias": "showUnselectableParents"; "required": false; }; "showFullPath": { "alias": "showFullPath"; "required": false; }; "showControls": { "alias": "showControls"; "required": false; }; "cache": { "alias": "cache"; "required": false; }; "cacheStyle": { "alias": "cacheStyle"; "required": false; }; "cacheTimerMS": { "alias": "cacheTimerMS"; "required": false; }; "defaultExpand": { "alias": "defaultExpand"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "clearOnBackspace": { "alias": "clearOnBackspace"; "required": false; }; "dropdownPosition": { "alias": "dropdownPosition"; "required": false; }; "markFirst": { "alias": "markFirst"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "maxSelectedItems": { "alias": "maxSelectedItems"; "required": false; }; "hideSelected": { "alias": "hideSelected"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "searchWhileComposing": { "alias": "searchWhileComposing"; "required": false; }; "selectOnTab": { "alias": "selectOnTab"; "required": false; }; "openOnEnter": { "alias": "openOnEnter"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "inputAttrs": { "alias": "inputAttrs"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "entityIdCallback": { "alias": "entityIdCallback"; "required": false; }; }, { "blur": "blur"; "focus": "focus"; "change": "change"; "open": "open"; "close": "close"; "search": "search"; "clear": "clear"; "add": "add"; "remove": "remove"; "scroll": "scroll"; "scrollToEnd": "scrollToEnd"; }, never, never, false, never>;
}

interface Language {
    code: string;
    name: string;
    alt: string[];
}

interface WsEntityModel {
    id: number;
    name: I18nText;
}

interface RoleApplicationModel {
    id: number;
    name: string;
    application_code: number;
    manages_own_roles: boolean;
}

interface Role {
    id: number;
    role_application_id: number;
    name: string;
    description: string;
    apply_per_entity: boolean;
    ws_entity: WsEntityModel;
    role_application: RoleApplicationModel;
    ws_entity_ids: number[];
}

interface User {
    id: number;
    person_id: number;
    legacy_id: number;
    first_name: string;
    last_name: string;
    puppeteer: any;
    username: string;
    email_addresses: string[];
    roles: Role[];
    user_profiles: any;
    active: boolean;
    password: any;
    pin: any;
    has_pin: boolean;
    preferred_lang: string;
}

declare class WsiTranslateService {
    translator: TranslateService;
    availableLanguages: {
        ar_AE: {};
        en: {
            translations: string;
            edit_all_translations: string;
            add_translation: string;
            remove: string;
            auth: {
                login: string;
                logout: string;
            };
            dialogue: {
                close: string;
            };
            footer: {
                copyright: {
                    contact: string;
                    privacy: string;
                    terms: string;
                    wsi: string;
                };
                links: {
                    forums: string;
                    glossary: string;
                    horizon: string;
                    'infrastructure.lists': string;
                    'my.worldskills': string;
                    registrations: string;
                    'skill.management': string;
                    wiw: string;
                };
                translation: {
                    language: string;
                    missing: string;
                };
            };
            polls: {
                vote_note_allowed: string;
                buttons: {
                    abstain: string;
                    delete: string;
                    edit: string;
                    'export.results': string;
                    extend: string;
                    'clear.vote': string;
                    reset: string;
                    'view.choices': string;
                    'view.results': string;
                    vote: string;
                    open: string;
                    close: string;
                };
                'created.by': string;
                messages: {
                    abstained: string;
                    anon: string;
                    choices: string;
                    voted: string;
                };
                points: string;
                status: string;
                selection: string;
                to: string;
                votes: string;
            };
            dates: {
                just_now: string;
                minute_ago: string;
                minutes_ago: string;
                hour_ago: string;
                hours_ago: string;
                yesterday: string;
                days_ago: string;
                week_ago: string;
                weeks_ago: string;
                soon: string;
                in_a_minute: string;
                in_n_minutes: string;
                in_an_hour: string;
                in_n_hours: string;
                tomorrow: string;
                in_n_days: string;
                in_a_week: string;
                in_n_weeks: string;
            };
            modals: {
                cancel: string;
                no: string;
                ok: string;
                yes: string;
            };
        };
        de: {
            auth: {
                login: string;
                logout: string;
            };
            dialogue: {
                close: string;
            };
            footer: {
                copyright: {
                    contact: string;
                    privacy: string;
                    terms: string;
                    wsi: string;
                };
                links: {
                    forums: string;
                    glossary: string;
                    'infrastructure.lists': string;
                    'my.worldskills': string;
                    registrations: string;
                };
                translation: {
                    language: string;
                    missing: string;
                };
            };
            polls: {
                buttons: {
                    abstain: string;
                    edit: string;
                    delete: string;
                    reset: string;
                };
            };
        };
        fr: {};
        fi: {
            auth: {
                login: string;
                logout: string;
            };
            dialogue: {
                close: string;
            };
            footer: {
                copyright: {
                    contact: string;
                    terms: string;
                    wsi: string;
                    privacy: string;
                };
                links: {
                    forums: string;
                    glossary: string;
                    'infrastructure.lists': string;
                    'my.worldskills': string;
                    registrations: string;
                    'skill.management': string;
                    wiw: string;
                };
                translation: {
                    language: string;
                    missing: string;
                };
            };
            polls: {
                buttons: {
                    abstain: string;
                    delete: string;
                    edit: string;
                    'export.results': string;
                    extend: string;
                    'clear.vote': string;
                    reset: string;
                    'view.choices': string;
                    'view.results': string;
                    vote: string;
                };
                'created.by': string;
                messages: {
                    anon: string;
                    choices: string;
                    voted: string;
                    abstained: string;
                };
                points: string;
                selection: string;
                status: string;
                to: string;
                votes: string;
            };
            dates: {
                minutes_ago: string;
                minute_ago: string;
                hour_ago: string;
                hours_ago: string;
                yesterday: string;
                week_ago: string;
                weeks_ago: string;
                soon: string;
                in_a_minute: string;
                in_n_minutes: string;
                in_an_hour: string;
                tomorrow: string;
                in_n_days: string;
                in_a_week: string;
                in_n_weeks: string;
                just_now: string;
                days_ago: string;
                in_n_hours: string;
            };
        };
        pt_BR: {};
        ru_RU: {};
        tt_RU: {};
        zh_CN: {};
    };
    onLangChanged: Subject<Language>;
    constructor(translator: TranslateService);
    init(code: string): any;
    mergeMissingKeys(obj: any, context: any): any;
    setUserLanguage(user: User): void;
    getCurrentOrDefaultCode(): string;
    getSelectedLanguage(): Language;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsiTranslateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WsiTranslateService>;
}

declare class FooterComponent implements OnInit {
    private wsi;
    private translator;
    date: any;
    languages: Language[];
    selectedLanguage: Language;
    isLoggedIn: boolean;
    currentUser: User;
    col1Template: TemplateRef<any>;
    col2Template: TemplateRef<any>;
    col3Template: TemplateRef<any>;
    col4Template: TemplateRef<any>;
    col5Template: TemplateRef<any>;
    col6Template: TemplateRef<any>;
    logoutClick: EventEmitter<any>;
    loginClick: EventEmitter<any>;
    col1DefaultTemplate: TemplateRef<any>;
    col6DefaultTemplate: TemplateRef<any>;
    colDefaultTemplate: TemplateRef<any>;
    supportEmail?: string;
    constructor(wsi: WorldskillsAngularLibService, translator: WsiTranslateService);
    ngOnInit(): void;
    login(): void;
    logout(): void;
    changeLanguage(model: Language): void;
    isLanguageSelected(model: Language): boolean;
    languagePrompt(): void;
    getLanguages(): Language[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FooterComponent, "ws-footer", never, { "isLoggedIn": { "alias": "isLoggedIn"; "required": false; }; "currentUser": { "alias": "currentUser"; "required": false; }; "col1Template": { "alias": "col1Template"; "required": false; }; "col2Template": { "alias": "col2Template"; "required": false; }; "col3Template": { "alias": "col3Template"; "required": false; }; "col4Template": { "alias": "col4Template"; "required": false; }; "col5Template": { "alias": "col5Template"; "required": false; }; "col6Template": { "alias": "col6Template"; "required": false; }; }, { "logoutClick": "logoutClick"; "loginClick": "loginClick"; }, never, never, false, never>;
}

interface MenuItem {
    label: string;
    params?: Params;
    url: string;
    hidden: boolean;
    requireLogin: boolean;
    requiredRoles: string[];
    subMenuItems?: MenuItem[];
}

declare class HeaderComponent implements OnInit {
    private router;
    private route;
    appName: string;
    isLoggedIn: boolean;
    showLoginAndLogoutButtons: boolean;
    menuItems: Array<MenuItem>;
    dropDownMenuItems: Array<MenuItem>;
    currentUser: User;
    linkTitle: boolean;
    appNameTemplate: TemplateRef<any>;
    menuTemplate: TemplateRef<any>;
    subMenuTemplate: TemplateRef<any>;
    logoutClick: EventEmitter<any>;
    loginClick: EventEmitter<any>;
    constructor(router: Router, route: ActivatedRoute);
    ngOnInit(): void;
    ngOnChanges(): void;
    userRoles(): string[];
    isRouteActive(item: MenuItem): boolean;
    getActiveParentMenu(): MenuItem;
    hasSubMenuItems(item: MenuItem): boolean;
    getSubMenuItems(item: MenuItem): MenuItem[];
    login(): void;
    logout(): void;
    getInitials(): string;
    showMenu(): boolean;
    showLoginButton(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "ws-header", never, { "appName": { "alias": "appName"; "required": false; }; "isLoggedIn": { "alias": "isLoggedIn"; "required": false; }; "showLoginAndLogoutButtons": { "alias": "showLoginAndLogoutButtons"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; "dropDownMenuItems": { "alias": "dropDownMenuItems"; "required": false; }; "currentUser": { "alias": "currentUser"; "required": false; }; "linkTitle": { "alias": "linkTitle"; "required": false; }; "appNameTemplate": { "alias": "appNameTemplate"; "required": false; }; "menuTemplate": { "alias": "menuTemplate"; "required": false; }; "subMenuTemplate": { "alias": "subMenuTemplate"; "required": false; }; }, { "logoutClick": "logoutClick"; "loginClick": "loginClick"; }, never, never, false, never>;
}

declare class LogoComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LogoComponent, "ws-logo", never, {}, {}, never, never, false, never>;
}

declare class MenuAccessPipe implements PipeTransform {
    transform(items: MenuItem[], isLoggedIn: boolean, roles: string[]): MenuItem[];
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuAccessPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MenuAccessPipe, "wsMenuAccessFilter", false>;
}

interface CreatedBy {
    id: number;
    firstName: string;
    lastName: string;
}

interface EntityPathItem {
    id: number;
    text: string;
    hasChildren: boolean;
}

interface EntityPath {
    pieces: EntityPathItem[];
}

interface Option {
    id: number;
    text: I18nText;
    deleted: boolean;
}

interface Person {
    id: number;
    firstName: string;
    lastName: string;
}

interface VoteEntry {
    rank: number;
    optionId: number;
}

interface Vote {
    hasVoted: boolean;
    votes: VoteEntry[];
    anonymous: boolean;
    abstained: boolean;
}

interface Poll {
    id: number;
    entity: WsEntityModel;
    entityPath: EntityPath;
    deleted: boolean;
    anonymousVoting: boolean;
    anonymousResults: boolean;
    showingResults: boolean;
    allowingReVote: boolean;
    allowingAbstain: boolean;
    whitelist: boolean;
    title: I18nText;
    question: I18nText;
    resultText?: I18nText;
    type: string;
    numberOfSelections: number;
    created: Date;
    start: Date;
    expiry: Date;
    createdBy: CreatedBy;
    options: Option[];
    userVote?: Vote;
    listId?: number;
    allowedVoters?: Person[];
    dependsOn?: Poll;
}

interface Result {
    id: number;
    count: number;
    points: number;
    option: Option;
}

interface Abstain {
    id: number;
    pollId: number;
    timestamp: Date;
}

interface PersonPosition {
    id: number;
    start: Date;
    end: Date;
    name: string;
    entityId: number;
    posId: number;
    memberCode: string;
}

interface Track {
    personId: number;
    firstName: string;
    lastName: string;
    option: Option;
    weight: number;
    timestamp: Date;
    abstain?: Abstain;
    imagePath?: string;
    relativePosition: PersonPosition;
    positions: PersonPosition[];
    voteIndex: number;
}

interface OptionResultView extends Option {
    points: number;
    votes: number;
}

declare class PollResultComponent implements OnInit {
    max: number;
    poll: Poll;
    results: Result[];
    tracks: Track[];
    canSeeWhoVoted: any;
    optionResultItems: OptionResultView[];
    constructor();
    ngOnInit(): void;
    ngOnChanges(): void;
    init(): void;
    getPeople(option: Option): Track[];
    getVoter(track: Track): string;
    getVoterHover(track: Track): string;
    countVotes(option: Option): number;
    countPoints(option: Option): number;
    showVoteIndex(): boolean;
    getVoteIndex(track: Track): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PollResultComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PollResultComponent, "ws-poll-result", never, { "poll": { "alias": "poll"; "required": false; }; "results": { "alias": "results"; "required": false; }; "tracks": { "alias": "tracks"; "required": false; }; "canSeeWhoVoted": { "alias": "canSeeWhoVoted"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PuppeteerBannerComponent implements OnInit {
    currentUser: User;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PuppeteerBannerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PuppeteerBannerComponent, "ws-puppeteer-banner", never, { "currentUser": { "alias": "currentUser"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * @deprecated The method should not be used. use tthe relative-date component instead
 */
interface RelativeDateProcessor {
    handlePastDate(date: Date): string;
    handleFutureDate(date: Date): string;
}

declare class RelativeDatePipe implements PipeTransform {
    /**
     * @deprecated The method should not be used. use tthe relative-date component instead
     */
    transform(value: Date, format?: string, locale?: string, processor?: RelativeDateProcessor): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<RelativeDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RelativeDatePipe, "relativeDate", false>;
}

type SelectAsyncSearchObserverResolver = PartialObserver<string> | ((value: string) => void) | ((value: string) => Observable<string>);

interface SelectAsyncSearchSettingsAdvanced {
    minCharacters?: number;
    debounceTime?: number;
    message?: string | TemplateRef<any>;
    onValid?: (valid: boolean) => void;
    observer: SelectAsyncSearchObserverResolver;
}

type SelectAsyncSearchSettings = SelectAsyncSearchSettingsAdvanced | SelectAsyncSearchObserverResolver;

interface SelectChangeEvent<T = any, U = any> {
    item: T;
    original: {
        label: string;
        value: U;
        [key: string]: any;
    };
    value: U;
}

type EntryReader<T = any, U = any> = string | Array<string> | ((obj: T) => U);
declare class SelectDirective implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    private ngSelectComponent;
    private changeDetectorRef;
    private viewContainerRef;
    private componentFactoryResolver;
    entryReader: [
        EntryReader,
        EntryReader,
        EntryReader | undefined
    ] | [
        EntryReader,
        EntryReader
    ] | {
        labelReader: EntryReader;
        valueReader: EntryReader;
        groupReader?: EntryReader;
    };
    items: any;
    wsChange: EventEmitter<SelectChangeEvent>;
    labelReader: EntryReader;
    valueReader: EntryReader;
    groupReader: EntryReader;
    asyncSearch: SelectAsyncSearchSettings;
    private originalItems;
    private asyncHandler;
    constructor(ngSelectComponent: NgSelectComponent, changeDetectorRef: ChangeDetectorRef, viewContainerRef: ViewContainerRef, componentFactoryResolver: ComponentFactoryResolver);
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private updateItems;
    private readObjectLabel;
    private readObjectValue;
    private readObjectGroup;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectDirective, [{ optional: true; host: true; self: true; }, null, null, null]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectDirective, "[wsSelect]", never, { "entryReader": { "alias": "wsSelect"; "required": false; }; "items": { "alias": "items"; "required": false; }; "labelReader": { "alias": "labelReader"; "required": false; }; "valueReader": { "alias": "valueReader"; "required": false; }; "groupReader": { "alias": "groupReader"; "required": false; }; "asyncSearch": { "alias": "asyncSearch"; "required": false; }; }, { "wsChange": "wsChange"; }, never, never, false, never>;
}

declare class SelectAsyncHeaderComponent {
    content: string | TemplateRef<any>;
    templateRef: any;
    get isString(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectAsyncHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectAsyncHeaderComponent, "ws-select-async-header", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SortPipe implements PipeTransform {
    transform(items: any, direction?: any, property?: any): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<SortPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SortPipe, "wsSort", false>;
}

declare class StagingBannerComponent implements OnInit {
    message: string;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StagingBannerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StagingBannerComponent, "ws-staging-banner", never, { "message": { "alias": "message"; "required": false; }; }, {}, never, never, false, never>;
}

interface OptionHandler {
    onOptionSelect(pollType: string, currentSelection: any[], newSelectedValue: any, selectionIndex: number): any[];
}

declare class StandardPollComponent implements OnInit {
    poll: Poll;
    voted: Vote;
    initialSelection: VoteEntry[];
    optionSelected: EventEmitter<VoteEntry[]>;
    optionHandler: OptionHandler;
    selection: VoteEntry;
    constructor();
    ngOnInit(): void;
    ngOnChanges(): void;
    init(): void;
    loadDefaultSelection(): void;
    isSelected(option: Option): boolean;
    onOptionSelect(option: Option): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StandardPollComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StandardPollComponent, "ws-standard-poll", never, { "poll": { "alias": "poll"; "required": false; }; "voted": { "alias": "voted"; "required": false; }; "initialSelection": { "alias": "initialSelection"; "required": false; }; "optionHandler": { "alias": "optionHandler"; "required": false; }; }, { "optionSelected": "optionSelected"; }, never, never, false, never>;
}

declare class WsiToastService {
    constructor();
    toasts: any[];
    show(textOrTpl: string | TemplateRef<any>, options?: any): void;
    remove(toast: any): void;
    showStandard(msg: string): void;
    showSuccess(title: string, msg: string): void;
    showError(title: string, msg: string): void;
    showCustomToast(customTpl: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsiToastService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WsiToastService>;
}

declare class VoteControlComponent implements OnInit {
    private toasts;
    personId: any;
    useToastNotifications: boolean;
    showEditButton: boolean;
    showExtendButton: boolean;
    showResetButton: boolean;
    showDeleteButton: boolean;
    showExportButton: boolean;
    showOpenButton: boolean;
    showCloseButton: boolean;
    showCustomView: boolean;
    poll: Poll;
    results: Result[];
    voted: Vote;
    votedDependsOn: Vote;
    tracks: Track[];
    confirmBeforeVote: boolean;
    confirmBeforeAbstain: boolean;
    optionHandler: OptionHandler;
    isOwner: boolean;
    beforeOptionsTemplate: TemplateRef<any>;
    optionsDefaultTemplate: TemplateRef<any>;
    optionsTemplate: TemplateRef<any>;
    afterOptionsTemplate: TemplateRef<any>;
    beforeResultTemplate: TemplateRef<any>;
    resultDefaultTemplate: TemplateRef<any>;
    resultTemplate: TemplateRef<any>;
    afterResultTemplate: TemplateRef<any>;
    controlBarLeftTemplate: TemplateRef<any>;
    controlBarRightTemplate: TemplateRef<any>;
    titleTemplate: TemplateRef<any>;
    footerTemplate: TemplateRef<any>;
    questionTemplate: TemplateRef<any>;
    customViewTemplate: TemplateRef<any>;
    edit: EventEmitter<Poll>;
    extend: EventEmitter<Poll>;
    reset: EventEmitter<Poll>;
    delete: EventEmitter<Poll>;
    viewChange: EventEmitter<string>;
    voteSelected: EventEmitter<VoteEntry[]>;
    abstainSelected: EventEmitter<any>;
    voteRemoved: EventEmitter<VoteEntry[]>;
    exportClicked: EventEmitter<any>;
    openClicked: EventEmitter<Poll>;
    closeClicked: EventEmitter<Poll>;
    view: string;
    subscription: Subscription;
    state: string;
    selection: VoteEntry[];
    dateFormat: string;
    constructor(toasts: WsiToastService);
    ngOnInit(): void;
    ngOnChanges(): void;
    init(): void;
    calculateState(): void;
    notifyInfo(message: string): void;
    notifySuccess(title: string, message: string): void;
    notifyError(title: string, message: string): void;
    selected(model: VoteEntry[]): void;
    vote(): void;
    abstain(): void;
    unvote(): void;
    changeView(view: string): void;
    viewResultsState(): boolean;
    hasVotesSelected(): boolean;
    editClick(poll: Poll): void;
    extendClick(poll: Poll): void;
    resetClick(poll: Poll): void;
    deleteClick(poll: Poll): void;
    openClick(poll: Poll): void;
    closeClick(poll: Poll): void;
    getVoteText(entry: VoteEntry): string;
    isWhiteListed(): boolean;
    showVoteButton(): boolean;
    showAbstainButton(): boolean;
    showClearVoteButton(): boolean;
    showManageButton(): boolean;
    showWhoVoted(): boolean;
    export(): void;
    useDateRange(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<VoteControlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VoteControlComponent, "ws-vote-control", never, { "personId": { "alias": "personId"; "required": false; }; "useToastNotifications": { "alias": "useToastNotifications"; "required": false; }; "showEditButton": { "alias": "showEditButton"; "required": false; }; "showExtendButton": { "alias": "showExtendButton"; "required": false; }; "showResetButton": { "alias": "showResetButton"; "required": false; }; "showDeleteButton": { "alias": "showDeleteButton"; "required": false; }; "showExportButton": { "alias": "showExportButton"; "required": false; }; "showOpenButton": { "alias": "showOpenButton"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; }; "showCustomView": { "alias": "showCustomView"; "required": false; }; "poll": { "alias": "poll"; "required": false; }; "results": { "alias": "results"; "required": false; }; "voted": { "alias": "voted"; "required": false; }; "votedDependsOn": { "alias": "votedDependsOn"; "required": false; }; "tracks": { "alias": "tracks"; "required": false; }; "confirmBeforeVote": { "alias": "confirmBeforeVote"; "required": false; }; "confirmBeforeAbstain": { "alias": "confirmBeforeAbstain"; "required": false; }; "optionHandler": { "alias": "optionHandler"; "required": false; }; "isOwner": { "alias": "isOwner"; "required": false; }; "beforeOptionsTemplate": { "alias": "beforeOptionsTemplate"; "required": false; }; "optionsDefaultTemplate": { "alias": "optionsDefaultTemplate"; "required": false; }; "optionsTemplate": { "alias": "optionsTemplate"; "required": false; }; "afterOptionsTemplate": { "alias": "afterOptionsTemplate"; "required": false; }; "beforeResultTemplate": { "alias": "beforeResultTemplate"; "required": false; }; "resultDefaultTemplate": { "alias": "resultDefaultTemplate"; "required": false; }; "resultTemplate": { "alias": "resultTemplate"; "required": false; }; "afterResultTemplate": { "alias": "afterResultTemplate"; "required": false; }; "controlBarLeftTemplate": { "alias": "controlBarLeftTemplate"; "required": false; }; "controlBarRightTemplate": { "alias": "controlBarRightTemplate"; "required": false; }; "titleTemplate": { "alias": "titleTemplate"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; "questionTemplate": { "alias": "questionTemplate"; "required": false; }; "customViewTemplate": { "alias": "customViewTemplate"; "required": false; }; }, { "edit": "edit"; "extend": "extend"; "reset": "reset"; "delete": "delete"; "viewChange": "viewChange"; "voteSelected": "voteSelected"; "abstainSelected": "abstainSelected"; "voteRemoved": "voteRemoved"; "exportClicked": "exportClicked"; "openClicked": "openClicked"; "closeClicked": "closeClicked"; }, never, never, false, never>;
}

declare class WordmarkComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WordmarkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WordmarkComponent, "ws-wordmark", never, {}, {}, never, never, false, never>;
}

declare class WeightedPollComponent implements OnInit {
    poll: Poll;
    voted: Vote;
    initialSelection: VoteEntry[];
    optionHandler: OptionHandler;
    optionSelected: EventEmitter<VoteEntry[]>;
    numSelections: number[];
    models: string[];
    constructor();
    ngOnInit(): void;
    init(): void;
    change(event: any, index: any): void;
    hasMaxSelections(): boolean;
    numberToWord(num: number): string;
    calcPointsForItem(num: number): number;
    isSelected(optionId: number): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<WeightedPollComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WeightedPollComponent, "ws-weighted-poll", never, { "poll": { "alias": "poll"; "required": false; }; "voted": { "alias": "voted"; "required": false; }; "initialSelection": { "alias": "initialSelection"; "required": false; }; "optionHandler": { "alias": "optionHandler"; "required": false; }; }, { "optionSelected": "optionSelected"; }, never, never, false, never>;
}

declare class MultiselectPollComponent implements OnInit {
    poll: Poll;
    voted: Vote;
    initialSelection: VoteEntry[];
    optionSelected: EventEmitter<VoteEntry[]>;
    optionHandler: OptionHandler;
    numSelections: number[];
    models: string[];
    constructor();
    ngOnInit(): void;
    init(): void;
    change(event: any, index: any): void;
    hasMaxSelections(): boolean;
    numberToWord(num: number): string;
    isSelected(optionId: number): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiselectPollComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiselectPollComponent, "ws-multiselect-poll", never, { "poll": { "alias": "poll"; "required": false; }; "voted": { "alias": "voted"; "required": false; }; "initialSelection": { "alias": "initialSelection"; "required": false; }; "optionHandler": { "alias": "optionHandler"; "required": false; }; }, { "optionSelected": "optionSelected"; }, never, never, false, never>;
}

interface UserList {
    total_count: number;
    users: User[];
}

interface GetUsersParams {
    un?: string;
    fn?: string;
    ln?: string;
    sort?: string;
    role?: string;
    app_code?: number;
    role_id?: number;
    offset: number;
    limit: number;
    ws_entity?: number;
    ws_entity_precise?: boolean;
}

declare class AuthService {
    protected wsi: WorldskillsAngularLibService;
    protected http: HttpClient;
    protected appCode: number[];
    protected endpoint: string;
    constructor(wsi: WorldskillsAngularLibService, http: HttpClient);
    getLoggedInUser(showCollapsedChildRoles?: boolean): Observable<User>;
    logout(): Observable<any>;
    ping(): Observable<any>;
    listUsers(filter: GetUsersParams): Observable<UserList>;
    getUser(id: number): Observable<User>;
    getUserByPerson(id: number): Observable<User>;
    addRole(userId: number, roleId: number): Observable<any>;
    addRoleWithEntity(userId: number, roleId: number, entityId: number): Observable<any>;
    deleteRole(userId: number, roleId: number): Observable<any>;
    deleteRoleWithEntity(userId: number, roleId: number, entityId: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
}

declare class NgAuthService {
    private wsi;
    private oAuthService;
    authService: AuthService;
    currentUser: BehaviorSubject<User>;
    constructor(wsi: WorldskillsAngularLibService, oAuthService: OAuthService, authService: AuthService);
    keepAlive(): Observable<any>;
    isLoggedIn(): boolean;
    getLoggedInUser(showChildRoles?: boolean): Observable<User>;
    login(): void;
    logout(): Observable<any>;
    clearSession(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgAuthService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgAuthService>;
}

declare class UserRoleDirective implements OnInit {
    private templateRef;
    private viewContainerRef;
    private ngAuthService;
    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef, ngAuthService: NgAuthService);
    wsUserRole: string | Array<string>;
    wsUserRoleUser: User | true;
    wsUserRoleAll: boolean;
    wsUserRoleEntity: number | {
        id: number;
    };
    wsUserRoleAppId: number;
    wsUserRoleNegate: boolean;
    ngOnInit(): void;
    private renderIfValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserRoleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UserRoleDirective, "[wsUserRole]", never, { "wsUserRole": { "alias": "wsUserRole"; "required": false; }; "wsUserRoleUser": { "alias": "wsUserRoleUser"; "required": false; }; "wsUserRoleAll": { "alias": "wsUserRoleAll"; "required": false; }; "wsUserRoleEntity": { "alias": "wsUserRoleEntity"; "required": false; }; "wsUserRoleAppId": { "alias": "wsUserRoleAppId"; "required": false; }; "wsUserRoleNegate": { "alias": "wsUserRoleNegate"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AuthHeaderComponent implements OnInit {
    private router;
    private ngAuthService;
    appName: string;
    menuItems: Array<MenuItem>;
    onLogin: EventEmitter<void>;
    onLogout: EventEmitter<void>;
    appNameTemplate: TemplateRef<any>;
    menuTemplate: TemplateRef<any>;
    autoLoginOnLogout: boolean;
    currentUser: User;
    constructor(router: Router, ngAuthService: NgAuthService);
    ngOnInit(): void;
    isRouteActive(route: any): boolean;
    login(): void;
    logout(): void;
    get userRoles(): string[];
    get initials(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AuthHeaderComponent, "ws-auth-header", never, { "appName": { "alias": "appName"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; "appNameTemplate": { "alias": "appNameTemplate"; "required": false; }; "menuTemplate": { "alias": "menuTemplate"; "required": false; }; "autoLoginOnLogout": { "alias": "autoLoginOnLogout"; "required": false; }; }, { "onLogin": "onLogin"; "onLogout": "onLogout"; }, never, never, false, never>;
}

declare class AuthFooterComponent implements OnInit {
    private ngAuthService;
    private wsi;
    private translator;
    date: any;
    languages: Language[];
    selectedLanguage: Language;
    col1Template: TemplateRef<any>;
    col2Template: TemplateRef<any>;
    col3Template: TemplateRef<any>;
    col4Template: TemplateRef<any>;
    col5Template: TemplateRef<any>;
    col6Template: TemplateRef<any>;
    onLogin: EventEmitter<void>;
    onLogout: EventEmitter<void>;
    loginLabel: string;
    logoutLabel: string;
    languageChange: EventEmitter<Language>;
    autoLoginOnLogout: boolean;
    currentUser: User;
    col1DefaultTemplate: TemplateRef<any>;
    col6DefaultTemplate: TemplateRef<any>;
    colDefaultTemplate: TemplateRef<any>;
    supportEmail?: string;
    constructor(ngAuthService: NgAuthService, wsi: WorldskillsAngularLibService, translator: WsiTranslateService);
    ngOnInit(): void;
    login(): void;
    logout(): void;
    changeLanguage(model: Language): void;
    isLanguageSelected(model: Language): boolean;
    languagePrompt(): void;
    getLanguages(): Language[];
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AuthFooterComponent, "ws-auth-footer", never, { "col1Template": { "alias": "col1Template"; "required": false; }; "col2Template": { "alias": "col2Template"; "required": false; }; "col3Template": { "alias": "col3Template"; "required": false; }; "col4Template": { "alias": "col4Template"; "required": false; }; "col5Template": { "alias": "col5Template"; "required": false; }; "col6Template": { "alias": "col6Template"; "required": false; }; "loginLabel": { "alias": "loginLabel"; "required": false; }; "logoutLabel": { "alias": "logoutLabel"; "required": false; }; "autoLoginOnLogout": { "alias": "autoLoginOnLogout"; "required": false; }; }, { "onLogin": "onLogin"; "onLogout": "onLogout"; "languageChange": "languageChange"; }, never, never, false, never>;
}

interface ResourceThumbnail {
    resource_id: number;
    filename: string;
    thumbnailLink?: string;
    description?: string;
    fileSize?: number | string;
    downloadLink?: string;
}
declare class ResourceThumbnailComponent implements OnInit {
    showDetailInfo: boolean;
    constructor();
    private _resourceThumbnail;
    get resourceThumbnail(): ResourceThumbnail;
    set resourceThumbnail(view: ResourceThumbnail);
    ngOnInit(): void;
    isNumber(value: any): boolean;
    showDownload(): boolean;
    getFileTypeIcon(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceThumbnailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceThumbnailComponent, "ws-resource-thumbnail", never, { "resourceThumbnail": { "alias": "resourceThumbnail"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FileSizePipe implements PipeTransform {
    transform(size: number, ...args: unknown[]): unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FileSizePipe, "fileSize", false>;
}

declare class UploadService {
    private http;
    constructor(http: HttpClient);
    prepareUpload(url: string, data: FormData, params: HttpParams, method?: string): HttpRequest<FormData>;
    listen<T>(request: HttpRequest<FormData>, onProgress: (progress: HttpProgressEvent) => void, onComplete: (response: HttpResponse<T>) => void, onError?: (error: HttpErrorResponse) => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UploadService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UploadService>;
}

interface Link {
    rel: string;
    href: string;
    content_type?: string;
    description?: string;
}

interface StorageType {
    code: string;
    id: number;
    name: string;
}

interface Pair {
    name: string;
    value: string;
}

interface Translation {
    contact: any;
    id: number;
    date: string;
    filename: string;
    links: Link[];
    modified_date: string;
    lang_code: string;
    storage_type: StorageType;
    storage_data: Pair[];
}

interface Version {
    id: number;
    name: string;
    date: string;
    modified_date: string;
    translations: Translation[];
    tags: string[];
}

interface ResourceMetadataInfo {
    id: number;
    name: I18nText;
    description: I18nText;
    multiline: boolean;
}

interface ResourceTypeMetadata {
    metadata: ResourceMetadataInfo;
    required: boolean;
}

interface ResourceType {
    id: number;
    description: I18nText;
    name: string;
    metadata: ResourceTypeMetadata[];
}

interface ResourceMetadata {
    metadata: ResourceMetadataInfo;
    value: string;
}

interface Resource {
    id: number;
    name: I18nText;
    metadata: ResourceMetadata[];
    links: Link[];
    ws_entity: WsEntityModel;
    resource_types: ResourceType[];
    versions: Version[];
    tags: string[];
}

interface ResourceSearch {
    tags?: string[];
    name?: string;
    ws_entity?: number[];
    type?: number[];
    sort?: string;
    date?: string;
    meta_text?: string;
    meta_type?: number[];
    offset: number;
    limit: number;
}

interface ResourceContainer {
    resources: Resource[];
    total_count: number;
}

interface TranslationCreate {
    version: number;
    lang_code: string;
    storage_type: number;
    storage_data: Pair[];
}

interface VersionCreate {
    name: string;
    date?: string;
    translation?: TranslationCreate;
    tags?: string[];
}

interface ResourceMetadataUpdate {
    metadata: number;
    value: string;
}

declare class ResourceUpload {
    name: I18nText;
    ws_entity: number;
    types: number[];
    version: VersionCreate;
    metadata: ResourceMetadataUpdate[];
    tags: string[];
    constructor(obj?: Partial<ResourceUpload>);
    static fromResource(resource: Resource): ResourceUpload;
}

/**
 * Example usage:
 *
 * fetch(eventId: number, rOpt?: RequestOptions): Observable<T>;
 * fetch(eventId: number, params: FetchParams, rOpt?: RequestOptions): Observable<T>;
 * fetch(eventId: number, mOpt: MulticastOptions, rOpt?: RequestOptions): Observable<T>;
 * fetch(eventId: number, params: FetchParams, mOpt: MulticastOptions, rOpt?: RequestOptions): Observable<T>;
 * fetch(eventId: number, p1: P1, p2?: P2, p3?: P3): Observable<T> {
 *   const {fetchParams, multicastOptions, requestOptions} = this.resolveArgs(p1, p2, p3, FULL);
 *   const params: HttpParams = httpParamsFromFetchParams(fetchParams);
 *   const observable = this.http.get<T>("http://example.com", {params}).pipe(share());
 *   return this.request(observable, multicastOptions);
 * }
 */
interface MulticastOptions {
    subject?: boolean;
    loader?: boolean;
    subscription?: boolean;
    onError?: (error: any) => void;
}
interface FetchParams {
    limit?: number;
    offset?: number;
    sort?: string;
    l?: string;
}
interface RequestOptions {
    url?: string;
}
declare function isMulticastOptions(object: any): object is MulticastOptions;
declare function isFetchParams(object: any): object is FetchParams;
declare function isRequestOptions(object: any): object is RequestOptions;
type WsServiceRequestP1 = FetchParams | MulticastOptions | RequestOptions;
type WsServiceRequestP2 = MulticastOptions | RequestOptions;
type WsServiceRequestP3 = RequestOptions;
declare const FULL: MulticastOptions;
declare const LOADER_ONLY: MulticastOptions;
declare const NO_SUBJECT: MulticastOptions;
declare abstract class WsService<T, U extends FetchParams = FetchParams> {
    private loaders;
    private subscription;
    subject: ReplaySubject<T>;
    loading: ReplaySubject<boolean>;
    protected constructor();
    protected resolveArgs(p1: WsServiceRequestP1, p2: WsServiceRequestP2, p3: WsServiceRequestP3, defaultMulticastOptions: MulticastOptions, defaultFetchParams?: U): {
        fetchParams: U;
        multicastOptions: MulticastOptions;
        requestOptions: RequestOptions;
    };
    private incrementLoader;
    private decrementLoader;
    protected multicast(observable: Observable<T | T[]>, options?: MulticastOptions): void;
    protected request(observable: Observable<T>, options?: MulticastOptions): Observable<T>;
    protected requestMany(observables: Array<Observable<T>>, options?: MulticastOptions): Observable<Array<T>>;
}

declare class ResourceService extends WsService<any> {
    private wsi;
    private http;
    uploader: UploadService;
    private url;
    constructor(wsi: WorldskillsAngularLibService, http: HttpClient, uploader: UploadService);
    search(filter: ResourceSearch): Observable<ResourceContainer>;
    get(id: number): Observable<Resource>;
    delete(id: number): Observable<any>;
    update(id: number, model: ResourceUpload): Observable<Resource>;
    upload(data: ResourceUpload, file: any, method?: string, id?: number): HttpRequest<FormData>;
    listTypes(): Observable<ResourceType[]>;
    getType(id: number): Observable<ResourceType>;
    listMetadata(): Observable<ResourceMetadataInfo[]>;
    getMetadata(id: number): Observable<ResourceMetadataInfo>;
    createMetadata(model: ResourceMetadataInfo): Observable<ResourceMetadataInfo>;
    updateMetadata(id: number, model: ResourceMetadataInfo): Observable<ResourceMetadataInfo>;
    deleteMetadata(id: number): Observable<any>;
    downloadResources(resourceIds: number[]): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceService>;
}

declare abstract class WsComponent implements OnDestroy {
    protected subscriptions: Subscription;
    constructor();
    ngOnDestroy(): void;
    protected subscribe(...teardowns: Array<TeardownLogic>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WsComponent, never, never, {}, {}, never, never, true, never>;
}

declare class ResourceThumbnailContainerComponent extends WsComponent implements OnInit {
    private resourceService;
    private datePipe;
    private alertService;
    title: string;
    resourceThumbnailList: ResourceThumbnail[];
    isZippingFiles: boolean;
    constructor(resourceService: ResourceService, datePipe: DatePipe, alertService: AlertService);
    get getDownloadAllBtnText(): string;
    ngOnInit(): void;
    showDownloadAll(): boolean;
    downloadAllResourcesAsZipFile(): void;
    private createDownloadLink;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceThumbnailContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceThumbnailContainerComponent, "ws-resource-thumbnail-container", never, { "title": { "alias": "title"; "required": false; }; "resourceThumbnailList": { "alias": "resourceThumbnailList"; "required": false; }; }, {}, never, never, false, never>;
}

declare class I18nTextComponent implements OnInit, ControlValueAccessor {
    private modalService;
    languages: Language[];
    inputId: string;
    name: string;
    placeholder: string;
    required: boolean;
    model: I18nText;
    private onChange;
    private onTouched;
    constructor(modalService: NgbModal);
    ngOnInit(): void;
    switchTranslation(translation: any): void;
    editAllTranslations(content: any): void;
    getLanguages(): Language[];
    changeTranslation(lang_code: any, text: any): void;
    addTranslation(lang_code: any): void;
    deleteTranslation(lang_code: any): void;
    blurTranslation(): void;
    numTranslations(): number;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<I18nTextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<I18nTextComponent, "ws-i18n-text", never, { "inputId": { "alias": "inputId"; "required": false; }; "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, never, false, never>;
}

declare class I18nTextboxComponent implements OnInit {
    valueChanged: EventEmitter<I18nText[]>;
    allowedLanguages: Language[];
    defaultLanguage: Language;
    currentCode: string;
    text: string;
    show: boolean;
    value: I18nText[];
    disaableLangChange: boolean;
    constructor();
    ngOnInit(): void;
    ngOnChanges(): void;
    getValues(): I18nText[];
    textChanged(text: string): void;
    selectLang(lang: I18nText): void;
    loadText(): void;
    getLang(code: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<I18nTextboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<I18nTextboxComponent, "ws-i18n-textbox", never, { "value": { "alias": "value"; "required": false; }; "disaableLangChange": { "alias": "disaableLangChange"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, false, never>;
}

declare class I18nTextareaComponent implements OnInit {
    valueChanged: EventEmitter<I18nText[]>;
    allowedLanguages: Language[];
    defaultLanguage: Language;
    currentCode: string;
    text: string;
    show: boolean;
    value: I18nText[];
    disaableLangChange: boolean;
    constructor();
    ngOnInit(): void;
    ngOnChanges(): void;
    getValues(): I18nText[];
    textChanged(text: string): void;
    selectLang(lang: I18nText): void;
    loadText(): void;
    getLang(code: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<I18nTextareaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<I18nTextareaComponent, "ws-i18n-textarea", never, { "value": { "alias": "value"; "required": false; }; "disaableLangChange": { "alias": "disaableLangChange"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, false, never>;
}

declare class RelativeDateComponent implements OnInit {
    date: Date;
    format: string;
    locale: string;
    tresholdInDays: number;
    output: string;
    isPastDate: boolean;
    isRelative: boolean;
    diff: number;
    daydiff: number;
    calculateDelta: (now: any, date: any) => number;
    constructor();
    ngOnInit(): void;
    ngOnChanges(): void;
    calcRelativeDate(): void;
    isNotValid(): boolean;
    ceil(value: any): number;
    floor(value: any): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<RelativeDateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RelativeDateComponent, "ws-relative-date", never, { "date": { "alias": "date"; "required": false; }; "format": { "alias": "format"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "tresholdInDays": { "alias": "tresholdInDays"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ToastComponent implements OnInit {
    service: WsiToastService;
    constructor(service: WsiToastService);
    ngOnInit(): void;
    isTemplate(toast: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "ws-toast", never, {}, {}, never, never, false, never>;
}

interface ModalItem {
    name: string;
    content: any;
    title: string;
    body: string;
    options?: NgbModalOptions;
    ref?: NgbModalRef;
    lastResult?: any;
    lastReason?: string;
}

declare class WsiModalService {
    modal: NgbModal;
    modals: ModalItem[];
    openModals: ModalItem[];
    onModalUpdate: Subject<ModalItem>;
    constructor(modal: NgbModal);
    private closeModal;
    private listenModal;
    open(item: ModalItem): ModalItem;
    getDefaultOptions(): NgbModalOptions;
    getDismissReason(reason: any): string;
    getModal(name: string): ModalItem;
    updateModal(name: string, item: ModalItem): boolean;
    isModalOpen(item: ModalItem): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsiModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WsiModalService>;
}

declare class ModalsComponent implements OnInit {
    private service;
    okContent: any;
    okModalItem: ModalItem;
    okCancelContent: any;
    okCancelModalItem: ModalItem;
    yesContent: any;
    yesModalItem: ModalItem;
    yesNoContent: any;
    yesNoModalItem: ModalItem;
    constructor(service: WsiModalService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalsComponent, "ws-modals", never, {}, {}, never, never, false, never>;
}

interface AuthEntityRequest {
    id: number;
}
interface AuthEntity extends AuthEntityRequest {
    name: I18nText;
    parent_id?: number;
    children?: Array<AuthEntity>;
    links: Array<Link>;
    path: AuthEntity[];
}

interface Award {
    id: number;
    name: I18nText;
    description: I18nText;
    entity: AuthEntity;
    has_certificate: boolean;
    sort: number;
}
interface AwardRequest {
    name: I18nText;
    description: I18nText;
    entity: AuthEntityRequest;
    has_certificate: boolean;
    sort: number;
}
interface AwardContainer {
    awards: Award[];
}

declare enum RecipientAwardCertificateType {
    'DIGITAL' = "DIGITAL",
    'PRINT' = "PRINT"
}
interface RecipientAwardCertificate {
    id?: number;
    certificate_unique_id: string;
    certificate_dropbox_path: string;
    certificate_type?: RecipientAwardCertificateType;
}

interface PersonAward {
    id: number;
    person_id: number;
    award: Award;
    presented_at: number;
    extra_information: string;
    public_extra_information: string;
    last_updated: string;
    certificates?: RecipientAwardCertificate[];
}

interface MemberAward {
    id: number;
    member_id: number;
    award: Award;
    presented_at: number;
    extra_information: string;
    public_extra_information?: string;
    last_updated: string;
    certificates?: RecipientAwardCertificate[];
}

interface OrganizationAward {
    id: number;
    organization_id: number;
    award: Award;
    presented_at: number;
    extra_information: string;
    public_extra_information?: string;
    last_updated: string;
    certificates?: RecipientAwardCertificate[];
}

declare class AwardService extends WsService<any> {
    private wsi;
    private http;
    private apiAwardsURL;
    constructor(wsi: WorldskillsAngularLibService, http: HttpClient);
    getList(entityId?: number): Observable<AwardContainer>;
    getListUnderWSIEntity(): Observable<AwardContainer>;
    get(awardId: number): Observable<Award>;
    create(awardRequest: AwardRequest, rOpt?: RequestOptions): Observable<Award>;
    create(awardRequest: AwardRequest, params: FetchParams, rOpt?: RequestOptions): Observable<Award>;
    create(awardRequest: AwardRequest, mOpt: MulticastOptions, rOpt?: RequestOptions): Observable<Award>;
    create(awardRequest: AwardRequest, params: FetchParams, mOpt: MulticastOptions, rOpt?: RequestOptions): Observable<Award>;
    update(awardId: number, awardRequest: AwardRequest, rOpt?: RequestOptions): Observable<Award>;
    update(awardId: number, awardRequest: AwardRequest, params: FetchParams, rOpt?: RequestOptions): Observable<Award>;
    update(awardId: number, awardRequest: AwardRequest, mOpt: MulticastOptions, rOpt?: RequestOptions): Observable<Award>;
    update(awardId: number, awardRequest: AwardRequest, params: FetchParams, mOpt: MulticastOptions, rOpt?: RequestOptions): Observable<Award>;
    delete(awardId: number): Observable<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AwardService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AwardService>;
}

interface RecipientAwardRequest {
    id: number;
    award: Award;
    presented_at: number;
    extra_information?: string;
    public_extra_information?: string;
    certificates?: RecipientAwardCertificate[];
}
declare class RecipientAwardFormComponent implements OnInit {
    private awardService;
    recipientAward: PersonAward | MemberAward | OrganizationAward;
    save: EventEmitter<RecipientAwardRequest>;
    cancel: EventEmitter<void>;
    form: NgForm;
    certificateEnabled: boolean;
    certificates: RecipientAwardCertificate[];
    awards: Award[];
    selectedAward: Award;
    constructor(awardService: AwardService);
    ngOnInit(): void;
    get awardGroupByRenderer(): (award: Award) => string;
    loadAwards(): void;
    saveRecipientAward(): void;
    awardSelectionChange($event: SelectChangeEvent): void;
    certificatesEmitReceiver(pac: RecipientAwardCertificate[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecipientAwardFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RecipientAwardFormComponent, "ws-recipient-award-form", never, { "recipientAward": { "alias": "recipientAward"; "required": false; }; "certificateEnabled": { "alias": "certificateEnabled"; "required": false; }; "certificates": { "alias": "certificates"; "required": false; }; }, { "save": "save"; "cancel": "cancel"; }, never, never, false, never>;
}

declare class RecipientAwardListComponent implements OnInit {
    canCreate: boolean;
    canUpdate: boolean;
    canDelete: boolean;
    recipientAwards: PersonAward[] | MemberAward[] | OrganizationAward[];
    certificateEnabled: boolean;
    create: EventEmitter<RecipientAwardRequest>;
    update: EventEmitter<RecipientAwardRequest>;
    delete: EventEmitter<RecipientAwardRequest>;
    addAward: boolean;
    editRecipientAward: PersonAward | MemberAward | OrganizationAward;
    constructor();
    ngOnInit(): void;
    deleteRecipientAward(ra: PersonAward | MemberAward | OrganizationAward): void;
    saveRecipientAward(ra: RecipientAwardRequest): void;
    closeModal(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecipientAwardListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RecipientAwardListComponent, "ws-recipient-award-list", never, { "canCreate": { "alias": "canCreate"; "required": false; }; "canUpdate": { "alias": "canUpdate"; "required": false; }; "canDelete": { "alias": "canDelete"; "required": false; }; "recipientAwards": { "alias": "recipientAwards"; "required": false; }; "certificateEnabled": { "alias": "certificateEnabled"; "required": false; }; }, { "create": "create"; "update": "update"; "delete": "delete"; }, never, never, false, never>;
}

declare class WsSpinnerComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsSpinnerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WsSpinnerComponent, "ws-spinner", never, {}, {}, never, never, false, never>;
}

declare class ModalComponent implements OnChanges {
    private modalService;
    open: boolean;
    options: NgbModalOptions;
    onClose: EventEmitter<void>;
    content: TemplateRef<NgbModalRef>;
    private modalRef;
    constructor(modalService: NgbModal);
    openModal(): void;
    closeModal(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "ws-modal", never, { "open": { "alias": "open"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "onClose": "onClose"; }, never, ["[header]", "[body]", "[footer]"], false, never>;
}

declare class PanelRowActionsComponent implements OnInit {
    private translateService;
    edit: EventEmitter<void>;
    view: EventEmitter<void>;
    delete: EventEmitter<void>;
    editLabel: string;
    viewLabel: string;
    deleteLabel: string;
    editDisabled: boolean;
    viewDisabled: boolean;
    deleteDisabled: boolean;
    constructor(translateService: TranslateService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PanelRowActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PanelRowActionsComponent, "ws-panel-row-actions", never, { "editLabel": { "alias": "editLabel"; "required": false; }; "viewLabel": { "alias": "viewLabel"; "required": false; }; "deleteLabel": { "alias": "deleteLabel"; "required": false; }; "editDisabled": { "alias": "editDisabled"; "required": false; }; "viewDisabled": { "alias": "viewDisabled"; "required": false; }; "deleteDisabled": { "alias": "deleteDisabled"; "required": false; }; }, { "edit": "edit"; "view": "view"; "delete": "delete"; }, never, never, false, never>;
}

declare class RecipientAwardCertificateFormComponent implements OnInit {
    certificatesEmitter: EventEmitter<RecipientAwardCertificate[]>;
    get certificates(): RecipientAwardCertificate[];
    set certificates(certs: RecipientAwardCertificate[]);
    _certificates: RecipientAwardCertificate[];
    certificateTypes: RecipientAwardCertificateType[];
    constructor();
    ngOnInit(): void;
    addCert(): void;
    generateNewUniqueID(cert: RecipientAwardCertificate): void;
    emitValues(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecipientAwardCertificateFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RecipientAwardCertificateFormComponent, "ws-recipient-award-certificate-form", never, { "certificates": { "alias": "certificates"; "required": false; }; }, { "certificatesEmitter": "certificatesEmitter"; }, never, never, false, never>;
}

declare class WSTranslate implements PipeTransform {
    wsiTranslate: WsiTranslateService;
    constructor(wsiTranslate: WsiTranslateService);
    transform(key: string): any;
    flatten(obj: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<WSTranslate, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WSTranslate, "wsTranslate", false>;
}

declare const translateConfig: ModuleWithProviders<TranslateModule>;
declare class WorldskillsAngularLibModule {
    static forRoot(environment: any): ModuleWithProviders<WorldskillsAngularLibModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorldskillsAngularLibModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<WorldskillsAngularLibModule, [typeof WorldskillsAngularLibComponent, typeof AlertComponent, typeof AlertsComponent, typeof BreadcrumbsComponent, typeof DateRangeComponent, typeof DatetimePickerComponent, typeof EntityTreeSelectComponent, typeof FooterComponent, typeof HeaderComponent, typeof LogoComponent, typeof MenuAccessPipe, typeof PollResultComponent, typeof PuppeteerBannerComponent, typeof RelativeDatePipe, typeof SelectDirective, typeof SelectAsyncHeaderComponent, typeof SortPipe, typeof StagingBannerComponent, typeof StandardPollComponent, typeof VoteControlComponent, typeof WordmarkComponent, typeof WeightedPollComponent, typeof MultiselectPollComponent, typeof UserRoleDirective, typeof AuthHeaderComponent, typeof AuthFooterComponent, typeof ResourceThumbnailComponent, typeof FileSizePipe, typeof ResourceThumbnailContainerComponent, typeof I18nTextComponent, typeof I18nTextboxComponent, typeof I18nTextareaComponent, typeof RelativeDateComponent, typeof ToastComponent, typeof ModalsComponent, typeof RecipientAwardListComponent, typeof RecipientAwardFormComponent, typeof WsSpinnerComponent, typeof ModalComponent, typeof PanelRowActionsComponent, typeof RecipientAwardCertificateFormComponent, typeof WSTranslate], [typeof i43.CommonModule, typeof i44.FormsModule, typeof i45.RouterModule, typeof i46.NgbModule, typeof i47.NgSelectModule, typeof i48.TranslateModule], [typeof WorldskillsAngularLibComponent, typeof AlertComponent, typeof AlertsComponent, typeof BreadcrumbsComponent, typeof DateRangeComponent, typeof DatetimePickerComponent, typeof EntityTreeSelectComponent, typeof FooterComponent, typeof HeaderComponent, typeof AuthHeaderComponent, typeof AuthFooterComponent, typeof LogoComponent, typeof MenuAccessPipe, typeof PollResultComponent, typeof PuppeteerBannerComponent, typeof RelativeDatePipe, typeof SelectDirective, typeof SelectAsyncHeaderComponent, typeof SortPipe, typeof StagingBannerComponent, typeof StandardPollComponent, typeof MultiselectPollComponent, typeof VoteControlComponent, typeof WordmarkComponent, typeof WeightedPollComponent, typeof UserRoleDirective, typeof ResourceThumbnailComponent, typeof ResourceThumbnailContainerComponent, typeof I18nTextComponent, typeof I18nTextboxComponent, typeof I18nTextareaComponent, typeof RelativeDateComponent, typeof ToastComponent, typeof ModalsComponent, typeof RecipientAwardListComponent, typeof RecipientAwardFormComponent, typeof WsSpinnerComponent, typeof ModalComponent, typeof PanelRowActionsComponent, typeof RecipientAwardCertificateFormComponent, typeof i48.TranslateModule, typeof WSTranslate]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<WorldskillsAngularLibModule>;
}

interface APIError {
    code: string;
    user_msg: string;
    dev_msg: string;
    errors?: string[];
}

declare class FilterPipe implements PipeTransform {
    transform<T>(items: T[], search: string | null, keys: Array<keyof T>): T[];
    transform<T>(items: T[], predicate: (item: T, index: number, items: T[]) => boolean): T[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterPipe, "wsFilter", true>;
}

declare class DefaultRelativeDateProccessor implements RelativeDateProcessor {
    /**
     * @deprecated The method should not be used. use tthe relative-date component instead
     */
    handlePastDate(date: Date): string;
    /**
     * @deprecated The method should not be used. use tthe relative-date component instead
     */
    handleFutureDate(date: Date): string;
}

declare enum WSIDateFormat {
    default = "d MMMM yyyy",
    defaultWithDay = "EEEE, d MMMM yyyy",
    numeric = "dd.MM.yy"
}

declare enum WSITimeFormat {
    TwentyFourHour = "HH:mm",
    TwentyFourHourGMT = "HH:mm (O)",
    TwelveHour = "hh.mm aa.",
    TwelveHourGMT = "hh.mm aa. (O)"
}

/**
 * Utility class for array operations with type safety and performance optimizations
 */
declare class ArrayUtil {
    /**
     * Pushes all items from the second array into the first array.
     * This method mutates the first array and triggers UI updates (unlike concat).
     * @param first - The target array to push items into
     * @param second - The source array to push items from
     * @returns The modified first array
     */
    static pushMany<T>(first: T[], second: T[]): T[];
    /**
     * Removes duplicate primitive values from an array using Set for O(n) performance.
     * @param arr - The array to deduplicate
     * @returns A new array with unique values only
     */
    static dedupePrimitive<T>(arr: T[]): T[];
    /**
     * Removes duplicate objects from an array based on a key selector function.
     * @param arr - The array to deduplicate
     * @param keySelector - Function to extract the key for comparison
     * @returns A new array with unique objects based on the key
     */
    static dedupeByKey<T, K>(arr: T[], keySelector: (item: T) => K): T[];
    /**
     * Checks if the given object is an array.
     * @param obj - The object to check
     * @returns True if the object is an array, false otherwise
     */
    static isArray(obj: unknown): obj is unknown[];
    /**
     * Flattens an array of objects with optional children properties.
     * Supports recursive flattening of nested structures.
     * @param entities - Array of objects that may contain children
     * @param recursive - Whether to recursively flatten nested children (default: false)
     * @returns Flattened array containing all entities and their children
     */
    static flatten<T extends {
        children?: T[];
    }>(entities: T[], recursive?: boolean): T[];
    /**
     * Splits an array into chunks of specified size.
     * @param arr - The array to chunk
     * @param size - The size of each chunk
     * @returns Array of chunks
     */
    static chunk<T>(arr: T[], size: number): T[][];
    /**
     * Groups array elements by a key selector function.
     * @param arr - The array to group
     * @param keySelector - Function to extract the grouping key
     * @returns Object with keys as group identifiers and values as arrays of grouped items
     */
    static groupBy<T, K extends string | number | symbol>(arr: T[], keySelector: (item: T) => K): Record<K, T[]>;
    /**
     * Finds the intersection of two arrays (elements present in both).
     * @param arr1 - First array
     * @param arr2 - Second array
     * @returns Array containing elements present in both arrays
     */
    static intersection<T>(arr1: T[], arr2: T[]): T[];
    /**
     * Finds the difference between two arrays (elements in first but not in second).
     * @param arr1 - First array
     * @param arr2 - Second array
     * @returns Array containing elements in arr1 but not in arr2
     */
    static difference<T>(arr1: T[], arr2: T[]): T[];
    /**
     * Checks if an array is empty or null/undefined.
     * @param arr - The array to check
     * @returns True if array is empty, null, or undefined
     */
    static isEmpty(arr: unknown[] | null | undefined): boolean;
    /**
     * Safely gets an element at the specified index, returning undefined for out-of-bounds access.
     * @param arr - The array to access
     * @param index - The index to access
     * @returns The element at the index or undefined if out of bounds
     */
    static safeGet<T>(arr: T[], index: number): T | undefined;
    /**
     * Moves an element from one index to another in an array.
     * @param arr - The array to modify
     * @param fromIndex - The source index
     * @param toIndex - The destination index
     * @returns A new array with the element moved
     */
    static move<T>(arr: T[], fromIndex: number, toIndex: number): T[];
}

declare class DateUtil {
    static toJavaDateString(date: Date, locale: string): string;
}

declare class ErrorUtil {
    static getErrorMsg(error: any, defaultErrorMessage: string): string;
    static hasApiError(error: any): boolean;
    static arrayBufferToJSON(error: HttpErrorResponse): APIError;
    static captureAPIError(type: string, name: string, action: string, error: any, msg: string): void;
}

declare class GenericUtil {
    static isNullOrUndefined(obj: any): boolean;
    static getValueOrDefault<T>(value: any, defaultValue: T): T;
}

declare class HttpUtil {
    static objectToParams(obj: {}): HttpParams;
    static isNotLoggedIn(err: HttpErrorResponse, notLoggedInCode: string): boolean;
    static hasStaleToken(err: HttpErrorResponse, authorizationMissingCode?: string): boolean;
}

declare class HtmlUtil {
    static txt(html: string): string;
}

declare class I18nUtil {
    static instanceOfI18nModel(object: any): object is I18nText;
    static setObjectI18n(object: any, langCode: string): any;
}

declare class LangUtil {
    static getDefaultLanguages(): Language[];
    static getDefaultLanguage(): Language;
}

declare class ObjectUtil {
    static stripUndefined(obj: any, deep?: boolean): any;
    static stripNullOrUndefined(obj: any, deep?: boolean): any;
}

declare class RouterUtil {
    static lastNavigationEventWithOrInitialObservable(router: Router, name?: any): Observable<any>;
    static getResolvedUrl(route: ActivatedRouteSnapshot): string;
    static getConfiguredUrl(route: ActivatedRouteSnapshot): string;
}

declare class RxjsUtil {
    static loaderSubscriber(...subscribables: Array<Subscribable<boolean> | WsService<any, any>>): Observable<boolean>;
}

declare class UserRoleUtil {
    static userHasRoles(user: User, appId: number, ...roles: Array<string>): boolean;
    static userHasRolesOfEntity(user: User, appId: number, entityId: number, ...roles: Array<string>): boolean;
    static userHasAllRoles(user: User, appId: number, ...roles: Array<string>): boolean;
    static userHasAllRolesOfEntity(user: User, appId: number, entityId: number, ...roles: Array<string>): boolean;
    static userHasRolesOfAnyApp(user: User, ...roles: Array<string>): boolean;
    static userHasRolesOfEntityOfAnyApp(user: User, entityId: number, ...roles: Array<string>): boolean;
    static userHasAllRolesOfAnyApp(user: User, ...roles: Array<string>): boolean;
    static userHasAllRolesOfEntityOfAnyApp(user: User, entityId: number, ...roles: Array<string>): boolean;
}

/**
 * Utility class for converting numbers to ordinal format (1st, 2nd, 3rd, 4th, etc.)
 * Supports multiple locales and formatting options
 */
declare class OrdinalUtil {
    /**
     * Converts a number to its ordinal representation in English (e.g., 1 → "1st", 2 → "2nd")
     * @param num - The number to convert to ordinal format
     * @param options - Optional formatting options
     * @returns The ordinal string representation
     * @throws Error if input is not a valid number
     *
     * @example
     * OrdinalUtil.toOrdinal(1) // "1st"
     * OrdinalUtil.toOrdinal(22) // "22nd"
     * OrdinalUtil.toOrdinal(103) // "103rd"
     */
    static toOrdinal(num: number, options?: OrdinalOptions): string;
    /**
     * Legacy method name for backward compatibility
     * @deprecated Use toOrdinal() instead
     */
    static applyDefault(i: number): string;
    /**
     * Gets just the ordinal suffix for a number (st, nd, rd, th)
     * @param num - The number to get the suffix for
     * @param locale - The locale for the suffix (default: 'en')
     * @returns The ordinal suffix
     *
     * @example
     * OrdinalUtil.getOrdinalSuffix(1) // "st"
     * OrdinalUtil.getOrdinalSuffix(22) // "nd"
     */
    static getOrdinalSuffix(num: number, locale?: string): string;
    /**
     * Converts an array of numbers to their ordinal representations
     * @param numbers - Array of numbers to convert
     * @param options - Optional formatting options
     * @returns Array of ordinal strings
     */
    static toOrdinalArray(numbers: number[], options?: OrdinalOptions): string[];
    /**
     * Checks if a string is a valid ordinal number
     * @param str - The string to check
     * @param locale - The locale to check against (default: 'en')
     * @returns True if the string is a valid ordinal
     *
     * @example
     * OrdinalUtil.isOrdinal("1st") // true
     * OrdinalUtil.isOrdinal("22nd") // true
     * OrdinalUtil.isOrdinal("invalid") // false
     */
    static isOrdinal(str: string, locale?: string): boolean;
    /**
     * Parses an ordinal string back to its numeric value
     * @param ordinalStr - The ordinal string to parse (e.g., "1st", "22nd")
     * @param locale - The locale of the ordinal string (default: 'en')
     * @returns The numeric value
     * @throws Error if the string is not a valid ordinal
     *
     * @example
     * OrdinalUtil.parseOrdinal("1st") // 1
     * OrdinalUtil.parseOrdinal("22nd") // 22
     */
    static parseOrdinal(ordinalStr: string, locale?: string): number;
    /**
     * Private method to get English ordinal representation
     */
    private static getEnglishOrdinal;
    /**
     * Private method to get English ordinal suffix following standard rules:
     * - Numbers ending in 1 (except 11) get "st"
     * - Numbers ending in 2 (except 12) get "nd"
     * - Numbers ending in 3 (except 13) get "rd"
     * - All others get "th"
     */
    private static getEnglishSuffix;
    /**
     * Gets a range of ordinal numbers
     * @param start - Starting number
     * @param end - Ending number (inclusive)
     * @param options - Optional formatting options
     * @returns Array of ordinal strings
     *
     * @example
     * OrdinalUtil.getOrdinalRange(1, 5) // ["1st", "2nd", "3rd", "4th", "5th"]
     */
    static getOrdinalRange(start: number, end: number, options?: OrdinalOptions): string[];
}
/**
 * Options for ordinal formatting
 */
interface OrdinalOptions {
    /** The locale for formatting (default: 'en') */
    locale?: string;
    /** Whether to use absolute value for negative numbers (default: false) */
    absoluteValue?: boolean;
    /** Whether to include the number in the output (default: true) */
    includeNumber?: boolean;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
declare const ISO8601_DATE_REGEX: RegExp;
/**
 * @ngModule CommonModule
 * @description
 *
 * Formats a date according to locale rules.
 *
 * @param value The date to format, as a Date, or a number (milliseconds since UTC epoch)
 * or an [ISO date-time string](https://www.w3.org/TR/NOTE-datetime).
 * @param format The date-time components to include. See `DatePipe` for details.
 * @param locale A locale code for the locale format rules to use.
 * @param timezone The time zone. A time zone offset from GMT (such as `'+0430'`),
 * or a standard UTC/GMT or continental US time zone abbreviation.
 * If not specified, uses host system settings.
 *
 * @returns The formatted date string.
 *
 * @see `DatePipe`
 * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n)
 *
 * @publicApi
 */
declare function formatDate(value: string | number | Date, format: string, locale: string, timezone?: string): string;
/**
 * Converts a value to date.
 *
 * Supported input formats:
 * - `Date`
 * - number: timestamp
 * - string: numeric (e.g. "1234"), ISO and date strings in a format supported by
 *   [Date.parse()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse).
 *   Note: ISO strings without time return a date without timeoffset.
 *
 * Throws if unable to convert to a date.
 */
declare function toDate(value: string | number | Date): Date;
/**
 * Converts a date in ISO8601 to a Date.
 * Used instead of `Date.parse` because of browser discrepancies.
 */
declare function isoStringToDate(match: RegExpMatchArray): Date;
declare function isDate(value: any): value is Date;

declare const RETURN_URL_KEY = "returnUrl";
declare const USER_CURRENT_KEY = "user.current";

interface RedirectOptions {
    url?: any;
    onlyIfExact?: ActivatedRoute | ActivatedRouteSnapshot;
    showChildRoles?: boolean;
}
declare class RedirectHandler {
    protected ngAuthService: NgAuthService;
    protected router: Router;
    constructor(ngAuthService: NgAuthService, router: Router);
    redirectOrReturn(redirectOptions: RedirectOptions): Observable<void>;
    hasReturnUrl(): boolean;
    handleReturnUrl(showChildRoles?: boolean): Observable<void>;
    redirectUserToUrl(user: User, returnUrl: string, skipLocationChange?: boolean): void;
    redirectUserToRoute(user: User, route: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RedirectHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RedirectHandler>;
}

declare class RedirectEventHandler {
    protected ngAuthService: NgAuthService;
    protected router: Router;
    constructor(ngAuthService: NgAuthService, router: Router);
    getReturnUrl(): string;
    getUser(showRoles: boolean): Observable<User>;
    redirectUserToUrl(returnUrl: string, skipLocationChange?: boolean): void;
    listen(): Observable<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RedirectEventHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RedirectEventHandler>;
}

interface AuthGuardAccess {
    appCode: number;
    name: string;
}

declare class GuardService {
    private ngAuthService;
    private wsi;
    private router;
    private config;
    constructor(ngAuthService: NgAuthService, wsi: WorldskillsAngularLibService, router: Router);
    canActivate(next: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
    protected getCurrentUser(): User;
    protected login(state: RouterStateSnapshot): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuardService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GuardService>;
}

declare const DEFAULT_LABELS: {
    clearAllText: string;
    loadingText: string;
    notFoundText: string;
    typeToSearchText: string;
    placeholder: string;
};

declare class WsHttpEncoder implements HttpParameterCodec {
    encodeKey(key: string): string;
    encodeValue(value: string): string;
    decodeKey(key: string): string;
    decodeValue(value: string): string;
}

declare const MISSING_LANGUAGE_MESSAGE: (email: string) => string;

declare class WsHttpInterceptor implements HttpInterceptor {
    private wsi;
    private oAuthService;
    private config;
    constructor(wsi: WorldskillsAngularLibService, oAuthService: OAuthService);
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsHttpInterceptor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WsHttpInterceptor>;
}

declare class DefaultOptionHandler implements OptionHandler {
    onOptionSelect(pollType: string, currentSelection: any[], newSelectedValue: any, selectionIndex: number): any[];
}

interface Page<T> {
    offset: number;
    limit: number;
    total: number;
    items: T[];
}

interface PollList {
    id: number;
    title: I18nText;
    entity: WsEntityModel;
    createdBy: CreatedBy;
    deleted: boolean;
    created: Date;
    slug: string;
    entityPath: EntityPath;
}

declare class PollListService {
    protected wsi: WorldskillsAngularLibService;
    protected http: HttpClient;
    endpoint: string;
    constructor(wsi: WorldskillsAngularLibService, http: HttpClient);
    list(params: any): Observable<Page<PollList>>;
    get(id: number): Observable<PollList>;
    getBySlug(slug: string): Observable<PollList>;
    create(model: PollList): Observable<PollList>;
    update(id: number, model: PollList): Observable<PollList>;
    delete(id: number): Observable<any>;
    undelete(id: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PollListService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PollListService>;
}

declare class PollService {
    protected wsi: WorldskillsAngularLibService;
    protected http: HttpClient;
    endpoint: string;
    constructor(wsi: WorldskillsAngularLibService, http: HttpClient);
    list(params: any): Observable<Page<Poll>>;
    select(params: any): Observable<Poll[]>;
    get(id: number): Observable<Poll>;
    getAbstains(id: number): Observable<Abstain[]>;
    getResults(id: number): Observable<Result[]>;
    getTrackRecords(id: number): Observable<Track[]>;
    hasVoted(id: number): Observable<Vote>;
    create(model: Poll): Observable<Poll>;
    update(id: number, model: Poll): Observable<Poll>;
    open(id: number, start: Date, expiry: Date): Observable<any>;
    close(id: number): Observable<any>;
    delete(id: number): Observable<any>;
    undelete(id: number): Observable<any>;
    reset(id: number, start: Date, expiry: Date): Observable<any>;
    extend(id: number, expiry: Date): Observable<any>;
    addVote(pollId: number, votes: VoteEntry): Observable<Option>;
    addAbstain(pollId: number): Observable<any>;
    unvote(pollId: number): Observable<any>;
    unAbstain(pollId: number): Observable<any>;
    copy(pollId: number): Observable<Poll>;
    export(id: number): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<PollService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PollService>;
}

export { AlertComponent, AlertService, AlertType, AlertsComponent, ArrayUtil, AuthFooterComponent, AuthHeaderComponent, AuthService, AwardService, BreadcrumbsComponent, BreadcrumbsService, DEFAULT_LABELS, DateRangeComponent, DateUtil, Datetime, DatetimePickerComponent, DefaultOptionHandler, DefaultRelativeDateProccessor, EntityTreeSelectComponent, EntityTreeService, EntityTreeView, ErrorUtil, FULL, FilterPipe, FooterComponent, GenericUtil, GuardService, HeaderComponent, HtmlUtil, HttpUtil, I18nTextComponent, I18nTextareaComponent, I18nTextboxComponent, I18nUtil, ISO8601_DATE_REGEX, LOADER_ONLY, LangUtil, LogoComponent, MISSING_LANGUAGE_MESSAGE, MenuAccessPipe, ModalComponent, ModalsComponent, MultiselectPollComponent, NO_SUBJECT, NgAuthService, ObjectUtil, OrdinalUtil, PanelRowActionsComponent, PollListService, PollResultComponent, PollService, PuppeteerBannerComponent, RETURN_URL_KEY, RecipientAwardCertificateFormComponent, RecipientAwardFormComponent, RecipientAwardListComponent, RedirectEventHandler, RedirectHandler, RelativeDateComponent, RelativeDatePipe, ResourceService, ResourceThumbnailComponent, ResourceThumbnailContainerComponent, ResourceUpload, RouterUtil, RxjsUtil, SelectAsyncHeaderComponent, SelectDirective, SortPipe, StagingBannerComponent, StandardPollComponent, ToastComponent, USER_CURRENT_KEY, UploadService, UserRoleDirective, UserRoleUtil, VoteControlComponent, WSIDateFormat, WSITimeFormat, WSTranslate, WeightedPollComponent, WordmarkComponent, WorldskillsAngularLibComponent, WorldskillsAngularLibModule, WorldskillsAngularLibService, WsComponent, WsHttpEncoder, WsHttpInterceptor, WsService, WsSpinnerComponent, WsiModalService, WsiToastService, WsiTranslateService, formatDate, isDate, isFetchParams, isMulticastOptions, isRequestOptions, isoStringToDate, toDate, translateConfig };
export type { APIError, Abstain, Alert, AppConfig, AuthEntity, AuthEntityRequest, AuthGuardAccess, Award, AwardContainer, AwardRequest, Breadcrumb, CreatedBy, DateRange, EntityFetchParams, EntityPath, EntityPathItem, EntityTreeSelectControls, EntityTreeSelectLabels, EntryReader, FetchParams, GetUsersParams, HttpConfig, I18nText, Language, Link, MemberAward, MenuItem, ModalItem, MulticastOptions, NgbDatetimeStruct, Option, OptionHandler, OrdinalOptions, OrganizationAward, Page, Pair, Person, PersonAward, Poll, PollList, RecipientAwardRequest, RedirectOptions, RelativeDateProcessor, RequestOptions, Resource, ResourceContainer, ResourceMetadata, ResourceMetadataInfo, ResourceSearch, ResourceThumbnail, ResourceType, ResourceTypeMetadata, Result, Role, RoleApplicationModel, SelectAsyncSearchObserverResolver, SelectAsyncSearchSettings, SelectAsyncSearchSettingsAdvanced, SelectChangeEvent, ServiceConfig, StorageType, Track, Translation, TranslationCreate, TreeEntity, User, UserList, Version, VersionCreate, Vote, VoteEntry, WsEntityModel, WsServiceRequestP1, WsServiceRequestP2, WsServiceRequestP3 };