@deenruv/admin-ui 1.0.0

package/core/common/introspection-result-wrapper.d.ts

@@ -0,0 +1 @@
+export { default as introspectionResult } from './introspection-result';

package/core/common/introspection-result.d.ts

@@ -0,0 +1,7 @@
+export interface PossibleTypesResultData {
+    possibleTypes: {
+        [key: string]: string[];
+    };
+}
+declare const result: PossibleTypesResultData;
+export default result;

package/core/common/single-search-selection-model.d.ts

@@ -0,0 +1,16 @@
+import { NgOption, SelectionModel } from '@ng-select/ng-select';
+/**
+ * A custom SelectionModel for the NgSelect component which only allows a single
+ * search term at a time.
+ */
+export declare class SingleSearchSelectionModel implements SelectionModel {
+    private _selected;
+    get value(): NgOption[];
+    select(item: NgOption, multiple: boolean, groupAsModel: boolean): void;
+    unselect(item: NgOption, multiple: boolean): void;
+    clear(keepDisabled: boolean): void;
+    private _setChildrenSelectedState;
+    private _removeChildren;
+    private _removeParent;
+}
+export declare function SingleSearchSelectionModelFactory(): SingleSearchSelectionModel;

package/core/common/title-setter.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Creates a function that can be used to set the meta title of the current page.
+ */
+export declare function titleSetter(): (title: string) => void;

package/core/common/utilities/bulk-action-utils.d.ts

@@ -0,0 +1,49 @@
+import { Observable } from 'rxjs';
+import { DataService } from '../../data/providers/data.service';
+import { BulkAction } from '../../providers/bulk-action-registry/bulk-action-types';
+import { BaseListComponent } from '../base-list.component';
+import { DeletionResponse } from '../generated-types';
+/**
+ * @description
+ * Resolves to an object containing the Channel code of the given channelId, or if no channelId
+ * is supplied, the code of the activeChannel.
+ */
+export declare function getChannelCodeFromUserStatus(dataService: DataService, channelId?: string): Promise<{
+    channelCode: string;
+}>;
+/**
+ * @description
+ * Resolves to `true` if multiple Channels are set up.
+ */
+export declare function isMultiChannel(dataService: DataService): Promise<boolean>;
+/**
+ * @description
+ * Resolves to `true` if the current active Channel is not the default Channel.
+ */
+export declare function currentChannelIsNotDefault(dataService: DataService): Promise<boolean>;
+export type CreateBulkDeleteActionConfig<ItemType> = Pick<BulkAction, 'location' | 'requiresPermission'> & {
+    getItemName: (item: ItemType) => string;
+    shouldRetryItem?: (response: DeletionResponse, item: ItemType) => boolean;
+    bulkDelete: (dataService: DataService, ids: string[], retrying: boolean) => Observable<DeletionResponse[]>;
+};
+/**
+ * @description
+ * Creates a BulkAction which can be used to delete multiple items.
+ */
+export declare function createBulkDeleteAction<ItemType>(config: CreateBulkDeleteActionConfig<ItemType>): BulkAction<any, BaseListComponent<any, any, any>>;
+export type CreateBulkAssignToChannelActionConfig<ItemType> = Pick<BulkAction, 'location' | 'requiresPermission'> & {
+    getItemName: (item: ItemType) => string;
+    bulkAssignToChannel: (dataService: DataService, ids: string[], channelIds: string[]) => Array<Observable<Array<Partial<ItemType>>>>;
+};
+export declare function createBulkAssignToChannelAction<ItemType>(config: CreateBulkAssignToChannelActionConfig<ItemType>): BulkAction<any, BaseListComponent<any, any, any>>;
+export type CreateBulkRemoveFromChannelActionConfig<ItemType, RemoveResult = Partial<ItemType>> = Pick<BulkAction, 'location' | 'requiresPermission'> & {
+    getItemName: (item: ItemType) => string;
+    bulkRemoveFromChannel: (dataService: DataService, ids: string[], channelId: string, retrying: boolean) => Observable<RemoveResult[]>;
+    /**
+     * An optional test of whether the removal succeeded for the given item. If this
+     * function returns a string, that is taken to be an error message which will be
+     * displayed to the user.
+     */
+    isErrorResult?: (result: RemoveResult) => string | undefined;
+};
+export declare function createBulkRemoveFromChannelAction<ItemType, ResultType = Partial<ItemType>>(config: CreateBulkRemoveFromChannelActionConfig<ItemType, ResultType>): BulkAction<any, BaseListComponent<any, any, any>>;

package/core/common/utilities/configurable-operation-utils.d.ts

@@ -0,0 +1,48 @@
+import { ConfigArgDefinition, ConfigurableOperation, ConfigurableOperationDefinition, ConfigurableOperationInput } from '../generated-types';
+/**
+ * ConfigArg values are always stored as strings. If they are not primitives, then
+ * they are JSON-encoded. This function unwraps them back into their original
+ * data type.
+ */
+export declare function getConfigArgValue(value: any): any;
+export declare function encodeConfigArgValue(value: any): string;
+/**
+ * Creates an empty ConfigurableOperation object based on the definition.
+ */
+export declare function configurableDefinitionToInstance(def: Omit<ConfigurableOperationDefinition, '__typename'>): ConfigurableOperation;
+/**
+ * Converts an object of the type:
+ * ```
+ * {
+ *     code: 'my-operation',
+ *     args: {
+ *         someProperty: 'foo'
+ *     }
+ * }
+ * ```
+ * to the format defined by the ConfigurableOperationInput GraphQL input type:
+ * ```
+ * {
+ *     code: 'my-operation',
+ *     arguments: [
+ *         { name: 'someProperty', value: 'foo' }
+ *     ]
+ * }
+ * ```
+ */
+export declare function toConfigurableOperationInput(operation: Omit<ConfigurableOperation, '__typename'>, formValueOperations: {
+    args: Record<string, string> | Array<{
+        name: string;
+        value: string;
+    }>;
+}): ConfigurableOperationInput;
+export declare function configurableOperationValueIsValid(def?: ConfigurableOperationDefinition, value?: {
+    code: string;
+    args: {
+        [key: string]: string;
+    };
+}): boolean;
+/**
+ * Returns a default value based on the type of the config arg.
+ */
+export declare function getDefaultConfigArgValue(arg: ConfigArgDefinition): any;

package/core/common/utilities/create-updated-translatable.d.ts

@@ -0,0 +1,25 @@
+import { CustomFieldConfig, LanguageCode } from '../generated-types';
+export interface TranslatableUpdateOptions<T extends {
+    translations: any[];
+} & MayHaveCustomFields> {
+    translatable: T;
+    updatedFields: {
+        [key: string]: any;
+    };
+    languageCode: LanguageCode;
+    customFieldConfig?: CustomFieldConfig[];
+    defaultTranslation?: Partial<T['translations'][number]>;
+}
+export type MayHaveCustomFields = {
+    customFields?: {
+        [key: string]: any;
+    };
+};
+/**
+ * When updating an entity which has translations, the value from the form will pertain to the current
+ * languageCode. This function ensures that the "translations" array is correctly set based on the
+ * existing languages and the updated values in the specified language.
+ */
+export declare function createUpdatedTranslatable<T extends {
+    translations: any[];
+} & MayHaveCustomFields>(options: TranslatableUpdateOptions<T>): T;

package/core/common/utilities/custom-field-default-value.d.ts

@@ -0,0 +1,6 @@
+import { CustomFieldType } from '@deenruv/common/lib/shared-types';
+import { CustomFieldConfig } from '../generated-types';
+export declare function getCustomFieldsDefaults(customFieldConfig: CustomFieldConfig[]): {
+    [key: string]: ReturnType<typeof getDefaultValue>;
+};
+export declare function getDefaultValue(type: CustomFieldType, isNullable?: boolean): false | 0 | "" | Date | null;

package/core/common/utilities/find-translation.d.ts

@@ -0,0 +1,14 @@
+import { LanguageCode } from '../generated-types';
+export type Translation<T> = T & {
+    languageCode: LanguageCode;
+};
+export type PossiblyTranslatable<T> = {
+    translations?: Array<Translation<T>> | null;
+};
+export type TranslationOf<E> = E extends PossiblyTranslatable<infer U> ? U : undefined;
+/**
+ * @description
+ * Given a translatable entity, returns the translation in the specified LanguageCode if
+ * one exists.
+ */
+export declare function findTranslation<E extends PossiblyTranslatable<any>>(entity: E | undefined, languageCode: LanguageCode): TranslationOf<E> | undefined;

package/core/common/utilities/get-default-ui-language.d.ts

@@ -0,0 +1,3 @@
+import { LanguageCode } from '../generated-types';
+export declare function getDefaultUiLanguage(): LanguageCode;
+export declare function getDefaultUiLocale(): string | undefined;

package/core/common/utilities/interpolate-description.d.ts

@@ -0,0 +1,7 @@
+import { ConfigurableOperationDefinition } from '../generated-types';
+/**
+ * Interpolates the description of an ConfigurableOperation with the given values.
+ */
+export declare function interpolateDescription(operation: ConfigurableOperationDefinition, values: {
+    [name: string]: any;
+}, precisionFactor?: number): string;

package/core/common/utilities/selection-manager.d.ts

@@ -0,0 +1,30 @@
+import { Observable } from 'rxjs';
+export interface SelectionManagerOptions<T> {
+    multiSelect: boolean;
+    itemsAreEqual: (a: T, b: T) => boolean;
+    additiveMode: boolean;
+}
+/**
+ * @description
+ * A helper class used to manage selection of list items. Supports multiple selection via
+ * cmd/ctrl/shift key.
+ */
+export declare class SelectionManager<T> {
+    private options;
+    constructor(options: SelectionManagerOptions<T>);
+    get selection(): T[];
+    selectionChanges$: Observable<T[]>;
+    private _selection;
+    private items;
+    private selectionChangesSubject;
+    setMultiSelect(isMultiSelect: boolean): void;
+    setCurrentItems(items: T[]): void;
+    toggleSelection(item: T, event?: MouseEvent): void;
+    selectMultiple(items: T[]): void;
+    clearSelection(): void;
+    isSelected(item: T): boolean;
+    areAllCurrentItemsSelected(): boolean;
+    toggleSelectAll(): void;
+    lastSelected(): T;
+    private invokeOnSelectionChangeHandler;
+}

package/core/common/utilities/string-to-color.d.ts

@@ -0,0 +1,4 @@
+/**
+ * For a given string, returns one of a pre-defined selection of colours.
+ */
+export declare function stringToColor(input: string): string;

package/core/common/version.d.ts

@@ -0,0 +1 @@
+export declare const ADMIN_UI_VERSION = "1.0.0";

package/core/components/alerts/alerts.component.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { ActiveAlert, AlertsService } from '../../providers/alerts/alerts.service';
+import * as i0 from "@angular/core";
+export declare class AlertsComponent {
+    protected alertsService: AlertsService;
+    protected hasAlerts$: Observable<boolean>;
+    protected activeAlerts$: Observable<ActiveAlert[]>;
+    constructor(alertsService: AlertsService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlertsComponent, "vdr-alerts", never, {}, {}, never, never, false, never>;
+}

package/core/components/app-shell/app-shell.component.d.ts

@@ -0,0 +1,41 @@
+import { OnInit } from '@angular/core';
+import { Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { LanguageCode } from '../../common/generated-types';
+import { DataService } from '../../data/providers/data.service';
+import { AuthService } from '../../providers/auth/auth.service';
+import { BreadcrumbService } from '../../providers/breadcrumb/breadcrumb.service';
+import { I18nService } from '../../providers/i18n/i18n.service';
+import { LocalStorageService } from '../../providers/local-storage/local-storage.service';
+import { ModalService } from '../../providers/modal/modal.service';
+import { LocalizationDirectionType, LocalizationLanguageCodeType, LocalizationService } from '../../providers/localization/localization.service';
+import * as i0 from "@angular/core";
+export declare class AppShellComponent implements OnInit {
+    private authService;
+    private dataService;
+    private router;
+    private i18nService;
+    private modalService;
+    private localStorageService;
+    private breadcrumbService;
+    private localizationService;
+    version: string;
+    userName$: Observable<string>;
+    uiLanguageAndLocale$: LocalizationLanguageCodeType;
+    direction$: LocalizationDirectionType;
+    availableLanguages: LanguageCode[];
+    availableLocales: string[];
+    hideDeenruvBranding: boolean | undefined;
+    hideVersion: boolean | undefined;
+    pageTitle$: Observable<string>;
+    mainNavExpanded$: Observable<boolean>;
+    devMode: boolean;
+    constructor(authService: AuthService, dataService: DataService, router: Router, i18nService: I18nService, modalService: ModalService, localStorageService: LocalStorageService, breadcrumbService: BreadcrumbService, localizationService: LocalizationService);
+    ngOnInit(): void;
+    selectUiLanguage(): void;
+    expandNav(): void;
+    collapseNav(): void;
+    logOut(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppShellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppShellComponent, "vdr-app-shell", never, {}, {}, never, never, false, never>;
+}

package/core/components/base-nav/base-nav.component.d.ts

@@ -0,0 +1,30 @@
+import { Injector, OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { DataService } from '../../data/providers/data.service';
+import { HealthCheckService } from '../../providers/health-check/health-check.service';
+import { JobQueueService } from '../../providers/job-queue/job-queue.service';
+import { NavMenuItem } from '../../providers/nav-builder/nav-builder-types';
+import { NavBuilderService } from '../../providers/nav-builder/nav-builder.service';
+import { NotificationService } from '../../providers/notification/notification.service';
+import * as i0 from "@angular/core";
+export declare class BaseNavComponent implements OnInit, OnDestroy {
+    protected route: ActivatedRoute;
+    protected router: Router;
+    navBuilderService: NavBuilderService;
+    protected healthCheckService: HealthCheckService;
+    protected jobQueueService: JobQueueService;
+    protected dataService: DataService;
+    protected notificationService: NotificationService;
+    protected injector: Injector;
+    constructor(route: ActivatedRoute, router: Router, navBuilderService: NavBuilderService, healthCheckService: HealthCheckService, jobQueueService: JobQueueService, dataService: DataService, notificationService: NotificationService, injector: Injector);
+    private userPermissions;
+    private subscription;
+    shouldDisplayLink(menuItem: Pick<NavMenuItem, 'requiresPermission'>): boolean | undefined;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getRouterLink(item: NavMenuItem): string[] | null;
+    private defineNavMenu;
+    private createContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseNavComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseNavComponent, "[vdrBaseNav]", never, {}, {}, never, never, false, never>;
+}

package/core/components/breadcrumb/breadcrumb.component.d.ts

@@ -0,0 +1,27 @@
+import { Observable } from 'rxjs';
+import { BreadcrumbService } from '../../providers/breadcrumb/breadcrumb.service';
+import * as i0 from "@angular/core";
+/**
+ * A breadcrumbs component which reads the route config and any route that has a `data.breadcrumb` property will
+ * be displayed in the breadcrumb trail.
+ *
+ * The `breadcrumb` property can be a string or a function. If a function, it will be passed the route's `data`
+ * object (which will include all resolved keys) and any route params, and should return a BreadcrumbValue.
+ *
+ * See the test config to get an idea of allowable configs for breadcrumbs.
+ */
+export declare class BreadcrumbComponent {
+    private breadcrumbService;
+    breadcrumbs$: Observable<Array<{
+        link: string | any[];
+        label: string;
+    }>>;
+    parentBreadcrumb$: Observable<{
+        link: string | any[];
+        label: string;
+    } | undefined>;
+    private destroy$;
+    constructor(breadcrumbService: BreadcrumbService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "vdr-breadcrumb", never, {}, {}, never, never, false, never>;
+}

package/core/components/channel-switcher/channel-switcher.component.d.ts

@@ -0,0 +1,21 @@
+import { OnInit } from '@angular/core';
+import { UntypedFormControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { CurrentUserChannel } from '../../common/generated-types';
+import { DataService } from '../../data/providers/data.service';
+import { ChannelService } from '../../providers/channel/channel.service';
+import * as i0 from "@angular/core";
+export declare class ChannelSwitcherComponent implements OnInit {
+    private dataService;
+    private channelService;
+    readonly displayFilterThreshold = 10;
+    channels$: Observable<CurrentUserChannel[]>;
+    channelCount$: Observable<number>;
+    filterControl: UntypedFormControl;
+    activeChannelCode$: Observable<string>;
+    constructor(dataService: DataService, channelService: ChannelService);
+    ngOnInit(): void;
+    setActiveChannel(channelId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChannelSwitcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChannelSwitcherComponent, "vdr-channel-switcher", never, {}, {}, never, never, false, never>;
+}

package/core/components/main-nav/main-nav.component.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { NavMenuItem, NavMenuSection } from '../../providers/nav-builder/nav-builder-types';
+import { BaseNavComponent } from '../base-nav/base-nav.component';
+import * as i0 from "@angular/core";
+export declare class MainNavComponent extends BaseNavComponent implements OnInit {
+    displayMode: string | undefined;
+    itemClick: EventEmitter<NavMenuItem>;
+    mainMenuConfig$: Observable<NavMenuSection[]>;
+    expandedSections: string[];
+    ngOnInit(): void;
+    toggleExpand(section: NavMenuSection): void;
+    setExpanded(section: NavMenuSection, expanded: boolean): void;
+    getStyleForSection(section: NavMenuSection): {
+        maxHeight: string;
+        opacity: number;
+        visibility: string;
+    } | undefined;
+    onItemClick(item: NavMenuItem, event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MainNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MainNavComponent, "vdr-main-nav", never, { "displayMode": { "alias": "displayMode"; "required": false; }; }, { "itemClick": "itemClick"; }, never, never, false, never>;
+}

package/core/components/notification/notification.component.d.ts

@@ -0,0 +1,37 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { NotificationType } from '../../providers/notification/notification.service';
+import { LocalizationDirectionType, LocalizationService } from '../../providers/localization/localization.service';
+import * as i0 from "@angular/core";
+export declare class NotificationComponent implements OnInit {
+    private localizationService;
+    direction$: LocalizationDirectionType;
+    wrapper: ElementRef;
+    offsetTop: number;
+    message: string;
+    translationVars: {
+        [key: string]: string | number;
+    };
+    type: NotificationType;
+    isVisible: boolean;
+    private onClickFn;
+    /**
+     *
+     */
+    constructor(localizationService: LocalizationService);
+    ngOnInit(): void;
+    registerOnClickFn(fn: () => void): void;
+    onClick(): void;
+    /**
+     * Fade out the toast. When promise resolves, toast is invisible and
+     * can be removed.
+     */
+    fadeOut(): Promise<any>;
+    /**
+     * Returns the height of the toast element in px.
+     */
+    getHeight(): number;
+    getIcon(): string;
+    stringifyMessage(message: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationComponent, "vdr-notification", never, {}, {}, never, never, false, never>;
+}

package/core/components/overlay-host/overlay-host.component.d.ts

@@ -0,0 +1,12 @@
+import { ViewContainerRef } from '@angular/core';
+import { OverlayHostService } from '../../providers/overlay-host/overlay-host.service';
+import * as i0 from "@angular/core";
+/**
+ * The OverlayHostComponent is a placeholder component which provides a location in the DOM into which overlay
+ * elements (modals, notify notifications etc) may be injected dynamically.
+ */
+export declare class OverlayHostComponent {
+    constructor(viewContainerRef: ViewContainerRef, overlayHostService: OverlayHostService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OverlayHostComponent, "vdr-overlay-host", never, {}, {}, never, never, false, never>;
+}

package/core/components/settings-nav/settings-nav.component.d.ts

@@ -0,0 +1,11 @@
+import { OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { NavMenuSection } from '../../providers/nav-builder/nav-builder-types';
+import { BaseNavComponent } from '../base-nav/base-nav.component';
+import * as i0 from "@angular/core";
+export declare class SettingsNavComponent extends BaseNavComponent implements OnInit {
+    settingsMenuConfig$: Observable<NavMenuSection[]>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsNavComponent, "vdr-settings-nav", never, {}, {}, never, never, false, never>;
+}

package/core/components/theme-switcher/theme-switcher.component.d.ts

@@ -0,0 +1,16 @@
+import { OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DataService } from '../../data/providers/data.service';
+import { LocalStorageService } from '../../providers/local-storage/local-storage.service';
+import * as i0 from "@angular/core";
+export declare class ThemeSwitcherComponent implements OnInit {
+    private dataService;
+    private localStorageService;
+    activeTheme$: Observable<string>;
+    constructor(dataService: DataService, localStorageService: LocalStorageService);
+    ngOnInit(): void;
+    onHostClick(): void;
+    toggleTheme(current: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeSwitcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ThemeSwitcherComponent, "vdr-theme-switcher", never, {}, {}, never, never, false, never>;
+}

package/core/components/ui-language-switcher-dialog/ui-language-switcher-dialog.component.d.ts

@@ -0,0 +1,30 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { CurrencyCode, LanguageCode } from '../../common/generated-types';
+import { Dialog } from '../../providers/modal/modal.types';
+import { DataService } from '../../data/providers/data.service';
+import * as i0 from "@angular/core";
+export declare class UiLanguageSwitcherDialogComponent implements Dialog<[LanguageCode, string | undefined]>, OnInit, OnDestroy {
+    private dataService;
+    private changeDetector;
+    isLoading: boolean;
+    private destroy$;
+    resolveWith: (result?: [LanguageCode, string | undefined]) => void;
+    currentLanguage: LanguageCode;
+    availableLanguages: LanguageCode[];
+    currentLocale: string | undefined;
+    availableLocales: string[];
+    availableCurrencyCodes: CurrencyCode[];
+    selectedCurrencyCode: string;
+    previewLocale: string;
+    readonly browserDefaultLocale: string | undefined;
+    readonly now: string;
+    constructor(dataService: DataService, changeDetector: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    updatePreviewLocale(): void;
+    setLanguage(): void;
+    cancel(): void;
+    private createLocaleString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiLanguageSwitcherDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiLanguageSwitcherDialogComponent, "vdr-ui-language-switcher", never, {}, {}, never, never, false, never>;
+}

package/core/components/user-menu/user-menu.component.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from '@angular/core';
+import { LanguageCode } from '../../common/generated-types';
+import * as i0 from "@angular/core";
+export declare class UserMenuComponent {
+    userName: string;
+    availableLanguages: LanguageCode[];
+    uiLanguageAndLocale: [LanguageCode, string | undefined];
+    logOut: EventEmitter<void>;
+    selectUiLanguage: EventEmitter<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserMenuComponent, "vdr-user-menu", never, { "userName": { "alias": "userName"; "required": false; }; "availableLanguages": { "alias": "availableLanguages"; "required": false; }; "uiLanguageAndLocale": { "alias": "uiLanguageAndLocale"; "required": false; }; }, { "logOut": "logOut"; "selectUiLanguage": "selectUiLanguage"; }, never, never, false, never>;
+}

package/core/core.module.d.ts

@@ -0,0 +1,39 @@
+import { PlatformLocation } from '@angular/common';
+import { HttpClient } from '@angular/common/http';
+import { Title } from '@angular/platform-browser';
+import { AlertsService } from './providers/alerts/alerts.service';
+import { CustomHttpTranslationLoader } from './providers/i18n/custom-http-loader';
+import { I18nService } from './providers/i18n/i18n.service';
+import { LocalStorageService } from './providers/local-storage/local-storage.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./components/app-shell/app-shell.component";
+import * as i2 from "./components/user-menu/user-menu.component";
+import * as i3 from "./components/base-nav/base-nav.component";
+import * as i4 from "./components/main-nav/main-nav.component";
+import * as i5 from "./components/settings-nav/settings-nav.component";
+import * as i6 from "./components/breadcrumb/breadcrumb.component";
+import * as i7 from "./components/overlay-host/overlay-host.component";
+import * as i8 from "./components/notification/notification.component";
+import * as i9 from "./components/ui-language-switcher-dialog/ui-language-switcher-dialog.component";
+import * as i10 from "./components/channel-switcher/channel-switcher.component";
+import * as i11 from "./components/theme-switcher/theme-switcher.component";
+import * as i12 from "./components/alerts/alerts.component";
+import * as i13 from "@angular/platform-browser";
+import * as i14 from "./data/data.module";
+import * as i15 from "./shared/shared.module";
+import * as i16 from "@angular/platform-browser/animations";
+import * as i17 from "@ngx-translate/core";
+export declare class CoreModule {
+    private i18nService;
+    private localStorageService;
+    private titleService;
+    private alertsService;
+    constructor(i18nService: I18nService, localStorageService: LocalStorageService, titleService: Title, alertsService: AlertsService);
+    private initUiLanguagesAndLocales;
+    private initUiTitle;
+    private initAlerts;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreModule, [typeof i1.AppShellComponent, typeof i2.UserMenuComponent, typeof i3.BaseNavComponent, typeof i4.MainNavComponent, typeof i5.SettingsNavComponent, typeof i6.BreadcrumbComponent, typeof i7.OverlayHostComponent, typeof i8.NotificationComponent, typeof i9.UiLanguageSwitcherDialogComponent, typeof i10.ChannelSwitcherComponent, typeof i11.ThemeSwitcherComponent, typeof i12.AlertsComponent], [typeof i13.BrowserModule, typeof i14.DataModule, typeof i15.SharedModule, typeof i16.BrowserAnimationsModule, typeof i17.TranslateModule], [typeof i15.SharedModule, typeof i7.OverlayHostComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoreModule>;
+}
+export declare function HttpLoaderFactory(http: HttpClient, location: PlatformLocation): CustomHttpTranslationLoader;

package/core/data/check-jobs-link.d.ts

@@ -0,0 +1,19 @@
+import { Injector } from '@angular/core';
+import { ApolloLink } from '@apollo/client/core';
+import { JobQueueService } from '../providers/job-queue/job-queue.service';
+/**
+ * This link checks each operation and if it is a mutation, it tells the JobQueueService
+ * to poll for active jobs. This is because certain mutations trigger background jobs
+ * which should be made known in the UI.
+ */
+export declare class CheckJobsLink extends ApolloLink {
+    private injector;
+    private _jobQueueService;
+    get jobQueueService(): JobQueueService;
+    /**
+     * We inject the Injector rather than the JobQueueService directly in order
+     * to avoid a circular dependency error.
+     */
+    constructor(injector: Injector);
+    private isMutation;
+}

package/core/data/client-state/client-defaults.d.ts

@@ -0,0 +1,32 @@
+import { LocalStorageService } from '../../providers/local-storage/local-storage.service';
+export declare function getClientDefaults(localStorageService: LocalStorageService): {
+    networkStatus: {
+        __typename?: "NetworkStatus" | undefined;
+        inFlightRequests: number;
+    };
+    userStatus: {
+        __typename?: "UserStatus" | undefined;
+        administratorId?: string | null | undefined;
+        username: string;
+        isLoggedIn: boolean;
+        loginTime: string;
+        activeChannelId?: string | null | undefined;
+        permissions: import("../../common/generated-types").Permission[];
+        channels: {
+            __typename?: "CurrentUserChannel" | undefined;
+            id: string;
+            code: string;
+            token: string;
+            permissions: import("../../common/generated-types").Permission[];
+        }[];
+    };
+    uiState: {
+        __typename?: "UiState" | undefined;
+        language: import("../../common/generated-types").LanguageCode;
+        locale?: string | null | undefined;
+        contentLanguage: import("../../common/generated-types").LanguageCode;
+        theme: string;
+        displayUiExtensionPoints: boolean;
+        mainNavExpanded: boolean;
+    };
+};

package/core/data/client-state/client-resolvers.d.ts

@@ -0,0 +1,12 @@
+import { InMemoryCache } from '@apollo/client/core';
+export type ResolverContext = {
+    cache: InMemoryCache;
+    optimisticResponse: any;
+    getCacheKey: (storeObj: any) => string;
+};
+export type ResolverDefinition = {
+    Mutation: {
+        [name: string]: (rootValue: any, args: any, context: ResolverContext, info?: any) => any;
+    };
+};
+export declare const clientResolvers: ResolverDefinition;