@the-liberators/ngx-scrumteamsurvey-tools 2.3.78 → 2.3.80

package/index.d.ts

@@ -1,5 +1,3398 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@the-liberators/ngx-scrumteamsurvey-tools" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { EventEmitter, InjectionToken, OnInit, OnDestroy, PipeTransform, ElementRef, SimpleChanges, ErrorHandler, NgZone, DoCheck } from '@angular/core';
+import * as i3$1 from '@angular/forms';
+import { FormGroup, FormBuilder, FormGroupDirective, FormControl, ControlValueAccessor, UntypedFormGroup, UntypedFormControl, UntypedFormBuilder, FormArray, ValidatorFn } from '@angular/forms';
+import * as i3$2 from '@angular/material/snack-bar';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import * as i3 from '@angular/router';
+import { ActivatedRoute, Router, CanActivate, ActivatedRouteSnapshot, UrlTree } from '@angular/router';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject, Subscription, Subject } from 'rxjs';
+import * as i9 from 'ngx-webstorage-service';
+import { StorageService } from 'ngx-webstorage-service';
+import { HttpClient, HttpBackend, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import * as i2$2 from '@angular/material/dialog';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import * as i12 from '@angular/material/tooltip';
+import * as i54 from '@angular/material/core';
+import * as i14 from '@angular/material/menu';
+import * as i15 from '@angular/material/paginator';
+import { PageEvent } from '@angular/material/paginator';
+import * as i2 from '@angular/material/select';
+import * as i2$1 from '@angular/common';
+import { Location, DatePipe } from '@angular/common';
+import * as i6 from '@angular/material/input';
+import * as i22 from '@angular/material/datepicker';
+import * as i2$3 from '@angular/material/autocomplete';
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import * as i6$1 from '@angular/material/chips';
+import { MatChipInputEvent } from '@angular/material/chips';
+import * as i4 from '@angular/material/form-field';
+import * as i5 from '@angular/cdk/clipboard';
+import { Clipboard } from '@angular/cdk/clipboard';
+import * as i7 from '@angular/material/checkbox';
+import { AuthService } from '@auth0/auth0-angular';
+import { ComponentType } from '@angular/cdk/portal';
+import * as i50 from '@swimlane/ngx-charts';
+import { LegendPosition } from '@swimlane/ngx-charts';
+import * as i58 from '@angular/material/slide-toggle';
+import * as i61 from '@angular/material/progress-spinner';
+import * as i64 from '@ncstate/sat-popover';
+
+declare abstract class ComponentBase {
+    protected snackBar: MatSnackBar;
+    constructor(snackBar: MatSnackBar);
+    protected showSuccess(message: string): void;
+    protected showMessage(message: string): void;
+    protected showError(message: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentBase, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentBase>;
+}
+
+declare class PaginatedResponse<Dto> {
+    constructor();
+    items: Dto[];
+    totalItems: number;
+    page: number;
+    itemsPerPage: number;
+}
+
+declare class PaginatorComponent extends ComponentBase {
+    protected snackBar: MatSnackBar;
+    items: PaginatedResponse<any>;
+    readonly page: EventEmitter<PaginatorPageEvent>;
+    pageIndex: number;
+    pageSize: number;
+    pageCount: number;
+    constructor(snackBar: MatSnackBar);
+    ngOnInit(): void;
+    next(): void;
+    back(): void;
+    changePageSize(): void;
+    private emitPageEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginatorComponent, "paginator", never, { "items": { "alias": "items"; "required": false; }; }, { "page": "page"; }, never, never, false, never>;
+}
+declare class PaginatorPageEvent {
+    pageIndex: number;
+    pageSize: number;
+}
+
+declare class ContextItemDto {
+    constructor(key: string, value: string);
+    key: string;
+    value: string;
+}
+
+declare class BrandingSettingsDto {
+    accentColor: string;
+    themeColor: string;
+    backgroundColor: string;
+    neutralColor: string;
+    logoUrl: string;
+    publicKey: string;
+    platformName: string;
+    platformLearnMoreUrl: string;
+    name: string;
+    companyUrl: string;
+    isDefault: boolean;
+    hasBroker: boolean;
+    channelKey: string;
+    channelName: string;
+    channelSubscribeUrl: string;
+    channelCompanyUrl: string;
+    channelPrivacyPolicyUrl: string;
+    channelTermsOfUseUrl: string;
+    channelAccentColor: string;
+    channelThemeColor: string;
+    channelPlatformName: string;
+    contentBranding: ContentBrandingDto;
+    brokerUrl: string;
+    teamReportUrl: string;
+    teamsDashboardUrl: string;
+}
+declare class ContentBrandingDto {
+    settings: Record<string, string>[];
+    signature: string;
+}
+
+declare class ClientInfoDto {
+    name: string;
+    subscriptionKey: string;
+    activationCode: string;
+    publicKey: string;
+    aboutToExpire: boolean;
+    metered: boolean;
+    expires: Date;
+    legal: LegalDto;
+    teamsUsed: number;
+    teamLimit: number;
+    usersUsed: number;
+    userLimit: number;
+}
+declare class LegalDto {
+    accepted: Date;
+    documents: LegalDocumentDto[];
+}
+declare class LegalDocumentDto {
+    name: string;
+    url: string;
+}
+
+declare class FeaturesDto {
+    allowMFA: boolean;
+    allowSSO: boolean;
+    allowAPI: boolean;
+    allowCustomDomain: boolean;
+    allowBrandedPdfs: boolean;
+    allowScaleSelection: boolean;
+}
+
+declare class ActionDto {
+    constructor();
+    publicKey: string;
+    description: string;
+    url: string;
+    team: ActionTeamDto;
+    created: Date;
+    due: Date;
+    isDue: boolean;
+    state: InterventionStateEnum;
+    type: InterventionTypeEnum;
+    owner: InterventionOwnerEnum;
+    expectedImpactOn: string[];
+    expectedImpactOnLabels: string[];
+    deleted: boolean;
+    quickTipPublicKey: string;
+    ageInDays: number;
+}
+declare class ActionTeamDto {
+    publicKey: string;
+    name: string;
+    colorString: string;
+}
+declare enum InterventionStateEnum {
+    open = "Open",
+    completed = "Completed",
+    impeded = "Impeded",
+    obsolete = "Obsolete",
+    due = "Due"
+}
+declare enum InterventionSortEnum {
+    due = "Due",
+    owner = "Owner",
+    type = "Type",
+    created = "Created",
+    age = "Age"
+}
+declare enum InterventionTypeEnum {
+    conversation = "Conversation",
+    involveOthers = "InvolveOthers",
+    runExperiment = "RunExperiment",
+    research = "Research",
+    workshop = "Workshop",
+    other = "Other"
+}
+declare enum InterventionOwnerEnum {
+    entireTeam = "EntireTeam",
+    management = "Management",
+    productPerson = "ProductPerson",
+    teamCoach = "TeamCoach",
+    teamMember = "TeamMember",
+    stakeholder = "Stakeholder",
+    other = "Other"
+}
+
+declare class ModelStructureDto {
+    definition: ModelDefinitionDto;
+    models: ModelSummaryDto[];
+}
+declare class ModelDefinitionDto {
+    constructor();
+    name: string;
+    publicKey: string;
+    description: string;
+    demoUrls: ModelDemoUrlDto[];
+    attribution: string;
+    questionnaireTypes: QuestionnaireTypeDto[];
+    factors: FactorStructureDto[];
+    explainerVideoUrl: string;
+}
+declare class ModelDemoUrlDto {
+    type: string;
+    url: string;
+}
+declare class DefinitionDto {
+    term: string;
+    definition: string;
+}
+declare class EffectDto {
+    to: string;
+    standardizedBeta: number;
+    standardError: number;
+}
+declare class FactorStructureDto {
+    constructor();
+    publicKey: string;
+    parentKey: string;
+    name: string;
+    color: string;
+    description: string;
+    questionCount: number;
+    ownQuestionCount: number;
+    explainerVideoUrl: string;
+    effects: EffectDto[];
+    segments: FactorStructureSegmentDto[];
+    constraints: FactorStructureConstraintDto;
+    lower: FactorStructureDto[];
+    attribution: string;
+    antecedents: FactorStructureDto[];
+    recommended: boolean;
+}
+declare class FactorStructureSegmentDto {
+    questionCount: number;
+    ownQuestionCount: number;
+    segment: SegmentEnum;
+    durationInSeconds: number;
+    questions: string[];
+}
+declare class ModelSummaryDto {
+    publicKey: string;
+    name: string;
+    description: string;
+    isInBeta: boolean;
+}
+declare class FactorStructureConstraintDto {
+    constructor();
+    forSegments: string[];
+    teamTraitKeys: string[];
+}
+declare class QuestionnaireTypeDto {
+    constructor(publicKey: any, name: any);
+    publicKey: string;
+    name: string;
+    description: string;
+    scaleKeys: string[];
+}
+declare class TeamFlagMatchDto {
+    isSoftwareTeam: boolean | null;
+    isAgileTeam: boolean | null;
+    isIterationTeam: boolean | null;
+}
+declare enum SegmentEnum {
+    TeamMember = "TeamMember",
+    Stakeholder = "Stakeholder",
+    Management = "Supporter"
+}
+
+declare class DateRangeDto {
+    from: Date;
+    to: Date;
+}
+
+declare class ParticipationRateDto {
+    percentage: number;
+    upperConfidence: number;
+    lowerConfidence: number;
+    points: PointDto[];
+    qualification: QualificationEnum;
+}
+
+declare class FactorScoreDto {
+    name: string;
+    key: string;
+    score: number;
+    upperConfidence: number;
+    lowerConfidence: number;
+    delta: number;
+    deltaAvailable: boolean;
+    impact: number;
+    benchmark: number;
+    benchmarkUpperQuartile: number;
+    benchmarkLowerQuartile: number;
+    points: PointDto[];
+    sampleSize: number;
+    qualification: string;
+    interventionSummary: InterventionSummaryDto;
+    recommendation: FactorRecommendationDto;
+    effects: FactorEffectDto[];
+    notes: string[];
+    anonymized: boolean;
+    lastMeasured: Date;
+}
+declare class FactorRecommendationDto {
+    available: boolean;
+    research: string;
+    improve: string;
+    summary: string;
+    resources: FeedbackResourceDto[];
+    quickTips: FeedbackQuickTipDto[];
+}
+declare class ProcessingDataDto {
+    qualifiedBy: QualifiedByEnum;
+    notes: string[];
+    anonymized: boolean;
+    cacheRenewsAt: Date;
+}
+declare class PointDto {
+    publicKey: string;
+    type: PointTypeEnum;
+    name: string;
+    normalizedScore: number;
+    occurances: number;
+    lowerConfidence: number;
+    upperConfidence: number;
+}
+declare class FactorScoreCollectionDto {
+    filters: FactorScoreCollectionFiltersDto;
+    dateRange: DateRangeDto;
+    factorScores: FactorScoreDto[];
+    interventionSummary: InterventionSummaryDto;
+    delta: FactorScoreCollectionDeltaDto;
+    benchmark: FactorScoreCollectionBenchmarkDto;
+    composition: FactorScoreCollectionCompositionDto;
+    processingData: ProcessingDataDto;
+    modelStructure: ModelStructureDto;
+    participationRate: ParticipationRateDto;
+}
+declare class FactorScoreCollectionFiltersDto {
+    tags: string[];
+}
+declare class FactorScoreCollectionDeltaDto {
+    dateRange: DateRangeDto;
+    available: boolean;
+    teams: FactorScoreCompositionPointsDto;
+    type: DeltaPeriodEnum;
+}
+declare class FactorScoreCollectionBenchmarkDto {
+    type: BenchmarkTypeEnum;
+    name: string;
+    size: number;
+    available: BenchmarkOptionDto[];
+}
+declare class BenchmarkOptionDto {
+    key: string;
+    name: string;
+}
+declare class FactorScoreCompositionPointsDto {
+    count: number;
+    points: FactorScoreCompositionPointDto[];
+    type: PointTypeEnum;
+}
+declare class FactorScoreCompositionPointDto {
+    name: string;
+    publicKey: string;
+}
+declare class FactorScoreCollectionCompositionDto {
+    population: number;
+    segments: FactorScoreCollectionCompositionSegmentDto[];
+    points: FactorScoreCompositionPointsDto;
+}
+declare class FactorScoreCollectionCompositionSegmentDto {
+    name: string;
+    occurances: number;
+}
+declare class InterventionSummaryDto {
+    open: number;
+    completed: number;
+    impeded: number;
+    obsolete: number;
+    total: number;
+    due: number;
+}
+declare class FeedbackResourceDto {
+    publicKey: string;
+    title: string;
+}
+declare class FeedbackQuickTipDto {
+    publicKey: string;
+    description: string;
+    type: InterventionTypeEnum;
+}
+declare class FactorEffectDto {
+    key: string;
+    name: string;
+    effect: number;
+    type: EffectTypeEnum;
+}
+declare enum BenchmarkTypeEnum {
+    NoBenchmark = "NoBenchmark",
+    MostRecentSamples = "MostRecentSamples",
+    TopSamplesByExperience = "TopSamplesByExperience",
+    TopSamplesByEffectiveness = "TopSamplesByEffectiveness",
+    topSamplesByValue = "TopSamplesByValue",
+    TopSamplesByResponsiveness = "TopSamplesByResponsiveness",
+    TeamsFromSameClient = "TeamsFromSameclient",
+    TeamsFromSameBroker = "TeamsFromSameBroker",
+    TeamsInSectorFinance = "TeamsInSectorFinance",
+    TeamsInSectorIT = "TeamsInSectorIT",
+    TeamsFrameworkSAFe = "TeamsFrameworkSAFe",
+    TeamsFrameworkScrum = "TeamsFrameworkScrum"
+}
+declare enum ContextTypes {
+    Unset = "Unset",
+    Participant = "Participant",
+    Snapshot = "Snapshot"
+}
+declare enum QualifiedByEnum {
+    benchmark = "Benchmark",
+    delta = "Delta",
+    none = "None"
+}
+declare enum EffectTypeEnum {
+    predicts = "Predicts",
+    isPartOf = "IsPartOf",
+    isPredictedby = "IsPredictedBy"
+}
+declare enum PointTypeEnum {
+    unspecified = "Unspecified",
+    team = "Team",
+    segment = "Segment",
+    individual = "Individual",
+    client = "Client"
+}
+declare enum QualificationEnum {
+    positive = "Positive",
+    neutral = "Neutral",
+    negative = "Negative"
+}
+declare enum DeltaPeriodEnum {
+    previousMonth = "PreviousMonth",
+    previousQuarter = "PreviousQuarter",
+    previousYear = "PreviousYear",
+    previousSnapshot = "PreviousSnapshot",
+    previousHalfYear = "PreviousHalfYear",
+    none = "None"
+}
+declare enum IncludeActionsModeEnum {
+    none = "None",
+    includeAll = "IncludeAll",
+    includeRelevant = "IncludeRelevant"
+}
+
+declare class PagingOptions {
+    page: number;
+    pageSize: number;
+}
+
+declare class UserSettingsDto {
+    constructor();
+    global: UserGlobalSettingsDto;
+    user: UserSpecificSettingsDto;
+}
+declare class UserGlobalSettingsDto {
+    constructor();
+    benchmark: BenchmarkTypeEnum;
+    deltaPeriod: DeltaPeriodEnum;
+    qualifyBy: QualifiedByEnum;
+    overviewFactors: string[];
+    stacking: boolean;
+}
+declare class UserSpecificSettingsDto {
+    constructor();
+    modelKey: string;
+    teamFilter: TeamListFilter;
+    userFilter: UserListFilter;
+    modelFilter: ModelFilter;
+    interventionFilter: ActionListFilter;
+    guideSettings: GuideSettingsDto;
+    teamPassword: string;
+}
+declare class GuideSettingsDto {
+    constructor();
+    activeGuideKey: string;
+    completedSteps: string[];
+}
+declare class ModelFilter {
+    constructor(interventionFilterType: InterventionFilterType);
+    interventionFilter: InterventionFilterType;
+}
+declare class TeamListFilter extends PagingOptions {
+    constructor();
+    tags: string[];
+    keyword: string;
+    sort?: TeamSortEnum;
+    status: TeamStatusEnum;
+}
+declare class UserListFilter extends PagingOptions {
+    constructor();
+    keyword: string;
+}
+declare class ActionListFilter extends PagingOptions {
+    keyword: string;
+    sort?: InterventionSortEnum;
+    state?: InterventionStateEnum;
+    owner?: InterventionOwnerEnum;
+    type?: InterventionTypeEnum;
+    teamKey: string;
+    expectedImpactOn: string;
+}
+declare enum InterventionFilterType {
+    All = "All",
+    OnlyOpen = "OnlyOpen",
+    OnlyCompleted = "OnlyCompleted",
+    None = "None"
+}
+declare enum TeamSortEnum {
+    name = "Name",
+    created = "Created"
+}
+declare enum TeamStatusEnum {
+    active = "Active",
+    archived = "Archived"
+}
+
+declare class UserInfoDto {
+    constructor();
+    publicKey: string;
+    isAdmin: boolean;
+    isSubscriptionAdmin: boolean;
+    isCoach: boolean;
+    multipleEnvironments: boolean;
+    features: FeaturesDto;
+    settings: UserSettingsDto;
+    branding: BrandingSettingsDto;
+    client: ClientInfoDto;
+    profile: UserProfileDto;
+}
+declare class UserProfileDto {
+    name: string;
+    email: string;
+    avatarUrl: string;
+    usesSSO: boolean;
+}
+
+declare class ChannelDto {
+    publicKey: string;
+    name: string;
+    branding: ChannelDefaultBrandingDto;
+    siteUrl: string;
+    poweredBy: string;
+    pitch: string;
+    navigationUrls: NavigationUrlDto[];
+}
+declare class ChannelDefaultBrandingDto extends BrandingSettingsDto {
+    logoLargeUrl: string;
+}
+declare class NavigationUrlDto {
+    name: string;
+    url: string;
+    category: NavigationUrlTypeEnum;
+    icon: string;
+    children: NavigationUrlDto[];
+}
+declare enum NavigationUrlTypeEnum {
+    MainMenuCTA = "MainMenuCTA",
+    MainMenu = "MainMenu",
+    Resources = "Resources",
+    Support = "Support",
+    SocialMedia = "SocialMedia",
+    Legal = "Legal"
+}
+
+interface IAggregateRootSource {
+    subscribe<T extends IViewState>(): Observable<T>;
+    reloadable(): boolean;
+    type(): LoadModes;
+    unsubscribe(): void;
+}
+interface IReloadStrategy {
+    subscribe(): void;
+    isConnected(): boolean;
+    unsubscribe(): void;
+    reload: BehaviorSubject<boolean>;
+}
+declare enum LoadModes {
+    Pull = 0,
+    Push = 1
+}
+interface IViewState {
+    loaded: boolean;
+    context: ContextItemDto[];
+    userInfo: UserInfoDto;
+    channel: ChannelDto;
+}
+interface IAggregateRootStreamFactory {
+    get(): IAggregateRootSource;
+}
+
+declare const VIEWSTATE_LOAD_STRATEGY: InjectionToken<IAggregateRootSource>;
+declare const VIEWSTATE_RELOAD_STRATEGY: InjectionToken<IAggregateRootSource>;
+declare const VIEWSTATE_PROVIDER: InjectionToken<ViewModelStateBase<IViewState>>;
+declare abstract class ViewModelStateBase<T extends IViewState> {
+    protected strategy: IAggregateRootSource;
+    protected reloadStrategy: IReloadStrategy;
+    protected startInstance: (new () => T);
+    data: BehaviorSubject<T>;
+    updating: BehaviorSubject<boolean>;
+    protected result: T;
+    protected loadUrl: string;
+    protected subscription: Subscription;
+    constructor(strategy: IAggregateRootSource, reloadStrategy: IReloadStrategy, startInstance: (new () => T));
+    load(): void;
+    forcedReload(): void;
+    reload(): void;
+    close(): void;
+    protected map(aggregate: T): void;
+    initiate(): void;
+}
+
+declare abstract class ComponentWithViewStateBase<T extends IViewState> extends ComponentBase implements OnInit, OnDestroy {
+    private stateStore;
+    protected snackBar: MatSnackBar;
+    loaded: boolean;
+    private stateStoreSubscription;
+    constructor(stateStore: ViewModelStateBase<T>, snackBar: MatSnackBar);
+    ngOnInit(): void;
+    protected onDataUpdate(data: T): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentWithViewStateBase<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentWithViewStateBase<any>>;
+}
+
+declare const VIEWSTATE_USERSETTINGS_STRATEGY: InjectionToken<IUserSettingStrategy>;
+declare class UserSettingService {
+    private storage;
+    private settings;
+    changed: Subject<UserSettingsDto>;
+    constructor(storage: StorageService);
+    set(filters: UserSettingsDto): void;
+    get(): UserSettingsDto;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserSettingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserSettingService>;
+}
+interface IUserSettingStrategy {
+    apply(): Promise<void>;
+    settings: UserSettingsDto;
+}
+
+declare class KeyValueDto {
+    constructor(key: string, value: string);
+    key: string;
+    value: string;
+}
+
+declare class BadgeCollectionDto {
+    badges: BadgeDto[];
+}
+declare class BadgeDto {
+    description: string;
+    icon: string;
+    color: string;
+    name: string;
+    level: number;
+    progress: number;
+    nextLevel: number;
+    nextLevelProgress: number;
+    nextLevelRequirement: string;
+    lost: boolean;
+    gained: boolean;
+    awarded: boolean;
+    hash: string;
+    type: BadgeTypeEnum;
+}
+declare enum BadgeTypeEnum {
+    streak = "Streak",
+    progression = "Progression"
+}
+
+declare class DimensionResultDto {
+    name: string;
+    color: string;
+    score: number;
+    difference: number;
+}
+
+declare class ParticipantDto {
+    publicKey: string;
+    obfuscatedEmail: string;
+    started: Date;
+    completed: Date;
+    isInvitation: boolean;
+    segment: string;
+    confirmDelete: boolean;
+    canDelete: boolean;
+    progress: number;
+    email: string;
+    warnings: string[];
+}
+
+declare class SnapshotDto {
+    publicKey: string;
+    closed: Date;
+    started: Date;
+    participants: number;
+    reportUrl: string;
+    inviteUrls: Record<SegmentEnum, string>;
+    teamKey: string;
+    limit: number;
+    note: string;
+    anonymized: boolean;
+    progress: number;
+    questionnaireType: string;
+    scaleKeys: string[];
+    participantList: ParticipantDto[];
+    coreDimensions: DimensionResultDto[];
+    factorScores: FactorScoreCollectionDto;
+    notificationEmail: string;
+    invitationGoal: number;
+}
+
+declare class TeamDto {
+    publicKey: string;
+    name: string;
+    email: string;
+    color: string;
+    measurements: number;
+    retakeUrl: string;
+    managementUrl: string;
+    snapshots: number;
+    colorString: string;
+    lowTrustMode: boolean;
+    benchmark: BenchmarkTypeEnum;
+    snapshotList: SnapshotDto[];
+    badges: BadgeDto[];
+    tags: string[];
+    overlayTeamKeys: string[];
+    interventionSummary: InterventionSummaryDto;
+    improvementGoal: string;
+    archived: boolean;
+    metaData: KeyValueDto;
+    teamTraitKeys: string[];
+}
+
+declare class TeamListResponseDto {
+    teams: PaginatedResponse<TeamDto>;
+    tags: string[];
+    names: TeamNameAndKeyDto[];
+    teamTraits: TeamTraitDto[];
+}
+declare class TeamNameAndKeyDto {
+    name: string;
+    publicKey: string;
+}
+declare class TeamTraitDto {
+    key: string;
+    name: string;
+}
+
+declare class TeamMetaDataDto {
+    name: string;
+    notificationEmail: string;
+    teamKey: string;
+    isSubscribed: boolean;
+    subscriptionTier: SubscriptionTierEnum;
+    managementUrl: string;
+    retakeUrl: string;
+    lowTrustMode: boolean;
+    pincode: string;
+    improvementGoal: string;
+    improvementGoals: SelectListItemApiDto[];
+    teamTypes: SelectListItemApiDto[];
+    reminderFrequencies: SelectListItemApiDto[];
+    reminderDate: Date;
+    notificationSettings: TeamNotificationSettingsDto;
+    teamTraits: SelectListItemApiDto[];
+}
+declare enum SubscriptionTierEnum {
+    Freemium = "Freemium",
+    Professional = "Professional",
+    Enterprise = "Enterprise"
+}
+declare abstract class SelectListItemApiDto {
+    key: string;
+    name: string;
+    selected: boolean;
+}
+declare class TeamNotificationSettingsDto {
+    newParticipant: boolean;
+    repeat: boolean;
+    actionDue: boolean;
+    recommendations: boolean;
+}
+
+declare class ActionCollectionDto {
+    constructor();
+    items: PaginatedResponse<ActionDto>;
+}
+
+interface IActionState extends IViewState {
+    actions: ActionCollectionDto;
+    factorScores: FactorScoreCollectionDto;
+    teamList: TeamListResponseDto;
+    teamMetaData: TeamMetaDataDto;
+}
+
+declare class ActionOptionsDto {
+    teams: ActionOptionDto[];
+}
+declare class ActionOptionDto {
+    constructor(key: string, label: string);
+    key: string;
+    label: string;
+}
+
+declare class ActionPrefillDto {
+    teamKey: string;
+    description: string;
+    expectedImpactOn: string[];
+    type: InterventionTypeEnum;
+    owner: InterventionOwnerEnum;
+    state: InterventionStateEnum;
+    quickTipPublicKey: string;
+    url: string;
+}
+
+declare const ApiConfigToken: InjectionToken<ApiConfigDto>;
+declare class ApiConfig {
+    private config?;
+    constructor(config?: ApiConfigDto);
+    set(config: ApiConfigDto): void;
+    get(): ApiConfigDto;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiConfig, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiConfig>;
+}
+declare class ApiConfigDto {
+    apiUrl: string;
+}
+
+declare class ExportActionsRequestDto {
+    dateRange: DateRangeDto;
+}
+
+declare class ActionService {
+    private http;
+    private config;
+    private baseUrl;
+    constructor(http: HttpClient, config: ApiConfig);
+    create(teamKey: string, dto: ActionDto): Promise<Object>;
+    update(teamKey: string, dto: ActionDto): Promise<Object>;
+    delete(teamKey: string, publicKey: string): Promise<Object>;
+    changeState(teamKey: string, publicKey: string, state: InterventionStateEnum): Promise<Object>;
+    getStateOptions(): ActionOptionDto[];
+    getOwnerOptions(): ActionOptionDto[];
+    getTypeOptions(): ActionOptionDto[];
+    exportActions(request: ExportActionsRequestDto): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionService>;
+}
+
+declare class SelectItem {
+    constructor(value: string, label: string, lower?: boolean);
+    value: string;
+    label: string;
+    lower: boolean;
+}
+
+declare class ActionManageComponent extends ComponentBase {
+    private dialogRef;
+    private formBuilder;
+    private actionService;
+    private viewModelState;
+    protected snackBar: MatSnackBar;
+    prefill: ActionPrefillDto;
+    action: ActionDto;
+    form: FormGroup;
+    interventionTypeList: ActionOptionDto[];
+    expectedEffectOnList: ActionOptionDto[];
+    stateList: ActionOptionDto[];
+    ownerList: ActionOptionDto[];
+    teams: ActionOptionDto[];
+    multipleTeams: boolean;
+    viewStateSubscription: Subscription;
+    showTeamSelector: boolean;
+    factors: SelectItem[];
+    constructor(dialogRef: MatDialog, formBuilder: FormBuilder, actionService: ActionService, viewModelState: ViewModelStateBase<IActionState>, snackBar: MatSnackBar);
+    ngOnInit(): void;
+    onSubmit(formDirective: FormGroupDirective): Promise<void>;
+    delete(): Promise<void>;
+    cancel(): void;
+    private resetForm;
+    private getFactors;
+    private createForm;
+    private applyPrefill;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionManageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionManageComponent, "action-manage", never, { "prefill": { "alias": "prefill"; "required": false; }; "action": { "alias": "action"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ActionListComponent extends ComponentWithViewStateBase<IActionState> {
+    protected snackBar: MatSnackBar;
+    protected userSettings: IUserSettingStrategy;
+    protected actionService: ActionService;
+    private state;
+    protected route: ActivatedRoute;
+    prefill: ActionPrefillDto;
+    overrideFilter: ActionListFilter;
+    actionManageComponent: ActionManageComponent;
+    actions: PaginatedResponse<ActionDto>;
+    multipleTeams: boolean;
+    sortOptionsList: ActionOptionDto[];
+    filterCount: number;
+    keywordControl: FormControl;
+    isLoggedIn: boolean;
+    constructor(snackBar: MatSnackBar, userSettings: IUserSettingStrategy, actionService: ActionService, state: ViewModelStateBase<IActionState>, route: ActivatedRoute);
+    ngOnInit(): Promise<void>;
+    setPaging(event: PaginatorPageEvent): Promise<void>;
+    setSort(sort: string): Promise<void>;
+    protected onDataUpdate(data: IActionState): void;
+    loadActions(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionListComponent, "action-list", never, { "prefill": { "alias": "prefill"; "required": false; }; "overrideFilter": { "alias": "overrideFilter"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ActionTileComponent extends ComponentWithViewStateBase<IActionState> {
+    protected snackBar: MatSnackBar;
+    protected actionService: ActionService;
+    private viewModelState;
+    protected route: ActivatedRoute;
+    action: ActionDto;
+    multipleTeams: boolean;
+    actionManageComponent: ActionManageComponent;
+    constructor(snackBar: MatSnackBar, actionService: ActionService, viewModelState: ViewModelStateBase<IActionState>, route: ActivatedRoute);
+    ngOnInit(): void;
+    obsolete(event: MouseEvent, action: ActionDto): Promise<void>;
+    complete(event: MouseEvent, action: ActionDto): Promise<void>;
+    open(event: MouseEvent, action: ActionDto): Promise<void>;
+    impede(event: MouseEvent, action: ActionDto): Promise<void>;
+    unimpede(event: MouseEvent, action: ActionDto): Promise<void>;
+    private changeState;
+    protected onDataUpdate(data: IActionState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionTileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionTileComponent, "action-tile", never, { "action": { "alias": "action"; "required": false; }; "multipleTeams": { "alias": "multipleTeams"; "required": false; }; "actionManageComponent": { "alias": "actionManageComponent"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DialogActionManageComponent {
+    private dialogRef;
+    data: {
+        prefill: ActionPrefillDto;
+        action: ActionDto;
+    };
+    constructor(dialogRef: MatDialog, data: {
+        prefill: ActionPrefillDto;
+        action: ActionDto;
+    });
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogActionManageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogActionManageComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+declare class OpenAddActionDialogDirective {
+    private dialog;
+    prefill: ActionPrefillDto;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenAddActionDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenAddActionDialogDirective, "[addActionDialog]", never, { "prefill": { "alias": "prefill"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class OpenEditActionDialogDirective {
+    private dialog;
+    action: ActionDto;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenEditActionDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenEditActionDialogDirective, "[editActionDialog]", never, { "action": { "alias": "action"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DialogActionFiltersComponent extends ComponentWithViewStateBase<IActionState> {
+    private state;
+    private actionService;
+    protected snackBar: MatSnackBar;
+    private dialogRef;
+    protected userSettings: IUserSettingStrategy;
+    data: {};
+    stateFilterList: ActionOptionDto[];
+    ownerFilterList: ActionOptionDto[];
+    typeFilterList: ActionOptionDto[];
+    expectedEffectOnList: ActionOptionDto[];
+    teams: ActionOptionDto[];
+    multipleTeams: boolean;
+    constructor(state: ViewModelStateBase<IActionState>, actionService: ActionService, snackBar: MatSnackBar, dialogRef: MatDialogRef<DialogActionFiltersComponent>, userSettings: IUserSettingStrategy, data: {});
+    ngOnInit(): Promise<void>;
+    protected onDataUpdate(data: IActionState): void;
+    applyFilters(): Promise<void>;
+    clearFilters(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogActionFiltersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogActionFiltersComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+declare class OpenActionFiltersDialogDirective {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenActionFiltersDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenActionFiltersDialogDirective, "[actionFiltersDialog]", never, {}, {}, never, never, false, never>;
+}
+
+declare class DialogExportActionsComponent extends ComponentWithViewStateBase<IViewState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    private actionService;
+    private dialogRef;
+    private formBuilder;
+    form: FormGroup;
+    sending: boolean;
+    submitted: boolean;
+    constructor(state: ViewModelStateBase<IViewState>, snackBar: MatSnackBar, actionService: ActionService, dialogRef: MatDialogRef<DialogExportActionsComponent>, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    submit(): Promise<void>;
+    protected onDataUpdate(data: IViewState): void;
+    private createForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogExportActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogExportActionsComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class InterventionTypeToStringPipe implements PipeTransform {
+    transform(type: InterventionTypeEnum): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterventionTypeToStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InterventionTypeToStringPipe, "interventionTypeToString", false>;
+}
+
+declare class InterventionStateToStringPipe implements PipeTransform {
+    transform(type: InterventionStateEnum): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterventionStateToStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InterventionStateToStringPipe, "interventionStateToStringPipe", false>;
+}
+
+declare class InterventionOwnerToStringPipe implements PipeTransform {
+    transform(type: InterventionOwnerEnum): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterventionOwnerToStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InterventionOwnerToStringPipe, "interventionOwnerToString", false>;
+}
+
+declare class OpenExportActionsDialogDirective {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenExportActionsDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenExportActionsDialogDirective, "[exportActionsDialog]", never, {}, {}, never, never, false, never>;
+}
+
+declare class PaginatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PaginatorModule, [typeof PaginatorComponent], [typeof i2.MatSelectModule, typeof i3.RouterModule, typeof i2$1.CommonModule, typeof i3$1.FormsModule, typeof i6.MatInputModule], [typeof PaginatorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PaginatorModule>;
+}
+
+declare class ActionsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ActionsModule, [typeof ActionListComponent, typeof ActionManageComponent, typeof ActionTileComponent, typeof DialogActionManageComponent, typeof DialogActionFiltersComponent, typeof DialogExportActionsComponent, typeof InterventionTypeToStringPipe, typeof InterventionStateToStringPipe, typeof InterventionOwnerToStringPipe, typeof OpenAddActionDialogDirective, typeof OpenEditActionDialogDirective, typeof OpenActionFiltersDialogDirective, typeof OpenExportActionsDialogDirective], [typeof i2$2.MatDialogModule, typeof i12.MatTooltipModule, typeof i54.MatNativeDateModule, typeof i14.MatMenuModule, typeof i15.MatPaginatorModule, typeof i2.MatSelectModule, typeof i3.RouterModule, typeof PaginatorModule, typeof i2$1.CommonModule, typeof i3$1.FormsModule, typeof i3$1.ReactiveFormsModule, typeof i6.MatInputModule, typeof i22.MatDatepickerModule], [typeof ActionListComponent, typeof ActionManageComponent, typeof ActionTileComponent, typeof DialogActionManageComponent, typeof DialogActionFiltersComponent, typeof DialogExportActionsComponent, typeof InterventionTypeToStringPipe, typeof InterventionOwnerToStringPipe, typeof InterventionStateToStringPipe, typeof OpenAddActionDialogDirective, typeof OpenEditActionDialogDirective, typeof OpenActionFiltersDialogDirective, typeof OpenExportActionsDialogDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ActionsModule>;
+}
+
+declare class ActionClientConfig {
+    private config?;
+    constructor(config?: ActionConfigDto);
+    set(config: ActionConfigDto): void;
+    get(): ActionConfigDto;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionClientConfig, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionClientConfig>;
+}
+declare class ActionConfigDto {
+}
+declare const AactionConfigToken: InjectionToken<ActionConfigDto>;
+
+declare class NgAddToCalendarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgAddToCalendarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgAddToCalendarModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgAddToCalendarModule>;
+}
+
+declare class AlertDto {
+    key: string;
+    title: string;
+    body: string;
+    posted: Date;
+    isDismissed: boolean;
+    canBeDismissed: boolean;
+    urgency: string;
+    url: string;
+}
+
+declare class AlertResponseDto {
+    constructor();
+    alerts: PaginatedResponse<AlertDto>;
+    announcement: AlertDto;
+}
+
+interface IAlertState extends IViewState {
+    alerts: AlertResponseDto;
+    unreadAlerts: PaginatedResponse<AlertDto>;
+}
+
+declare class AlertFilterDto {
+    itemsPerPage: number;
+    totalItems: number;
+    page: number;
+}
+
+declare class DismissAlertRequestDto {
+    keys: string[];
+    snapshotKey: string;
+    participantKey: string;
+    teamKey: string;
+}
+
+declare class AlertService {
+    protected state: ViewModelStateBase<IAlertState>;
+    private http;
+    private config;
+    constructor(state: ViewModelStateBase<IAlertState>, http: HttpClient, config: ApiConfig);
+    dismiss(request: DismissAlertRequestDto): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertService>;
+}
+
+declare class DismissedAlertsService {
+    private storage;
+    dismissedAlerts: string[];
+    constructor(storage: StorageService);
+    dismiss(alert: AlertDto): void;
+    isDismissed(alert: AlertDto): boolean;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DismissedAlertsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DismissedAlertsService>;
+}
+
+declare class AlertsComponent extends ComponentBase {
+    private alertService;
+    private dismissedAlertService;
+    protected snackBar: MatSnackBar;
+    private viewModelState;
+    pageSize: number;
+    onlyUnread: boolean;
+    private allAlerts;
+    private unreadAlerts;
+    filteredAlerts: AlertDto[];
+    filter: AlertFilterDto;
+    viewStateSubscription: Subscription;
+    constructor(alertService: AlertService, dismissedAlertService: DismissedAlertsService, snackBar: MatSnackBar, viewModelState: ViewModelStateBase<IAlertState>);
+    ngOnInit(): void;
+    isDismissed(alert: AlertDto): boolean;
+    setPaging(event: PageEvent): void;
+    private selectAlerts;
+    dismiss(alert: AlertDto): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlertsComponent, "alerts", never, { "pageSize": { "alias": "pageSize"; "required": false; }; "onlyUnread": { "alias": "onlyUnread"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class OpenAlertsDialogDirective {
+    private dialog;
+    archiveUrl: any[];
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenAlertsDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenAlertsDialogDirective, "[alertsDialog]", never, { "archiveUrl": { "alias": "archiveUrl"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DialogAlertsComponent {
+    dialogRef: MatDialogRef<DialogAlertsComponent>;
+    data: {
+        archiveUrl: any[];
+    };
+    key: string;
+    archiveUrl: any[];
+    constructor(dialogRef: MatDialogRef<DialogAlertsComponent>, data: {
+        archiveUrl: any[];
+    });
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogAlertsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogAlertsComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class AlertAnnouncementComponent extends ComponentWithViewStateBase<IAlertState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    private dismissedAlertService;
+    announcement: AlertDto;
+    constructor(state: ViewModelStateBase<IAlertState>, snackBar: MatSnackBar, dismissedAlertService: DismissedAlertsService);
+    dismiss(): void;
+    protected onDataUpdate(data: IAlertState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertAnnouncementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlertAnnouncementComponent, "alert-announcement", never, {}, {}, never, never, false, never>;
+}
+
+declare class AlertsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AlertsModule, [typeof AlertsComponent, typeof OpenAlertsDialogDirective, typeof DialogAlertsComponent, typeof AlertAnnouncementComponent], [typeof i2$2.MatDialogModule, typeof i15.MatPaginatorModule, typeof i3.RouterModule, typeof i2$1.CommonModule, typeof i9.StorageServiceModule], [typeof AlertsComponent, typeof OpenAlertsDialogDirective, typeof DialogAlertsComponent, typeof AlertAnnouncementComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AlertsModule>;
+}
+
+declare class AlertClientConfig {
+    private config?;
+    constructor(config?: AlertConfigDto);
+    set(config: AlertConfigDto): void;
+    get(): AlertConfigDto;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertClientConfig, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertClientConfig>;
+}
+declare class AlertConfigDto {
+}
+declare const AlertConfigToken: InjectionToken<AlertConfigDto>;
+
+declare class BrandingProvider {
+    palette: PaletteItem[];
+    changed: Subject<PaletteItem[]>;
+    branding: Subject<BrandingSettingsDto>;
+    currentBranding: BrandingSettingsDto;
+    constructor();
+    set(branding: BrandingSettingsDto): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrandingProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BrandingProvider>;
+}
+declare class PaletteItem {
+    constructor(key: string, hex: string);
+    key: string;
+    hex: string;
+}
+
+declare class BrandBackgroundDirective {
+    private brandingProvider;
+    palette: string;
+    backgroundColor: string;
+    private paletteItems;
+    constructor(brandingProvider: BrandingProvider);
+    ngOnInit(): void;
+    private setColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrandBackgroundDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrandBackgroundDirective, "[brandbackground]", never, { "palette": { "alias": "palette"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BrandConditionalBackgroundColorDirective {
+    private brandingProvider;
+    defaultColor: string;
+    activeColor: string;
+    active: boolean;
+    backgroundColor: string;
+    private loadedDefaultColor;
+    private loadedActiveColor;
+    constructor(brandingProvider: BrandingProvider);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private setColors;
+    private getColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrandConditionalBackgroundColorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrandConditionalBackgroundColorDirective, "[brandConditionalBackgroundColor]", never, { "defaultColor": { "alias": "palette"; "required": false; }; "activeColor": { "alias": "activePalette"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BrandConditionalColorDirective {
+    private brandingProvider;
+    defaultColor: string;
+    activeColor: string;
+    active: boolean;
+    backgroundColor: string;
+    textColor: string;
+    private loadedDefaultColor;
+    private loadedActiveColor;
+    constructor(brandingProvider: BrandingProvider);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private setColors;
+    private getColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrandConditionalColorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrandConditionalColorDirective, "[brandConditionalColor]", never, { "defaultColor": { "alias": "palette"; "required": false; }; "activeColor": { "alias": "activePalette"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BrandHoverColorDirective {
+    private brandingProvider;
+    defaultColor: string;
+    hoverColor: string;
+    backgroundColor: string;
+    textColor: string;
+    private loadedDefaultColor;
+    private loadedHoverColor;
+    constructor(brandingProvider: BrandingProvider);
+    private getColor;
+    ngOnInit(): void;
+    private setColors;
+    mouseOver(): void;
+    mouseLeave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrandHoverColorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrandHoverColorDirective, "[brandHoverColor]", never, { "defaultColor": { "alias": "palette"; "required": false; }; "hoverColor": { "alias": "hoverPalette"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SiteDefaultFooterComponent extends ComponentWithViewStateBase<IViewState> {
+    private state;
+    error: string;
+    channel: ChannelDto;
+    mainMenu: NavigationUrlDto[];
+    socialMediaMenu: NavigationUrlDto[];
+    resourcesMenu: NavigationUrlDto[];
+    supportMenu: NavigationUrlDto[];
+    constructor(state: ViewModelStateBase<IViewState>, snackBar: MatSnackBar);
+    ngOnInit(): Promise<void>;
+    protected onDataUpdate(data: IViewState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiteDefaultFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiteDefaultFooterComponent, "site-default-footer", never, {}, {}, never, never, false, never>;
+}
+
+declare class SiteDefaultHeaderComponent extends ComponentWithViewStateBase<IViewState> {
+    private state;
+    visible: boolean;
+    channel: ChannelDto;
+    mainMenu: NavigationUrlDto[];
+    cta: NavigationUrlDto;
+    constructor(state: ViewModelStateBase<IViewState>, snackBar: MatSnackBar);
+    ngOnInit(): Promise<void>;
+    toggleMenu($event: any): void;
+    onClick(): void;
+    protected onDataUpdate(data: IViewState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiteDefaultHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiteDefaultHeaderComponent, "site-default-header", never, {}, {}, never, never, false, never>;
+}
+
+declare class SiteMicroFooterComponent extends ComponentWithViewStateBase<IViewState> {
+    private state;
+    channel: ChannelDto;
+    legalMenu: NavigationUrlDto[];
+    constructor(state: ViewModelStateBase<IViewState>, snackBar: MatSnackBar);
+    ngOnInit(): Promise<void>;
+    protected onDataUpdate(data: IViewState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiteMicroFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiteMicroFooterComponent, "footer[site-micro-footer]", never, {}, {}, never, never, false, never>;
+}
+
+interface ContactDto {
+    fromEmail: string;
+    requests: string[];
+    body: string;
+    type: number;
+    context: ContextItemDto[];
+}
+
+declare class ContactService {
+    private handler;
+    private config;
+    constructor(handler: HttpBackend, config: ApiConfig);
+    send(contact: ContactDto): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContactService>;
+}
+
+interface ContactTypeDto {
+    id: number;
+    label: string;
+}
+
+declare class DialogSupportComponent {
+    private state;
+    dialogRef: MatDialogRef<DialogSupportComponent>;
+    data: {
+        type: number;
+    };
+    private contactService;
+    protected snackBar: MatSnackBar;
+    private formBuilder;
+    form: FormGroup;
+    title: string;
+    textAreaLabel: string;
+    sending: boolean;
+    success: boolean;
+    error: string;
+    submitted: boolean;
+    typePrefilled: boolean;
+    private context;
+    private stateStoreSubscription;
+    contactTypes: ContactTypeDto[];
+    constructor(state: ViewModelStateBase<IViewState>, dialogRef: MatDialogRef<DialogSupportComponent>, data: {
+        type: number;
+    }, contactService: ContactService, snackBar: MatSnackBar, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    submitContactForm(): void;
+    private createForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogSupportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogSupportComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class OpenSupportDialogDirective {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenSupportDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenSupportDialogDirective, "[supportDialog]", never, {}, {}, never, never, false, never>;
+}
+declare class OpenFeedbackDialogDirective {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenFeedbackDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenFeedbackDialogDirective, "[feedbackDialog]", never, {}, {}, never, never, false, never>;
+}
+declare class OpenLookingForHelpDialog {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenLookingForHelpDialog, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenLookingForHelpDialog, "[lookingForHelpDialog]", never, {}, {}, never, never, false, never>;
+}
+declare class OpenReportBugDialogDirective {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenReportBugDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenReportBugDialogDirective, "[reportBugDialog]", never, {}, {}, never, never, false, never>;
+}
+declare class OpenContactSalesDialog {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenContactSalesDialog, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenContactSalesDialog, "[contactSalesDialog]", never, {}, {}, never, never, false, never>;
+}
+
+declare class DialogSupportModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogSupportModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogSupportModule, [typeof DialogSupportComponent, typeof OpenFeedbackDialogDirective, typeof OpenReportBugDialogDirective, typeof OpenLookingForHelpDialog, typeof OpenSupportDialogDirective, typeof OpenContactSalesDialog], [typeof i3$1.FormsModule, typeof i2.MatSelectModule, typeof i3$2.MatSnackBarModule, typeof i6.MatInputModule, typeof i2$1.CommonModule, typeof i3$1.ReactiveFormsModule, typeof i54.MatOptionModule, typeof i2$2.MatDialogModule], [typeof DialogSupportComponent, typeof OpenFeedbackDialogDirective, typeof OpenReportBugDialogDirective, typeof OpenLookingForHelpDialog, typeof OpenSupportDialogDirective, typeof OpenContactSalesDialog]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DialogSupportModule>;
+}
+
+declare class BrandingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrandingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BrandingModule, [typeof BrandBackgroundDirective, typeof BrandHoverColorDirective, typeof BrandConditionalBackgroundColorDirective, typeof BrandConditionalColorDirective, typeof SiteDefaultFooterComponent, typeof SiteDefaultHeaderComponent, typeof SiteMicroFooterComponent], [typeof i2$1.CommonModule, typeof i3.RouterModule, typeof DialogSupportModule], [typeof BrandBackgroundDirective, typeof BrandHoverColorDirective, typeof BrandConditionalColorDirective, typeof BrandConditionalBackgroundColorDirective, typeof SiteDefaultFooterComponent, typeof SiteDefaultHeaderComponent, typeof SiteMicroFooterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BrandingModule>;
+}
+
+declare class CheckboxComponent implements ControlValueAccessor {
+    label: string;
+    disabled: boolean;
+    onCheckChange: EventEmitter<boolean>;
+    checked: boolean;
+    constructor();
+    ngOnInit(): void;
+    toggle(): void;
+    onChange: (rating: boolean) => void;
+    onTouched: () => void;
+    writeValue(checked: boolean): void;
+    get value(): boolean;
+    registerOnChange(fn: (rating: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "checkbox", never, { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; }, { "onCheckChange": "onCheckChange"; }, never, never, false, never>;
+}
+
+declare class CheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CheckboxModule, [typeof CheckboxComponent], [typeof i2$1.CommonModule], [typeof CheckboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CheckboxModule>;
+}
+
+declare class ExpandComponent {
+    items: ExpandItemDto[];
+    theme: string;
+    numbering: boolean;
+    categories: string[];
+    selected: number;
+    constructor();
+    ngOnInit(): void;
+    expand(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandComponent, "expand", never, { "items": { "alias": "items"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "numbering": { "alias": "numbering"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class ExpandItemDto {
+    constructor(index: number, category: string, label: string, body: string);
+    index: number;
+    category: string;
+    label: string;
+    body: string;
+}
+
+declare class ExpandModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ExpandModule, [typeof ExpandComponent], [typeof i2$1.CommonModule], [typeof ExpandComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ExpandModule>;
+}
+
+declare class LoadingComponent extends ComponentWithViewStateBase<IViewState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    showLoading: boolean;
+    message: string;
+    ready: boolean;
+    constructor(state: ViewModelStateBase<IViewState>, snackBar: MatSnackBar);
+    protected onDataUpdate(data: IViewState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingComponent, "loading", never, { "showLoading": { "alias": "showLoading"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class LoadingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LoadingModule, [typeof LoadingComponent], [typeof i2$1.CommonModule], [typeof LoadingComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LoadingModule>;
+}
+
+declare class MatTagsComponent {
+    private formBuilder;
+    form: UntypedFormGroup;
+    newTagControl: UntypedFormControl;
+    filteredTags: Observable<string[]>;
+    allTags: string[];
+    tags: string[];
+    tagsChangedEvent: EventEmitter<string[]>;
+    tagInput: ElementRef<HTMLInputElement>;
+    separatorKeysCodes: number[];
+    constructor(formBuilder: UntypedFormBuilder);
+    ngOnInit(): void;
+    private createForm;
+    add(event: MatChipInputEvent): void;
+    remove(tag: string): void;
+    private filter;
+    selected(event: MatAutocompleteSelectedEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTagsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatTagsComponent, "mat-tags", never, { "allTags": { "alias": "allTags"; "required": false; }; }, { "tagsChangedEvent": "tagsChangedEvent"; }, never, never, false, never>;
+}
+
+declare class MatTagsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTagsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatTagsModule, [typeof MatTagsComponent], [typeof i2$3.MatAutocompleteModule, typeof i3$1.FormsModule, typeof i4.MatFormFieldModule, typeof i3$1.ReactiveFormsModule, typeof i2$1.CommonModule, typeof i6$1.MatChipsModule, typeof i6.MatInputModule], [typeof MatTagsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatTagsModule>;
+}
+
+declare class MetaDataInputComponent implements ControlValueAccessor {
+    private formBuilder;
+    form: FormGroup;
+    maximum: number;
+    addLabel: string;
+    emptyLabel: string;
+    changed: EventEmitter<KeyValueDto[]>;
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    writeValue(fields: KeyValueDto[]): void;
+    getValue(): KeyValueDto[];
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    addField(): void;
+    removeField(index: number): void;
+    fields(): FormArray;
+    private createField;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaDataInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaDataInputComponent, "metadata-input", never, { "maximum": { "alias": "maximum"; "required": false; }; "addLabel": { "alias": "addLabel"; "required": false; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; }; }, { "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class MetadataInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MetadataInputModule, [typeof MetaDataInputComponent], [typeof i2$1.CommonModule, typeof i3$1.FormsModule, typeof i4.MatFormFieldModule, typeof i3$1.ReactiveFormsModule, typeof i6.MatInputModule], [typeof MetaDataInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MetadataInputModule>;
+}
+
+declare class MultiEmailInputComponent implements ControlValueAccessor {
+    private formBuilder;
+    form: FormGroup;
+    maximum: number;
+    addLabel: string;
+    emptyLabel: string;
+    changed: EventEmitter<string[]>;
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    writeValue(emails: string[]): void;
+    getValue(): string[];
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    addField(): void;
+    removeField(index: number): void;
+    fields(): FormArray;
+    onKeyDown(event: KeyboardEvent): void;
+    private createField;
+    private isValidEmail;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiEmailInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiEmailInputComponent, "multi-email-input", never, { "maximum": { "alias": "maximum"; "required": false; }; "addLabel": { "alias": "addLabel"; "required": false; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; }; }, { "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class MultiEmailInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiEmailInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MultiEmailInputModule, [typeof MultiEmailInputComponent], [typeof i2$1.CommonModule, typeof i3$1.FormsModule, typeof i4.MatFormFieldModule, typeof i3$1.ReactiveFormsModule, typeof i6.MatInputModule], [typeof MultiEmailInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MultiEmailInputModule>;
+}
+
+declare class QuantitySelectorComponent implements ControlValueAccessor {
+    quantity: number;
+    disabled: boolean;
+    maximum: number;
+    minimum: number;
+    onChange: any;
+    onTouched: any;
+    increaseQuantity(): void;
+    setQuantity(): void;
+    decreaseQuantity(): void;
+    onInput(event: Event): void;
+    writeValue(quantity: number): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuantitySelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuantitySelectorComponent, "quantity-selector", never, { "disabled": { "alias": "disabled"; "required": false; }; "maximum": { "alias": "maximum"; "required": false; }; "minimum": { "alias": "minimum"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class QuantitySelectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuantitySelectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<QuantitySelectorModule, [typeof QuantitySelectorComponent], [typeof i2$1.CommonModule, typeof i3.RouterModule, typeof i3$1.FormsModule, typeof i4.MatFormFieldModule, typeof i3$1.ReactiveFormsModule, typeof i6.MatInputModule], [typeof QuantitySelectorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<QuantitySelectorModule>;
+}
+
+declare class SelectListComponent implements ControlValueAccessor {
+    options: SelectListItem[];
+    multiple: boolean;
+    noAnswerOption: SelectListItem;
+    disabled: boolean;
+    constructor();
+    select(option: SelectListItem): void;
+    writeValue(selected: SelectListItem[]): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    onChange: (options: SelectListItem[]) => void;
+    onTouched: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectListComponent, "select-list", never, { "options": { "alias": "options"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "noAnswerOption": { "alias": "noAnswerOption"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class SelectListItem {
+    constructor(key: string, label: string, selected?: boolean);
+    key: string;
+    label: string;
+    selected: boolean;
+}
+
+declare class SelectListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectListModule, [typeof SelectListComponent], [typeof i3$1.FormsModule, typeof i4.MatFormFieldModule, typeof i3$1.ReactiveFormsModule, typeof i2$1.CommonModule, typeof i2.MatSelectModule, typeof i12.MatTooltip, typeof BrandingModule], [typeof SelectListComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectListModule>;
+}
+
+declare class SnapshotMetaDataDto {
+    reportUrl: string;
+    teamKey: string;
+    publicKey: string;
+    started: Date;
+    closed: Date;
+    inviteUrls: Record<string, string>;
+    invitationGoal: number;
+}
+declare class InviteUrlDto {
+    segment: string;
+    value: string;
+}
+
+declare class SnapshotInviteUrlsComponent {
+    private snackBar;
+    private clipboard;
+    snapshot: SnapshotMetaDataDto;
+    constructor(snackBar: MatSnackBar, clipboard: Clipboard);
+    unsorted(a: any, b: any): number;
+    copyInvitationUrl(url: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnapshotInviteUrlsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SnapshotInviteUrlsComponent, "snapshot-inviteurls", never, { "snapshot": { "alias": "snapshot"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SnapshotInviteUrlsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnapshotInviteUrlsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SnapshotInviteUrlsModule, [typeof SnapshotInviteUrlsComponent], [typeof i4.MatFormFieldModule, typeof i3$1.ReactiveFormsModule, typeof i2$1.CommonModule, typeof i5.ClipboardModule], [typeof SnapshotInviteUrlsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SnapshotInviteUrlsModule>;
+}
+
+declare class TabNavigatorComponent {
+    private router;
+    itemSet: i0.WritableSignal<TabItemDto[]>;
+    set items(value: TabItemDto[]);
+    constructor(router: Router);
+    updateActiveItem(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabNavigatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabNavigatorComponent, "tabnavigator", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class TabItemDto {
+    constructor(label: string, url: string);
+    label: string;
+    url: string;
+    active: boolean;
+}
+
+declare class SlugifyPipe implements PipeTransform {
+    transform(str: string): string;
+    isString(value: any): value is string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlugifyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SlugifyPipe, "slugify", false>;
+}
+
+declare class SlugifyPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlugifyPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SlugifyPipeModule, [typeof SlugifyPipe], never, [typeof SlugifyPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SlugifyPipeModule>;
+}
+
+declare class TabNavigatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabNavigatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TabNavigatorModule, [typeof TabNavigatorComponent], [typeof i2$1.CommonModule, typeof i3.RouterModule, typeof SlugifyPipeModule], [typeof TabNavigatorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TabNavigatorModule>;
+}
+
+declare function presetCheckValidator(presetKey: string): ValidatorFn;
+
+declare function minTopicsSelectedValidator(minimum: number): ValidatorFn;
+
+declare class TopicSelectorComponent implements ControlValueAccessor {
+    private formBuilder;
+    private dialog;
+    form: FormGroup;
+    warnings: string[];
+    private topicSelectionDto;
+    private selectedTopics;
+    questionnaireAccuracy: number;
+    questionsTeamMembers: number;
+    questionsStakeholders: number;
+    questionsSupporters: number;
+    durationTeamMembers: number;
+    durationStakeholders: number;
+    durationSupporters: number;
+    questionsTotal: number;
+    topics: FactorStructureDto[];
+    presets: QuestionnaireTypeDto[];
+    disabled: boolean;
+    topicKeys: string[];
+    SegmentEnum: typeof SegmentEnum;
+    private formSubscription;
+    constructor(formBuilder: FormBuilder, dialog: MatDialog);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    toggleTopic(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    onChange: any;
+    onTouch: any;
+    writeValue(dto: TopicSelectorDto): void;
+    setDisabledState?(isDisabled: boolean): void;
+    selectPreset(): void;
+    getValue(): TopicSelectorDto;
+    openFactorInformation(topicKey: string, $event: Event): void;
+    hasSegmentQuestions(factor: FactorStructureDto, segment: SegmentEnum, useOwnQuestionCount: boolean): boolean;
+    getCoreFactors(): FactorStructureDto[];
+    getSubFactors(parentKey: string): FactorStructureDto[];
+    selectAll(topic: FactorStructureDto, $event: Event): void;
+    selectNone(topic: FactorStructureDto, $event: Event): void;
+    private wireUpTopicSelection;
+    private createForm;
+    private updateMetaData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopicSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TopicSelectorComponent, "topic-selector", never, { "topics": { "alias": "topics"; "required": false; }; "presets": { "alias": "presets"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "topicKeys": { "alias": "topicKeys"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class TopicSelectorDto {
+    constructor(presetKey: string, topicKeys: string[]);
+    presetKey: string;
+    topicKeys: string[];
+}
+
+declare class DialogFactorInformationComponent {
+    factor: FactorStructureDto;
+    constructor(factor: FactorStructureDto);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogFactorInformationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogFactorInformationComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+declare class OpenFactorInformationDialogDirective {
+    private dialog;
+    factor: FactorStructureDto;
+    constructor(dialog: MatDialog);
+    onClick($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenFactorInformationDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenFactorInformationDialogDirective, "[factorInformationDialog]", never, { "factor": { "alias": "factor"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class FactorInformationDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FactorInformationDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FactorInformationDialogModule, [typeof DialogFactorInformationComponent, typeof OpenFactorInformationDialogDirective], [typeof i2$2.MatDialogModule, typeof i3$2.MatSnackBarModule, typeof i2$1.CommonModule], [typeof DialogFactorInformationComponent, typeof OpenFactorInformationDialogDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FactorInformationDialogModule>;
+}
+
+declare class TopicSelectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopicSelectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TopicSelectorModule, [typeof TopicSelectorComponent], [typeof i2$1.CommonModule, typeof i3$1.FormsModule, typeof i4.MatFormFieldModule, typeof i3$1.ReactiveFormsModule, typeof i6.MatInputModule, typeof i2.MatSelectModule, typeof i7.MatCheckboxModule, typeof SlugifyPipeModule, typeof FactorInformationDialogModule], [typeof TopicSelectorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TopicSelectorModule>;
+}
+
+declare class AccountService$1 {
+    private http;
+    private config;
+    constructor(http: HttpClient, config: ApiConfig);
+    sendResetPassword(email: string): Observable<any>;
+    getManageUrl(): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountService$1, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccountService$1>;
+}
+
+interface IResultsState extends IActionState, IViewState {
+    factorScores: FactorScoreCollectionDto;
+    badges: BadgeCollectionDto;
+    isSubscriber: boolean;
+    baseUrl: string;
+    type: ContextTypes;
+    teamMetaData: TeamMetaDataDto;
+}
+interface ITeamReportResultsState extends IResultsState, IViewState {
+    teamMetaData: TeamMetaDataDto;
+    snapshotMetaData: SnapshotMetaDataDto;
+}
+
+declare class DialogAccountComponent extends ComponentWithViewStateBase<IResultsState> {
+    private authService;
+    protected snackBar: MatSnackBar;
+    private accountService;
+    dialogRef: MatDialogRef<DialogAccountComponent>;
+    private state;
+    subscriptionKey: string;
+    userName: string;
+    loading: boolean;
+    isAdmin: boolean;
+    email: string;
+    constructor(authService: AuthService, snackBar: MatSnackBar, accountService: AccountService$1, dialogRef: MatDialogRef<DialogAccountComponent>, state: ViewModelStateBase<IResultsState>);
+    ngOnInit(): void;
+    redirectToPortal(): Promise<void>;
+    sendPasswordReset(): void;
+    signout(): void;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogAccountComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogAccountComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+declare class OpenAccountDialogDirective {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenAccountDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenAccountDialogDirective, "[accountDialog]", never, {}, {}, never, never, false, never>;
+}
+
+declare class DialogAccountModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogAccountModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogAccountModule, [typeof DialogAccountComponent, typeof OpenAccountDialogDirective], [typeof i2$2.MatDialogModule, typeof i2$1.CommonModule], [typeof DialogAccountComponent, typeof OpenAccountDialogDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DialogAccountModule>;
+}
+
+declare class ResetPasswordRequestDto {
+    email: string;
+}
+
+declare class ResourceDownloadService {
+    private http;
+    private config;
+    private baseUrl;
+    constructor(http: HttpClient, config: ApiConfig);
+    get(publicKey: string, brandingSettings: ContentBrandingDto): Promise<ResourceDownloadRedirectUrlDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceDownloadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceDownloadService>;
+}
+declare class ResourceDownloadRedirectUrlDto {
+    cdnUrl: string;
+}
+
+declare class DialogResourceDownloadComponent {
+    private brandingProvider;
+    private snackBar;
+    private dialogRef;
+    private downloadService;
+    publicKey: string;
+    cdnUrl: string;
+    error: boolean;
+    private contentBranding;
+    constructor(brandingProvider: BrandingProvider, snackBar: MatSnackBar, data: string, dialogRef: MatDialogRef<DialogResourceDownloadComponent>, downloadService: ResourceDownloadService);
+    ngOnInit(): Promise<void>;
+    initiateDownload(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogResourceDownloadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogResourceDownloadComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+declare class OpenResourceDownloadDialogDirective {
+    private dialog;
+    publicKey: string;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenResourceDownloadDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenResourceDownloadDialogDirective, "[resourceDownloadDialog]", never, { "publicKey": { "alias": "publicKey"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ResourceDownloadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceDownloadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ResourceDownloadModule, [typeof DialogResourceDownloadComponent, typeof OpenResourceDownloadDialogDirective], [typeof i2$2.MatDialogModule, typeof i3$2.MatSnackBarModule, typeof BrandingModule, typeof i2$1.CommonModule], [typeof DialogResourceDownloadComponent, typeof OpenResourceDownloadDialogDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ResourceDownloadModule>;
+}
+
+declare class DialogSubscribeComponent {
+    private state;
+    subscribeUrl: string;
+    companyUrl: string;
+    title: string;
+    button: string;
+    discount: boolean;
+    constructor(state: ViewModelStateBase<IViewState>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogSubscribeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogSubscribeComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class OpenSubscribeDialogDirective {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenSubscribeDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenSubscribeDialogDirective, "[subscribeDialog]", never, {}, {}, never, never, false, never>;
+}
+
+declare class DialogSubscribeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogSubscribeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogSubscribeModule, [typeof DialogSubscribeComponent, typeof OpenSubscribeDialogDirective], [typeof i2$2.MatDialogModule, typeof i2$1.CommonModule], [typeof DialogSubscribeComponent, typeof OpenSubscribeDialogDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DialogSubscribeModule>;
+}
+
+declare class BackButtonDirective {
+    private location;
+    private router;
+    constructor(location: Location, router: Router);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BackButtonDirective, "[backButton]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BackButtonDirectiveModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackButtonDirectiveModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BackButtonDirectiveModule, [typeof BackButtonDirective], never, [typeof BackButtonDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BackButtonDirectiveModule>;
+}
+
+declare class ClickableTooltipDirective {
+    private matTooltip;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickableTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickableTooltipDirective, "[matTooltip]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GuardsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuardsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GuardsModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GuardsModule>;
+}
+
+declare class ValidChangeTokenGuard implements CanActivate {
+    private router;
+    constructor(router: Router);
+    canActivate(route: ActivatedRouteSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidChangeTokenGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidChangeTokenGuard>;
+}
+
+declare class ValidKeyGuard implements CanActivate {
+    private router;
+    constructor(router: Router);
+    canActivate(route: ActivatedRouteSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidKeyGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidKeyGuard>;
+}
+
+declare class ValidKeySnapshotKeyGuard implements CanActivate {
+    private router;
+    constructor(router: Router);
+    canActivate(route: ActivatedRouteSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidKeySnapshotKeyGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidKeySnapshotKeyGuard>;
+}
+
+declare class ValidKeyTeamKeyGuard implements CanActivate {
+    private router;
+    constructor(router: Router);
+    canActivate(route: ActivatedRouteSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidKeyTeamKeyGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidKeyTeamKeyGuard>;
+}
+
+declare class ErrorDto {
+    constructor();
+    error: string;
+    url: string;
+    userAgent: string;
+    stackTrace: string;
+    serverStackTrace: string;
+    details: ErrorDetailDto[];
+    loggingSeverity: LoggingSeverityEnum;
+}
+declare class ApiErrorDto {
+    code: number;
+    type: string;
+    message: string;
+    stack: string;
+    loggingSeverity: LoggingSeverityEnum;
+}
+declare class ErrorDetailDto {
+    type: string;
+    value: any;
+}
+declare enum LoggingSeverityEnum {
+    information = 0,
+    warning = 1,
+    exception = 2
+}
+
+declare class ErrorServiceConfig {
+    private config?;
+    constructor(config?: ErrorServiceConfigDto);
+    set(config: ErrorServiceConfigDto): void;
+    get(): ErrorServiceConfigDto;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorServiceConfig, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorServiceConfig>;
+}
+declare class ErrorServiceConfigDto {
+    errorSink: boolean;
+    endpoint: string;
+    enabled: boolean;
+}
+declare const ErrorConfigToken: InjectionToken<ErrorServiceConfigDto>;
+
+declare class FrontAndBackendErrorHandler implements ErrorHandler {
+    private router;
+    private zone;
+    private http;
+    private config;
+    constructor(router: Router, zone: NgZone, http: HttpClient, config: ErrorServiceConfig);
+    handleError(originError: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FrontAndBackendErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FrontAndBackendErrorHandler>;
+}
+
+declare class ErrorServiceModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorServiceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ErrorServiceModule, never, [typeof i3.RouterModule, typeof i2$1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ErrorServiceModule>;
+}
+
+declare class GuideCollectionDto {
+    guides: GuideDto[];
+    active: GuideDto;
+}
+declare class GuideDto {
+    key: string;
+    name: string;
+    steps: GuideStepDto[];
+}
+declare class GuideStepDto {
+    key: string;
+    title: string;
+    body: string;
+    url: string;
+    completed: boolean;
+    media: GuideStepMediaDto[];
+}
+declare class GuideStepMediaDto {
+    type: GuideMediaTypeEnum;
+    sourceUrl: string;
+    clickUrl: string;
+}
+declare class GuideStateDto {
+    constructor();
+    activeGuideKey: string;
+    completedSteps: string[];
+}
+declare enum GuideMediaTypeEnum {
+    image = "Image",
+    video = "Video"
+}
+
+declare class ImageSliderComponent {
+    private intervalId;
+    index: number;
+    maxIndex: number;
+    total: number;
+    items: GuideStepMediaDto[];
+    ngOnInit(): void;
+    ngAfterContentChecked(): void;
+    private nextImage;
+    select(index: number): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageSliderComponent, "imageslider", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface IGuideState extends IViewState {
+    guides: GuideCollectionDto;
+}
+
+declare const GuidesConfigToken: InjectionToken<GuideConfigDto>;
+declare class GuidesClientConfig {
+    private config?;
+    constructor(config?: GuideConfigDto);
+    set(config: GuideConfigDto): void;
+    get(): GuideConfigDto;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuidesClientConfig, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GuidesClientConfig>;
+}
+declare class GuideConfigDto {
+    autoOpen: boolean;
+}
+
+interface IGuideStateService {
+    activeGuideUpdated: BehaviorSubject<GuideDto>;
+    dismiss(): Promise<void>;
+    startGuide(guide: GuideDto): Promise<void>;
+    stepToggle(stepKey: string): Promise<void>;
+}
+
+declare const GUIDESTATE_PROVIDER: InjectionToken<IGuideStateService>;
+declare class GuidePopupService {
+    private state;
+    private dialog;
+    private guideStateService;
+    private config;
+    showResumeGuideOption: BehaviorSubject<boolean>;
+    private activeGuide;
+    private guides;
+    private alreadyOpened;
+    constructor(state: ViewModelStateBase<IGuideState>, dialog: MatDialog, guideStateService: IGuideStateService, config: GuidesClientConfig);
+    startGuide<T>(dialogComponent: ComponentType<T>, guide: GuideDto): Promise<void>;
+    startGuideByKey<T>(dialogComponent: ComponentType<T>, guideKey: string): Promise<void>;
+    stepToggle(step: GuideStepDto): Promise<void>;
+    open<T>(dialogComponent: ComponentType<T>): void;
+    resumeGuide<T>(dialogComponent: ComponentType<T>): void;
+    closeWithResume(): Promise<void>;
+    dismiss(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuidePopupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GuidePopupService>;
+}
+
+declare class ResumeGuideHoverComponent extends ComponentWithViewStateBase<IGuideState> {
+    private state;
+    private guidePopupService;
+    private guideDialog;
+    protected snackBar: MatSnackBar;
+    private dialog;
+    showResumeGuide: boolean;
+    constructor(state: ViewModelStateBase<IGuideState>, guidePopupService: GuidePopupService, guideDialog: ComponentType<any>, snackBar: MatSnackBar, dialog: MatDialog);
+    protected onDataUpdate(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResumeGuideHoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResumeGuideHoverComponent, "resumeguidehover", never, {}, {}, never, never, false, never>;
+}
+
+declare class DialogGuideComponent extends ComponentWithViewStateBase<IGuideState> {
+    private state;
+    guidePopupService: GuidePopupService;
+    private guideStateService;
+    private guidesDialog;
+    protected snackBar: MatSnackBar;
+    private dialog;
+    smallScreen: boolean;
+    activeStep: GuideStepDto;
+    guide: GuideDto;
+    constructor(state: ViewModelStateBase<IGuideState>, guidePopupService: GuidePopupService, guideStateService: IGuideStateService, guidesDialog: ComponentType<any>, snackBar: MatSnackBar, dialog: MatDialog);
+    ngOnInit(): void;
+    toGuides(): Promise<void>;
+    dismiss(): Promise<void>;
+    handleCheckChange(item: GuideStepDto, checked: boolean): Promise<void>;
+    next(item: GuideStepDto): Promise<void>;
+    complete(item: GuideStepDto): Promise<void>;
+    showSteps(): boolean;
+    select(item: GuideStepDto): void;
+    isLastStep(item: GuideStepDto): boolean;
+    private selectNextOpenItem;
+    protected onDataUpdate(data: IGuideState): void;
+    onWindowResize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogGuideComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogGuideComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+declare class OpenGuideDialogDirective {
+    private dialog;
+    private guidePopupService;
+    private guideDialog;
+    constructor(dialog: MatDialog, guidePopupService: GuidePopupService, guideDialog: ComponentType<any>);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenGuideDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenGuideDialogDirective, "[guideDialog]", never, {}, {}, never, never, false, never>;
+}
+declare const DIALOG_GUIDE_TOKEN: InjectionToken<ComponentType<any>>;
+
+declare class DialogGuidesComponent extends ComponentWithViewStateBase<IGuideState> {
+    private state;
+    guidePopupService: GuidePopupService;
+    private guideStateService;
+    private guideDialog;
+    dialog: MatDialog;
+    protected snackBar: MatSnackBar;
+    guides: GuideDto[];
+    activeGuideKey: string;
+    private subscription;
+    constructor(state: ViewModelStateBase<IGuideState>, guidePopupService: GuidePopupService, guideStateService: IGuideStateService, guideDialog: ComponentType<any>, dialog: MatDialog, snackBar: MatSnackBar);
+    ngOnInit(): void;
+    setActiveGuide(guide: GuideDto): Promise<void>;
+    protected onDataUpdate(data: IGuideState): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogGuidesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogGuidesComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+declare class OpenGuidesDialogDirective {
+    private dialog;
+    private guidesDialog;
+    constructor(dialog: MatDialog, guidesDialog: ComponentType<any>);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenGuidesDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenGuidesDialogDirective, "[guidesDialog]", never, {}, {}, never, never, false, never>;
+}
+declare const DIALOG_GUIDES_TOKEN: InjectionToken<ComponentType<any>>;
+
+declare class StartGuideDirective {
+    private guidePopupService;
+    guideKey: string;
+    constructor(guidePopupService: GuidePopupService);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StartGuideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StartGuideDirective, "[startGuide]", never, { "guideKey": { "alias": "guideKey"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GuidesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuidesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GuidesModule, [typeof StartGuideDirective, typeof OpenGuideDialogDirective, typeof OpenGuidesDialogDirective, typeof DialogGuidesComponent, typeof ResumeGuideHoverComponent, typeof DialogGuideComponent, typeof ImageSliderComponent], [typeof i2$2.MatDialogModule, typeof i3.RouterModule, typeof i3$1.FormsModule, typeof i2$1.CommonModule, typeof BrandingModule, typeof CheckboxModule, typeof i9.StorageServiceModule], [typeof StartGuideDirective, typeof OpenGuideDialogDirective, typeof OpenGuidesDialogDirective, typeof DialogGuidesComponent, typeof ResumeGuideHoverComponent, typeof DialogGuideComponent, typeof ImageSliderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GuidesModule>;
+}
+
+declare class GuideStateInBackEndService implements IGuideStateService {
+    private http;
+    private config;
+    private state;
+    activeGuideUpdated: BehaviorSubject<GuideDto>;
+    private guideState;
+    constructor(http: HttpClient, config: ApiConfig, state: ViewModelStateBase<IGuideState>);
+    dismiss(): Promise<void>;
+    startGuide(guide: GuideDto): Promise<void>;
+    stepToggle(stepKey: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuideStateInBackEndService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GuideStateInBackEndService>;
+}
+
+declare class GuideStateInBrowserService implements IGuideStateService {
+    private storage;
+    private state;
+    activeGuideUpdated: BehaviorSubject<GuideDto>;
+    private guideState;
+    constructor(storage: StorageService, state: ViewModelStateBase<IGuideState>);
+    dismiss(): Promise<void>;
+    startGuide(guide: GuideDto): Promise<void>;
+    stepToggle(stepKey: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuideStateInBrowserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GuideStateInBrowserService>;
+}
+
+declare class CallbackPipe implements PipeTransform {
+    transform<T>(items: any[], callback: (item: T) => boolean): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<CallbackPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CallbackPipe, "callback", false>;
+}
+
+declare class CallbackPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CallbackPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CallbackPipeModule, [typeof CallbackPipe], never, [typeof CallbackPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CallbackPipeModule>;
+}
+
+declare class DateRangePipe implements PipeTransform {
+    private datePipe;
+    constructor(datePipe: DatePipe);
+    transform(dateRange: DateRangeDto): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateRangePipe, "dateRange", false>;
+}
+
+declare class DateRangePipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangePipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DateRangePipeModule, [typeof DateRangePipe], never, [typeof DateRangePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DateRangePipeModule>;
+}
+
+declare class SegmentNamePipe implements PipeTransform {
+    constructor();
+    transform(segment: SegmentEnum): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentNamePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SegmentNamePipe, "segmentName", false>;
+}
+
+declare class SegmentNamePipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentNamePipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SegmentNamePipeModule, [typeof SegmentNamePipe], never, [typeof SegmentNamePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SegmentNamePipeModule>;
+}
+
+declare class TruncatePipe implements PipeTransform {
+    transform(value: string, limit?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TruncatePipe, "truncate", false>;
+}
+
+declare class TruncatePipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatePipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TruncatePipeModule, [typeof TruncatePipe], never, [typeof TruncatePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TruncatePipeModule>;
+}
+
+declare class AgeIndicatorComponent implements OnInit {
+    lastMeasured: Date;
+    lastMeasuredMonths: number;
+    lastMeasuredOpacity: number;
+    lastMeasuredTooltip: string;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AgeIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AgeIndicatorComponent, "age-indicator", never, { "lastMeasured": { "alias": "lastMeasured"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ArrowComponent implements OnInit, DoCheck {
+    private elem;
+    from: string;
+    to: string;
+    head: boolean;
+    tail: boolean;
+    text: string;
+    toolTip: string;
+    color: string;
+    width: number;
+    onlyVisible: boolean;
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+    arrowIndices: number[];
+    styleLine: object[];
+    styleArrowFw: object[];
+    styleArrowBw: object[];
+    needSwap: boolean[];
+    private elementPositionBackup;
+    constructor(elem: ElementRef);
+    private getNumberOrDef;
+    private isVisible;
+    private inside;
+    private intersectionPoint;
+    private adjustLine;
+    private adjustLines;
+    private getFromToPairs;
+    private trackPositionChange;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArrowComponent, "arrow", never, { "from": { "alias": "from"; "required": false; }; "to": { "alias": "to"; "required": false; }; "head": { "alias": "head"; "required": false; }; "tail": { "alias": "tail"; "required": false; }; "text": { "alias": "text"; "required": false; }; "toolTip": { "alias": "toolTip"; "required": false; }; "color": { "alias": "color"; "required": false; }; "width": { "alias": "width"; "required": false; }; "onlyVisible": { "alias": "onlyVisible"; "required": false; }; "fromX": { "alias": "fromX"; "required": false; }; "fromY": { "alias": "fromY"; "required": false; }; "toX": { "alias": "toX"; "required": false; }; "toY": { "alias": "toY"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BadgeProgressionComponent {
+    showName: boolean;
+    badge: BadgeDto;
+    radius: number;
+    constructor();
+    badgeType(): BadgeTypeEnum;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeProgressionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeProgressionComponent, "badge-progression", never, { "showName": { "alias": "showName"; "required": false; }; "badge": { "alias": "badge"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BadgeStreakComponent {
+    showName: boolean;
+    badge: BadgeDto;
+    radius: number;
+    constructor();
+    getStreakBadgeType(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeStreakComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeStreakComponent, "badge-streak", never, { "showName": { "alias": "showName"; "required": false; }; "badge": { "alias": "badge"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BadgeComponent {
+    showName: boolean;
+    badge: BadgeDto;
+    radius: number;
+    constructor();
+    isStreakBadge(): boolean;
+    isProgressionBadge(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeComponent, "badge", never, { "showName": { "alias": "showName"; "required": false; }; "badge": { "alias": "badge"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BadgesComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    loaded: boolean;
+    showNotearned: boolean;
+    earnedStreakBadges: BadgeDto[];
+    earnedProgressionBadges: BadgeDto[];
+    unearnedProgressionBadges: BadgeDto[];
+    unearnedStreakBadges: BadgeDto[];
+    constructor(state: ViewModelStateBase<IResultsState>, snackBar: MatSnackBar);
+    calculateBadgeProgress(badge: BadgeDto): number;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BadgesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BadgesComponent, "badges", never, {}, {}, never, never, false, never>;
+}
+
+declare class BenchmarkIndicatorComponent {
+    delta: number;
+    benchmarkAvailable: boolean;
+    factorScore: FactorScoreDto;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BenchmarkIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BenchmarkIndicatorComponent, "benchmark-indicator", never, { "factorScore": { "alias": "factorScore"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DeltaArrowComponent {
+    private datePipe;
+    deltaDateRangeFrom: string;
+    deltaDateRangeTo: string;
+    available: boolean;
+    comparedTo: string;
+    factorScore: FactorScoreDto;
+    delta: FactorScoreCollectionDeltaDto;
+    noDataIndicator: boolean;
+    constructor(datePipe: DatePipe);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeltaArrowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DeltaArrowComponent, "delta-arrow", never, { "factorScore": { "alias": "factorScore"; "required": false; }; "delta": { "alias": "delta"; "required": false; }; "noDataIndicator": { "alias": "noDataIndicator"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DoItYourselfComponent {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DoItYourselfComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DoItYourselfComponent, "doityourself", never, {}, {}, never, never, false, never>;
+}
+
+declare class DoItYourselfWorkshopsComponent extends ComponentWithViewStateBase<IActionState> {
+    protected snackBar: MatSnackBar;
+    private state;
+    factorScore: FactorScoreDto;
+    resources: FeedbackResourceDto[];
+    InterventionTypeEnum: typeof InterventionTypeEnum;
+    InterventionStateEnum: typeof InterventionStateEnum;
+    InterventionOwnerEnum: typeof InterventionOwnerEnum;
+    private baseUrl;
+    constructor(snackBar: MatSnackBar, state: ViewModelStateBase<IResultsState>);
+    protected onDataUpdate(data: IResultsState): void;
+    getResourceUrl(item: FeedbackResourceDto): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DoItYourselfWorkshopsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DoItYourselfWorkshopsComponent, "doityourselfworkshops", never, { "factorScore": { "alias": "factorScore"; "required": false; }; "resources": { "alias": "resources"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class FactorAxisComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    private dialog;
+    protected snackBar: MatSnackBar;
+    dimensionSelector: FactorStructureDto;
+    showIndividualScore: boolean;
+    showTeamRange: boolean;
+    expandLowerDimensions: boolean;
+    participantKey: string;
+    snapshotKey: string;
+    showBenchmark: boolean;
+    loaded: boolean;
+    subscribed: boolean;
+    benchmarkScore: number;
+    benchmarkLowerQuartile: number;
+    benchmarkUpperQuartile: number;
+    snapshotScore: number;
+    participantScore: number;
+    type: ContextTypes;
+    segments: PointDto[];
+    feedbackAvailable: boolean;
+    dataAvailable: boolean;
+    anonymized: boolean;
+    notes: string[];
+    name: string;
+    baseUrl: string;
+    factorScore: FactorScoreDto;
+    delta: FactorScoreCollectionDeltaDto;
+    constructor(state: ViewModelStateBase<ITeamReportResultsState>, dialog: MatDialog, snackBar: MatSnackBar);
+    protected onDataUpdate(data: ITeamReportResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FactorAxisComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FactorAxisComponent, "factor-axis", never, { "dimensionSelector": { "alias": "dimensionSelector"; "required": false; }; "showIndividualScore": { "alias": "showIndividualScore"; "required": false; }; "showTeamRange": { "alias": "showTeamRange"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class FactorsComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    populationSegments: FactorScoreCollectionCompositionSegmentDto[];
+    benchmarkName: string;
+    showIndividualScore: boolean;
+    showTeamRange: boolean;
+    factors: FactorStructureDto[];
+    loaded: boolean;
+    showParticipant: boolean;
+    subscribed: boolean;
+    type: ContextTypes;
+    moreparticipantsneeded: boolean;
+    globalNotes: string[];
+    constructor(state: ViewModelStateBase<IResultsState>, snackBar: MatSnackBar);
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FactorsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FactorsComponent, "factors", never, {}, {}, never, never, false, never>;
+}
+
+declare class FilterTagsComponent {
+    protected userSettings: IUserSettingStrategy;
+    tags: string[];
+    constructor(userSettings: IUserSettingStrategy);
+    filterByTag(tag: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterTagsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterTagsComponent, "filter-tags", never, { "tags": { "alias": "tags"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class FocusAreasComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    limit: number;
+    focusAreas: FactorScoreDto[];
+    count: number;
+    baseUrl: string;
+    constructor(state: ViewModelStateBase<IResultsState>, snackBar: MatSnackBar);
+    protected onDataUpdate(data: IResultsState): void;
+    getCoreFactor(item: FactorScoreDto): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusAreasComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FocusAreasComponent, "focusareas", never, { "limit": { "alias": "limit"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class FooterComponent extends ComponentWithViewStateBase<IViewState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    branding: BrandingSettingsDto;
+    constructor(state: ViewModelStateBase<IViewState>, snackBar: MatSnackBar);
+    protected onDataUpdate(data: IViewState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FooterComponent, "liberators-footer", never, {}, {}, never, never, false, never>;
+}
+
+declare class ImpactIndicatorComponent {
+    private datePipe;
+    factorScore: FactorScoreDto;
+    constructor(datePipe: DatePipe);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpactIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImpactIndicatorComponent, "impact-indicator", never, { "factorScore": { "alias": "factorScore"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class LimitationsApplyComponent {
+    notes: string[];
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LimitationsApplyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LimitationsApplyComponent, "limitationsapply", never, { "notes": { "alias": "notes"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ModelFactorBreakdownComponent implements OnInit {
+    factor: {
+        points: any[];
+        name?: string;
+    };
+    pageSize: number;
+    currentPage: number;
+    pageCount: number;
+    pagedPoints: any[];
+    points: PointDto[];
+    ngOnInit(): Promise<void>;
+    updatePaging(): void;
+    showPage(page: number): void;
+    nextPage(): void;
+    prevPage(): void;
+    hasNext(): boolean;
+    hasPrev(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelFactorBreakdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelFactorBreakdownComponent, "model-factor-breakdown", never, { "factor": { "alias": "factor"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ModelFactorComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    private userSettingsService;
+    protected snackBar: MatSnackBar;
+    dimension: FactorStructureDto;
+    factorExtraClass: string;
+    currentFactor: FactorScoreDto;
+    filter: ModelFilter;
+    direction: string;
+    factorScore: FactorScoreDto;
+    benchmarkScore: number;
+    dimensionKey: string;
+    subDimensions: FactorStructureDto[];
+    benchmark: string;
+    showBenchmark: boolean;
+    description: string;
+    notes: string[];
+    confidenceAvailable: boolean;
+    teamKey: string;
+    effects: EffectDto[];
+    points: PointDto[];
+    openInterventions: number;
+    completedInterventions: number;
+    dataAvailable: boolean;
+    score: number;
+    factorScoreWidth: number;
+    factorScoreLeft: number;
+    feedbackAvailable: boolean;
+    delta: FactorScoreCollectionDeltaDto;
+    dateRange: DateRangeDto;
+    impededInterventions: number;
+    name: string;
+    baseUrl: string;
+    private subscription;
+    InterventionStateEnum: typeof InterventionStateEnum;
+    breakdownPage: number;
+    lastMeasuredDots: Array<number>;
+    lastMeasuredOpacity: number;
+    lastMeasuredTooltip: string;
+    constructor(state: ViewModelStateBase<IResultsState>, userSettingsService: UserSettingService, snackBar: MatSnackBar);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelFactorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelFactorComponent, "model-factor", never, { "dimension": { "alias": "dimension"; "required": false; }; "factorExtraClass": { "alias": "factorExtraClass"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ModelSwitcherComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    modelDefinition: ModelDefinitionDto;
+    canSwitchModels: boolean;
+    constructor(state: ViewModelStateBase<IResultsState>, snackBar: MatSnackBar);
+    ngOnInit(): void;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelSwitcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelSwitcherComponent, "model-switcher", never, {}, {}, never, never, false, never>;
+}
+
+declare class ModelComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    private dialog;
+    protected snackBar: MatSnackBar;
+    factors: FactorStructureDto[];
+    showSubFactorArrows: boolean;
+    showModel: boolean;
+    dateRange: DateRangeDto;
+    deltaDateRange: DateRangeDto;
+    coreEffects: EffectDto[];
+    pointCount: number;
+    benchmark: string;
+    pointNames: string;
+    pointType: string;
+    deltaTeams: number;
+    deltaTeamNames: string;
+    deltaAvailable: boolean;
+    isLoggedIn: boolean;
+    canSwitchModels: boolean;
+    modelDefinition: ModelDefinitionDto;
+    qualifiedBy: QualifiedByEnum;
+    deltaType: DeltaPeriodEnum;
+    isSubscriber: boolean;
+    QualifiedByEnum: typeof QualifiedByEnum;
+    globalNotes: string[];
+    constructor(state: ViewModelStateBase<IResultsState>, dialog: MatDialog, snackBar: MatSnackBar);
+    ngOnInit(): void;
+    private determineScreenSize;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelComponent, "model", never, {}, {}, never, never, false, never>;
+}
+
+declare class NavButtonComponent implements OnInit, OnDestroy {
+    private router;
+    private brandingProvider;
+    hover: boolean;
+    active: boolean;
+    accentColor: string;
+    private paletteItems;
+    private subscription;
+    routerLink: string[];
+    url: string;
+    icon: string;
+    name: string;
+    alertCount: number;
+    backgroundColor: string;
+    color: string;
+    mouseover(eventData: Event): void;
+    mouseleave(eventData: Event): void;
+    constructor(router: Router, brandingProvider: BrandingProvider);
+    private isUrlSame;
+    ngOnInit(): void;
+    private setColor;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavButtonComponent, "nav-button", never, { "routerLink": { "alias": "routerLink"; "required": false; }; "url": { "alias": "url"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "name": { "alias": "name"; "required": false; }; "alertCount": { "alias": "alertCount"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ParticipantsComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    private clipboard;
+    teamInviteUrl: string;
+    supporterInviteUrl: string;
+    stakeholderInviteUrl: string;
+    stakeholderUrlCopied: boolean;
+    teamUrlCopied: boolean;
+    supporterUrlCopied: boolean;
+    population: number;
+    participationRate: number;
+    invitationGoal: number;
+    closed: Date;
+    populationSegments: FactorScoreCollectionCompositionSegmentDto[];
+    constructor(state: ViewModelStateBase<ITeamReportResultsState>, snackBar: MatSnackBar, clipboard: Clipboard);
+    copyTeamInviteLink(): void;
+    copyStakeholderInviteLink(): void;
+    copySupporterInviteLink(): void;
+    segmentName(type: string): string;
+    protected onDataUpdate(data: ITeamReportResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParticipantsComponent, "participants", never, {}, {}, never, never, false, never>;
+}
+
+declare class QuickTipsComponent extends ComponentWithViewStateBase<IActionState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    quickTip: FeedbackQuickTipDto;
+    dimensionKey: string;
+    extraClass: string;
+    InterventionTypeEnum: typeof InterventionTypeEnum;
+    InterventionStateEnum: typeof InterventionStateEnum;
+    InterventionOwnerEnum: typeof InterventionOwnerEnum;
+    quickTips: FeedbackQuickTipDto[];
+    tipIndex: number;
+    tipCount: number;
+    stateSubscription: Subscription;
+    constructor(state: ViewModelStateBase<IResultsState>, snackBar: MatSnackBar);
+    nextTip(): void;
+    previousTip(): void;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuickTipsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuickTipsComponent, "quicktips", never, { "dimensionKey": { "alias": "dimensionKey"; "required": false; }; "extraClass": { "alias": "extraClass"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RecommendationComponent extends ComponentWithViewStateBase<IActionState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    private router;
+    item: FactorScoreDto;
+    howToImproveExpanded: boolean;
+    researchExpanded: boolean;
+    recommendations: FactorScoreDto[];
+    resources: FeedbackResourceDto[];
+    index: number;
+    definition: string;
+    influences: FactorEffectDto[];
+    predictors: FactorEffectDto[];
+    delta: FactorScoreCollectionDeltaDto;
+    qualifiedBy: QualifiedByEnum;
+    model: ModelStructureDto;
+    benchmarkAvailable: boolean;
+    constructor(state: ViewModelStateBase<IResultsState>, snackBar: MatSnackBar, router: Router);
+    ngOnInit(): void;
+    getFactor(factorKey: string): FactorStructureDto;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecommendationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RecommendationComponent, "recommendation", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RecommendationsComponent extends ComponentWithViewStateBase<IActionState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    private router;
+    limit: number;
+    skip: number;
+    recommendations: FactorScoreDto[];
+    expanded: number;
+    factors: ModelStructureDto;
+    factorsCollection: FactorScoreCollectionDto;
+    deltaDateRange: DateRangeDto;
+    constructor(state: ViewModelStateBase<IResultsState>, snackBar: MatSnackBar, router: Router);
+    protected onDataUpdate(data: IResultsState): void;
+    private scroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecommendationsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RecommendationsComponent, "recommendations", never, { "limit": { "alias": "limit"; "required": false; }; "skip": { "alias": "skip"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ResearchComponent {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResearchComponent, "research", never, {}, {}, never, never, false, never>;
+}
+
+declare class ResultIndicatorComponent {
+    qualification: string;
+    result: number;
+    factorScore: FactorScoreDto;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResultIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResultIndicatorComponent, "result-indicator", never, { "factorScore": { "alias": "factorScore"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RoadmapComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    show: boolean;
+    subscribeUrl: string;
+    constructor(state: ViewModelStateBase<IResultsState>, snackBar: MatSnackBar);
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoadmapComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RoadmapComponent, "roadmap", never, {}, {}, never, never, false, never>;
+}
+
+declare class TeamEffectivenessComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    score: number;
+    benchmarkScore: number;
+    benchmarkUpperQuartile: number;
+    qualification: string;
+    showTeamScore: boolean;
+    private teamEffectivenessKey;
+    constructor(state: ViewModelStateBase<ITeamReportResultsState>, snackBar: MatSnackBar);
+    protected onDataUpdate(data: ITeamReportResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TeamEffectivenessComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TeamEffectivenessComponent, "teameffectiveness", never, {}, {}, never, never, false, never>;
+}
+
+declare class TermsService {
+    private http;
+    private config;
+    private baseUrl;
+    constructor(http: HttpClient, config: ApiConfig);
+    accept(): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TermsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TermsService>;
+}
+
+declare class TermsUpdatedComponent extends ComponentWithViewStateBase<IResultsState> {
+    private termsService;
+    protected state: ViewModelStateBase<IResultsState>;
+    protected snackBar: MatSnackBar;
+    legal: LegalDto;
+    termsUpdated: boolean;
+    sending: boolean;
+    constructor(termsService: TermsService, state: ViewModelStateBase<IResultsState>, snackBar: MatSnackBar);
+    accept(): Promise<void>;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TermsUpdatedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TermsUpdatedComponent, "termsupdated", never, {}, {}, never, never, false, never>;
+}
+
+declare class TipBadgeComponent extends ComponentWithViewStateBase<IResultsState> {
+    protected state: ViewModelStateBase<ITeamReportResultsState>;
+    protected snackBar: MatSnackBar;
+    dimension: string;
+    label: string;
+    key: string;
+    feedbackKey: string;
+    impact: number;
+    class: string;
+    subscribed: boolean;
+    baseUrl: string;
+    constructor(state: ViewModelStateBase<ITeamReportResultsState>, snackBar: MatSnackBar);
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TipBadgeComponent, "tip-badge", never, { "dimension": { "alias": "dimension"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class FactorService {
+    toSelectList(model: ModelStructureDto): SelectItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FactorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FactorService>;
+}
+
+declare class TrendDataSetDto {
+    name: string;
+    variables: VariableDto[];
+    generatorNotes: string[];
+}
+declare class VariableDto {
+    name: string;
+    color: string;
+    series: MeasurementDto[];
+}
+declare class MeasurementDto {
+    name: string;
+    value: number;
+    min: number;
+    max: number;
+}
+
+declare class TrendDataRequestDto {
+    type: string;
+    teamKey: string;
+    clientKey: string;
+    teamKeys: string[];
+    clientKeys: string[];
+    includeSpread: boolean;
+    dateRange: DateRangeDto;
+    factorKeys: string[];
+    periodGrouping: DeltaPeriodEnum;
+    includeActions: IncludeActionsModeEnum;
+}
+
+declare class TrendService {
+    private http;
+    private config;
+    private baseUrl;
+    constructor(http: HttpClient, config: ApiConfig);
+    team(request: TrendDataRequestDto): rxjs.Observable<TrendDataSetDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrendService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TrendService>;
+}
+
+declare class TrendsComponent extends ComponentWithViewStateBase<IResultsState> {
+    private formBuilder;
+    protected snackBar: MatSnackBar;
+    private factorService;
+    private trendService;
+    protected route: ActivatedRoute;
+    private state;
+    units: SelectItem[];
+    unitType: string;
+    chartContainer: ElementRef<HTMLDivElement>;
+    factors: SelectItem[];
+    data: any[];
+    generatorNotes: string[];
+    loading: boolean;
+    form: UntypedFormGroup;
+    view: [number, number];
+    legendPosition: LegendPosition;
+    customColors: any[];
+    periodGroupings: SelectItem[];
+    includeActionOptions: SelectItem[];
+    constructor(formBuilder: UntypedFormBuilder, snackBar: MatSnackBar, factorService: FactorService, trendService: TrendService, route: ActivatedRoute, state: ViewModelStateBase<IResultsState>);
+    ngOnInit(): void;
+    onFormSubmit(): void;
+    onResize(): void;
+    private createForm;
+    compareFactorOptions(o1: SelectItem, o2: SelectItem): boolean;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrendsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TrendsComponent, "trends", never, { "units": { "alias": "units"; "required": false; }; "unitType": { "alias": "unitType"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TryNowProfessionalComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    show: boolean;
+    subscribeUrl: string;
+    constructor(state: ViewModelStateBase<ITeamReportResultsState>, snackBar: MatSnackBar);
+    protected onDataUpdate(data: ITeamReportResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TryNowProfessionalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TryNowProfessionalComponent, "trynow-professional", never, {}, {}, never, never, false, never>;
+}
+
+declare class UpdateInProgressComponent extends ComponentWithViewStateBase<IResultsState> {
+    protected state: ViewModelStateBase<ITeamReportResultsState>;
+    protected snackBar: MatSnackBar;
+    delayedReloading: boolean;
+    private subscription;
+    constructor(state: ViewModelStateBase<ITeamReportResultsState>, snackBar: MatSnackBar);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateInProgressComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UpdateInProgressComponent, "update-in-progress", never, {}, {}, never, never, false, never>;
+}
+
+declare class UserProfileService {
+    private http;
+    private config;
+    private baseUrl;
+    constructor(http: HttpClient, config: ApiConfig);
+    update(userProfile: UserProfileDto): Observable<any>;
+    setAvatar(file: File): Observable<any>;
+    clearAvatar(): Observable<any>;
+    sendMFAEnrollment(): Observable<any>;
+    resetMFAEnrollment(): Observable<any>;
+    createAPITokens(): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserProfileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserProfileService>;
+}
+
+declare class AccountService {
+    private http;
+    private config;
+    private baseUrl;
+    constructor(http: HttpClient, config: ApiConfig);
+    sendResetPassword(email: string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccountService>;
+}
+
+declare class UserProfileComponent extends ComponentWithViewStateBase<IResultsState> {
+    protected state: ViewModelStateBase<IResultsState>;
+    private authService;
+    private userProfileService;
+    private accountService;
+    private formBuilder;
+    protected snackbar: MatSnackBar;
+    protected route: ActivatedRoute;
+    form: UntypedFormGroup;
+    loading: boolean;
+    userProfile: UserProfileDto;
+    changeAvatar: boolean;
+    color: string;
+    email: string;
+    usesMFA: boolean;
+    allowMFA: boolean;
+    allowPasswordChange: boolean;
+    showEmailInput: boolean;
+    allowAPI: any;
+    constructor(state: ViewModelStateBase<IResultsState>, authService: AuthService, userProfileService: UserProfileService, accountService: AccountService, formBuilder: UntypedFormBuilder, snackbar: MatSnackBar, route: ActivatedRoute);
+    ngOnInit(): void;
+    private createForm;
+    onSubmit(formDirective: FormGroupDirective): Promise<void>;
+    setChangeEmail(): void;
+    uploadAvatar($fileInput: any): void;
+    clearAvatar(): void;
+    sendPasswordReset(): void;
+    sendMFAEnrollment(): void;
+    resetMFAEnrollment(): void;
+    createAPITokens(): void;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserProfileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserProfileComponent, "userprofile", never, {}, {}, never, never, false, never>;
+}
+
+declare class VideoComponent {
+    videoUrl: string;
+    videoTitle: string;
+    constructor();
+    ngOnInit(): void;
+    openVideo(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VideoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VideoComponent, "explainervideo", never, { "videoUrl": { "alias": "videoUrl"; "required": false; }; "videoTitle": { "alias": "videoTitle"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class WidgetFactorScoreComponent {
+    direction: string;
+    factorScore: FactorScoreDto;
+    factorScores: FactorScoreCollectionDto;
+    delta: FactorScoreCollectionDeltaDto;
+    benchmarkName: string;
+    factorScoreWidth: number;
+    score: number;
+    benchmark: number;
+    confidenceAvailable: boolean;
+    factorScoreLeft: number;
+    points: PointDto[];
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetFactorScoreComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetFactorScoreComponent, "widget-factorscore", never, { "factorScore": { "alias": "factorScore"; "required": false; }; "factorScores": { "alias": "factorScores"; "required": false; }; "delta": { "alias": "delta"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class WidgetParticipationRateComponent {
+    direction: string;
+    data: ParticipationRateDto;
+    factorScoreWidth: number;
+    percentage: number;
+    confidenceAvailable: boolean;
+    factorScoreLeft: number;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetParticipationRateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetParticipationRateComponent, "widget-participationrate", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ExportFactorScoresRequestDto {
+    constructor(modelKey: string);
+    modelKey: string;
+    periodGrouping: string;
+    dateRange: DateRangeDto;
+    benchmark: BenchmarkTypeEnum;
+}
+declare class ExportTeamListRequestDto {
+    constructor(modelKey: string);
+    modelKey: string;
+}
+
+declare class ExportService {
+    private http;
+    private config;
+    private baseUrl;
+    constructor(http: HttpClient, config: ApiConfig);
+    exportFactorScores(request: ExportFactorScoresRequestDto): Observable<any>;
+    exportTeamList(request: ExportTeamListRequestDto): Observable<any>;
+    exportParticipationRate(request: ExportTeamListRequestDto): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportService>;
+}
+
+declare class DialogExportFactorScoresComponent extends ComponentWithViewStateBase<IViewState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    private exportService;
+    private dialogRef;
+    private formBuilder;
+    form: FormGroup;
+    sending: boolean;
+    submitted: boolean;
+    modelKey: string;
+    periodGroupings: SelectItem[];
+    benchmarkTypes: SelectItem[];
+    constructor(state: ViewModelStateBase<IViewState>, snackBar: MatSnackBar, exportService: ExportService, dialogRef: MatDialogRef<DialogExportFactorScoresComponent>, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    submit(): Promise<void>;
+    protected onDataUpdate(data: IResultsState): void;
+    private createForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogExportFactorScoresComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogExportFactorScoresComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class OpenExportFactorScoresDialogDirective {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenExportFactorScoresDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenExportFactorScoresDialogDirective, "[exportFactorScoresDialog]", never, {}, {}, never, never, false, never>;
+}
+
+declare class DialogExportTeamListComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    protected snackBar: MatSnackBar;
+    protected userSettings: IUserSettingStrategy;
+    private exportService;
+    private dialogRef;
+    private formBuilder;
+    form: FormGroup;
+    sending: boolean;
+    modelKey: string;
+    constructor(state: ViewModelStateBase<IResultsState>, snackBar: MatSnackBar, userSettings: IUserSettingStrategy, exportService: ExportService, dialogRef: MatDialogRef<DialogExportTeamListComponent>, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    exportTeamSummaries(): Promise<void>;
+    exportParticipationRate(): Promise<void>;
+    protected onDataUpdate(data: IResultsState): void;
+    private createForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogExportTeamListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogExportTeamListComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class OpenExportTeamListDialogDirective {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenExportTeamListDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenExportTeamListDialogDirective, "[exportTeamListDialog]", never, {}, {}, never, never, false, never>;
+}
+
+declare class DialogModelFilterComponent extends ComponentWithViewStateBase<IResultsState> {
+    private state;
+    protected userSettings: IUserSettingStrategy;
+    protected snackBar: MatSnackBar;
+    private dialogRef;
+    private formBuilder;
+    form: UntypedFormGroup;
+    sending: boolean;
+    submitted: boolean;
+    models: ModelSummaryDto[];
+    constructor(state: ViewModelStateBase<IResultsState>, userSettings: IUserSettingStrategy, snackBar: MatSnackBar, dialogRef: MatDialogRef<DialogModelFilterComponent>, formBuilder: UntypedFormBuilder);
+    ngOnInit(): void;
+    submit(): Promise<void>;
+    private createForm;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogModelFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogModelFilterComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+declare class OpenModelFilterDialog {
+    private dialog;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenModelFilterDialog, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenModelFilterDialog, "[modelFilterDialog]", never, {}, {}, never, never, false, never>;
+}
+
+declare class DialogSettingsComponent extends ComponentWithViewStateBase<IResultsState> {
+    dialogRef: MatDialogRef<DialogSettingsComponent>;
+    private factorService;
+    private userSettingsService;
+    protected snackBar: MatSnackBar;
+    private formBuilder;
+    private state;
+    form: FormGroup;
+    sending: boolean;
+    private settings;
+    factors: SelectItem[];
+    isSingleTeam: boolean;
+    isSubscriber: boolean;
+    modelFilterSettings: ModelFilter;
+    customFactorsSelected: boolean;
+    benchmarkTypes: SelectItem[];
+    deltaPeriods: SelectItem[];
+    interventionFilterTypes: SelectItem[];
+    qualifyByTypes: SelectItem[];
+    constructor(dialogRef: MatDialogRef<DialogSettingsComponent>, factorService: FactorService, userSettingsService: UserSettingService, snackBar: MatSnackBar, formBuilder: FormBuilder, state: ViewModelStateBase<IResultsState>);
+    ngOnInit(): void;
+    submit(): void;
+    resetOverviewFactors(): void;
+    verifyOverviewFactors(): void;
+    private createForm;
+    protected onDataUpdate(data: IResultsState): void;
+    private arraysHaveSameElements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogSettingsComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+declare class OpenSettingsDialogDirective {
+    private dialog;
+    showSettingStacking: boolean;
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenSettingsDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenSettingsDialogDirective, "[settingsDialog]", never, { "showSettingStacking": { "alias": "showSettingStacking"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DialogTeamFilterComponent extends ComponentWithViewStateBase<IResultsState> {
+    tags: string[];
+    private state;
+    protected userSettings: IUserSettingStrategy;
+    protected snackBar: MatSnackBar;
+    private dialogRef;
+    private formBuilder;
+    form: UntypedFormGroup;
+    sending: boolean;
+    submitted: boolean;
+    filterSet: boolean;
+    constructor(tags: string[], state: ViewModelStateBase<IResultsState>, userSettings: IUserSettingStrategy, snackBar: MatSnackBar, dialogRef: MatDialogRef<DialogTeamFilterComponent>, formBuilder: UntypedFormBuilder);
+    ngOnInit(): void;
+    submit(): Promise<void>;
+    clear(): Promise<void>;
+    private createForm;
+    protected onDataUpdate(data: IResultsState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogTeamFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogTeamFilterComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class OpenTeamFilterDialogDirective {
+    private dialog;
+    tags: string[];
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenTeamFilterDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenTeamFilterDialogDirective, "[teamFilterDialog]", never, { "tags": { "alias": "tags"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class LocalUserDto {
+    avatarUrl: string;
+    publicKey: string;
+    email: string;
+    name: string;
+    isAdmin: boolean;
+    requireSSO: boolean;
+    requireMFA: boolean;
+    noRemoteAccount: boolean;
+    allowedTeamPublicKeys: string[];
+    allowedTeamNames: string[];
+}
+
+declare class UserListResponseDto {
+    users: PaginatedResponse<LocalUserDto>;
+    externalUsers: UserNameAndKeyDto[];
+}
+declare class UserNameAndKeyDto {
+    name: string;
+    publicKey: string;
+    avatarUrl: string;
+}
+
+declare class DialogNotesComponent {
+    notes: string[];
+    constructor(notes: string[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogNotesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogNotesComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+declare class OpenNotesDialogDirective {
+    private dialog;
+    notes: string[];
+    constructor(dialog: MatDialog);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenNotesDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenNotesDialogDirective, "[notesDialog]", never, { "notes": { "alias": "notes"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ResultsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResultsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ResultsModule, [typeof ArrowComponent, typeof DeltaArrowComponent, typeof BenchmarkIndicatorComponent, typeof ResultIndicatorComponent, typeof FocusAreasComponent, typeof ImpactIndicatorComponent, typeof AgeIndicatorComponent, typeof RoadmapComponent, typeof TryNowProfessionalComponent, typeof ModelComponent, typeof QuickTipsComponent, typeof ModelFactorComponent, typeof RecommendationComponent, typeof RecommendationsComponent, typeof ModelSwitcherComponent, typeof ResearchComponent, typeof DoItYourselfWorkshopsComponent, typeof DoItYourselfComponent, typeof ModelFactorBreakdownComponent, typeof FooterComponent, typeof DialogSettingsComponent, typeof NavButtonComponent, typeof TermsUpdatedComponent, typeof OpenSettingsDialogDirective, typeof WidgetFactorScoreComponent, typeof WidgetParticipationRateComponent, typeof TeamEffectivenessComponent, typeof DialogExportFactorScoresComponent, typeof OpenExportFactorScoresDialogDirective, typeof DialogExportTeamListComponent, typeof OpenExportTeamListDialogDirective, typeof DialogTeamFilterComponent, typeof OpenTeamFilterDialogDirective, typeof FactorAxisComponent, typeof TipBadgeComponent, typeof DialogNotesComponent, typeof FilterTagsComponent, typeof LimitationsApplyComponent, typeof OpenNotesDialogDirective, typeof FactorsComponent, typeof TrendsComponent, typeof BadgeComponent, typeof BadgesComponent, typeof BadgeStreakComponent, typeof UpdateInProgressComponent, typeof DialogModelFilterComponent, typeof OpenModelFilterDialog, typeof BadgeProgressionComponent, typeof ParticipantsComponent, typeof VideoComponent, typeof UserProfileComponent], [typeof i5.ClipboardModule, typeof i50.NgxChartsModule, typeof SlugifyPipeModule, typeof i2$2.MatDialogModule, typeof i12.MatTooltipModule, typeof i54.MatNativeDateModule, typeof i3.RouterModule, typeof i3$1.FormsModule, typeof i3$1.ReactiveFormsModule, typeof i54.MatOptionModule, typeof i6.MatInputModule, typeof i58.MatSlideToggleModule, typeof BrandingModule, typeof i2.MatSelectModule, typeof i61.MatProgressSpinnerModule, typeof i22.MatDatepickerModule, typeof DateRangePipeModule, typeof i64.SatPopoverModule, typeof ActionsModule, typeof i2$1.CommonModule, typeof DialogSupportModule, typeof DialogSubscribeModule, typeof ResourceDownloadModule, typeof LoadingModule, typeof FactorInformationDialogModule, typeof GuidesModule], [typeof ArrowComponent, typeof DeltaArrowComponent, typeof BenchmarkIndicatorComponent, typeof TryNowProfessionalComponent, typeof ResultIndicatorComponent, typeof AgeIndicatorComponent, typeof FocusAreasComponent, typeof ImpactIndicatorComponent, typeof VideoComponent, typeof ModelComponent, typeof QuickTipsComponent, typeof ModelFactorComponent, typeof RoadmapComponent, typeof TermsUpdatedComponent, typeof FooterComponent, typeof NavButtonComponent, typeof RecommendationComponent, typeof ModelSwitcherComponent, typeof RecommendationsComponent, typeof FilterTagsComponent, typeof DoItYourselfWorkshopsComponent, typeof ModelFactorBreakdownComponent, typeof ResearchComponent, typeof LimitationsApplyComponent, typeof DoItYourselfComponent, typeof DialogSettingsComponent, typeof OpenSettingsDialogDirective, typeof TeamEffectivenessComponent, typeof WidgetFactorScoreComponent, typeof WidgetParticipationRateComponent, typeof DialogExportFactorScoresComponent, typeof UpdateInProgressComponent, typeof OpenExportFactorScoresDialogDirective, typeof DialogExportTeamListComponent, typeof OpenExportTeamListDialogDirective, typeof OpenTeamFilterDialogDirective, typeof DialogModelFilterComponent, typeof OpenModelFilterDialog, typeof TipBadgeComponent, typeof FactorsComponent, typeof BadgesComponent, typeof DialogModelFilterComponent, typeof OpenModelFilterDialog, typeof TrendsComponent, typeof BadgeComponent, typeof BadgeProgressionComponent, typeof BadgeStreakComponent, typeof ParticipantsComponent, typeof UserProfileComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ResultsModule>;
+}
+
+declare class DismissPopupService {
+    private dismissedPopups;
+    constructor();
+    dismiss(key: string): void;
+    isDismissed(key: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DismissPopupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DismissPopupService>;
+}
+
+declare class ResultsClientConfig {
+    private config?;
+    constructor(config?: ResultsClientDto);
+    set(config: ResultsClientDto): void;
+    get(): ResultsClientDto;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResultsClientConfig, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResultsClientConfig>;
+}
+declare class ResultsClientDto {
+}
+declare const ResultsConfigToken: InjectionToken<ResultsClientDto>;
+
+declare function domainValidator(): ValidatorFn;
+
+declare function compareInputValidator(compare1: string, compare2: string): ValidatorFn;
+
+declare function maxSelectedValidator(maximum: number): ValidatorFn;
+
+declare class NoReloadStrategy implements IReloadStrategy {
+    reload: BehaviorSubject<boolean>;
+    constructor();
+    subscribe(): void;
+    isConnected(): boolean;
+    unsubscribe(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoReloadStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NoReloadStrategy>;
+}
+
+declare class SessionIdProvider {
+    sessionId: string;
+    constructor();
+    private randomString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionIdProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionIdProvider>;
+}
+
+declare class ReloadOnPushStrategy implements IReloadStrategy {
+    private zone;
+    private config;
+    private sessionIdProvider;
+    private baseUrl;
+    private eventSource;
+    private sessionId;
+    reload: BehaviorSubject<boolean>;
+    constructor(zone: NgZone, config: ApiConfig, sessionIdProvider: SessionIdProvider);
+    subscribe(): void;
+    isConnected(): boolean;
+    unsubscribe(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReloadOnPushStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReloadOnPushStrategy>;
+}
+
+declare class SessionIdInterceptor implements HttpInterceptor {
+    private config;
+    private sessionIdProvider;
+    private sessionId;
+    constructor(config: ApiConfig, sessionIdProvider: SessionIdProvider);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionIdInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionIdInterceptor>;
+}
+
+declare class ViewModelStateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewModelStateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ViewModelStateModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ViewModelStateModule>;
+}
+
+declare class ViewModelStateConfig {
+    private config?;
+    constructor(config?: ViewModelStateConfigDto);
+    set(config: ViewModelStateConfigDto): void;
+    get(): ViewModelStateConfigDto;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewModelStateConfig, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewModelStateConfig>;
+}
+declare class ViewModelStateConfigDto {
+}
+declare const ViewModelStateConfigToken: InjectionToken<ViewModelStateConfigDto>;
+
+export { AactionConfigToken, AccountService$1 as AccountService, ActionClientConfig, ActionCollectionDto, ActionConfigDto, ActionDto, ActionListComponent, ActionListFilter, ActionManageComponent, ActionOptionDto, ActionOptionsDto, ActionPrefillDto, ActionService, ActionTeamDto, ActionTileComponent, ActionsModule, AgeIndicatorComponent, AlertAnnouncementComponent, AlertClientConfig, AlertConfigDto, AlertConfigToken, AlertDto, AlertFilterDto, AlertResponseDto, AlertService, AlertsComponent, AlertsModule, ApiConfig, ApiConfigDto, ApiConfigToken, ApiErrorDto, ArrowComponent, BackButtonDirective, BackButtonDirectiveModule, BadgeCollectionDto, BadgeComponent, BadgeDto, BadgeProgressionComponent, BadgeStreakComponent, BadgeTypeEnum, BadgesComponent, BenchmarkIndicatorComponent, BenchmarkOptionDto, BenchmarkTypeEnum, BrandBackgroundDirective, BrandConditionalBackgroundColorDirective, BrandConditionalColorDirective, BrandHoverColorDirective, BrandingModule, BrandingProvider, BrandingSettingsDto, CallbackPipe, CallbackPipeModule, ChannelDefaultBrandingDto, ChannelDto, CheckboxComponent, CheckboxModule, ClickableTooltipDirective, ClientInfoDto, ComponentBase, ComponentWithViewStateBase, ContactService, ContentBrandingDto, ContextItemDto, ContextTypes, DIALOG_GUIDES_TOKEN, DIALOG_GUIDE_TOKEN, DateRangeDto, DateRangePipe, DateRangePipeModule, DefinitionDto, DeltaArrowComponent, DeltaPeriodEnum, DialogAccountComponent, DialogAccountModule, DialogActionFiltersComponent, DialogActionManageComponent, DialogAlertsComponent, DialogExportActionsComponent, DialogExportFactorScoresComponent, DialogExportTeamListComponent, DialogFactorInformationComponent, DialogGuideComponent, DialogGuidesComponent, DialogModelFilterComponent, DialogResourceDownloadComponent, DialogSettingsComponent, DialogSubscribeComponent, DialogSubscribeModule, DialogSupportComponent, DialogSupportModule, DialogTeamFilterComponent, DimensionResultDto, DismissAlertRequestDto, DismissPopupService, DismissedAlertsService, DoItYourselfComponent, DoItYourselfWorkshopsComponent, EffectDto, EffectTypeEnum, ErrorConfigToken, ErrorDetailDto, ErrorDto, ErrorServiceConfig, ErrorServiceConfigDto, ErrorServiceModule, ExpandComponent, ExpandItemDto, ExpandModule, ExportActionsRequestDto, ExportFactorScoresRequestDto, ExportTeamListRequestDto, FactorAxisComponent, FactorEffectDto, FactorInformationDialogModule, FactorRecommendationDto, FactorScoreCollectionBenchmarkDto, FactorScoreCollectionCompositionDto, FactorScoreCollectionCompositionSegmentDto, FactorScoreCollectionDeltaDto, FactorScoreCollectionDto, FactorScoreCollectionFiltersDto, FactorScoreCompositionPointDto, FactorScoreCompositionPointsDto, FactorScoreDto, FactorService, FactorStructureConstraintDto, FactorStructureDto, FactorStructureSegmentDto, FactorsComponent, FeedbackQuickTipDto, FeedbackResourceDto, FilterTagsComponent, FocusAreasComponent, FooterComponent, FrontAndBackendErrorHandler, GUIDESTATE_PROVIDER, GuardsModule, GuideCollectionDto, GuideConfigDto, GuideDto, GuideMediaTypeEnum, GuidePopupService, GuideSettingsDto, GuideStateDto, GuideStateInBackEndService, GuideStateInBrowserService, GuideStepDto, GuideStepMediaDto, GuidesClientConfig, GuidesConfigToken, GuidesModule, ImageSliderComponent, ImpactIndicatorComponent, IncludeActionsModeEnum, InterventionFilterType, InterventionOwnerEnum, InterventionOwnerToStringPipe, InterventionSortEnum, InterventionStateEnum, InterventionStateToStringPipe, InterventionSummaryDto, InterventionTypeEnum, InterventionTypeToStringPipe, InviteUrlDto, KeyValueDto, LegalDocumentDto, LegalDto, LimitationsApplyComponent, LoadModes, LoadingComponent, LoadingModule, LocalUserDto, LoggingSeverityEnum, MatTagsComponent, MatTagsModule, MeasurementDto, MetaDataInputComponent, MetadataInputModule, ModelComponent, ModelDefinitionDto, ModelDemoUrlDto, ModelFactorBreakdownComponent, ModelFactorComponent, ModelFilter, ModelStructureDto, ModelSummaryDto, ModelSwitcherComponent, MultiEmailInputComponent, MultiEmailInputModule, NavButtonComponent, NavigationUrlDto, NavigationUrlTypeEnum, NgAddToCalendarModule, NoReloadStrategy, OpenAccountDialogDirective, OpenActionFiltersDialogDirective, OpenAddActionDialogDirective, OpenAlertsDialogDirective, OpenContactSalesDialog, OpenEditActionDialogDirective, OpenExportActionsDialogDirective, OpenExportFactorScoresDialogDirective, OpenExportTeamListDialogDirective, OpenFactorInformationDialogDirective, OpenFeedbackDialogDirective, OpenGuideDialogDirective, OpenGuidesDialogDirective, OpenLookingForHelpDialog, OpenModelFilterDialog, OpenReportBugDialogDirective, OpenResourceDownloadDialogDirective, OpenSettingsDialogDirective, OpenSubscribeDialogDirective, OpenSupportDialogDirective, OpenTeamFilterDialogDirective, PaginatedResponse, PaginatorComponent, PaginatorModule, PaginatorPageEvent, PagingOptions, PaletteItem, ParticipantDto, ParticipantsComponent, ParticipationRateDto, PointDto, PointTypeEnum, ProcessingDataDto, QualificationEnum, QualifiedByEnum, QuantitySelectorComponent, QuantitySelectorModule, QuestionnaireTypeDto, QuickTipsComponent, RecommendationComponent, RecommendationsComponent, ReloadOnPushStrategy, ResearchComponent, ResetPasswordRequestDto, ResourceDownloadModule, ResourceDownloadRedirectUrlDto, ResourceDownloadService, ResultIndicatorComponent, ResultsClientConfig, ResultsClientDto, ResultsConfigToken, ResultsModule, ResumeGuideHoverComponent, RoadmapComponent, SegmentEnum, SegmentNamePipe, SegmentNamePipeModule, SelectItem, SelectListComponent, SelectListItem, SelectListItemApiDto, SelectListModule, SessionIdInterceptor, SessionIdProvider, SiteDefaultFooterComponent, SiteDefaultHeaderComponent, SiteMicroFooterComponent, SlugifyPipe, SlugifyPipeModule, SnapshotDto, SnapshotInviteUrlsComponent, SnapshotInviteUrlsModule, SnapshotMetaDataDto, StartGuideDirective, SubscriptionTierEnum, TabItemDto, TabNavigatorComponent, TabNavigatorModule, TeamDto, TeamEffectivenessComponent, TeamFlagMatchDto, TeamListFilter, TeamListResponseDto, TeamMetaDataDto, TeamNameAndKeyDto, TeamNotificationSettingsDto, TeamSortEnum, TeamStatusEnum, TeamTraitDto, TermsService, TermsUpdatedComponent, TipBadgeComponent, TopicSelectorComponent, TopicSelectorDto, TopicSelectorModule, TrendDataRequestDto, TrendDataSetDto, TrendService, TrendsComponent, TruncatePipe, TruncatePipeModule, TryNowProfessionalComponent, UpdateInProgressComponent, UserGlobalSettingsDto, UserInfoDto, UserListFilter, UserListResponseDto, UserNameAndKeyDto, UserProfileComponent, UserProfileDto, UserProfileService, UserSettingService, UserSettingsDto, UserSpecificSettingsDto, VIEWSTATE_LOAD_STRATEGY, VIEWSTATE_PROVIDER, VIEWSTATE_RELOAD_STRATEGY, VIEWSTATE_USERSETTINGS_STRATEGY, ValidChangeTokenGuard, ValidKeyGuard, ValidKeySnapshotKeyGuard, ValidKeyTeamKeyGuard, VariableDto, VideoComponent, ViewModelStateBase, ViewModelStateConfig, ViewModelStateConfigDto, ViewModelStateConfigToken, ViewModelStateModule, WidgetFactorScoreComponent, WidgetParticipationRateComponent, compareInputValidator, domainValidator, maxSelectedValidator, minTopicsSelectedValidator, presetCheckValidator };
+export type { ContactDto, ContactTypeDto, IActionState, IAggregateRootSource, IAggregateRootStreamFactory, IAlertState, IReloadStrategy, IResultsState, ITeamReportResultsState, IUserSettingStrategy, IViewState };