@clickview/library-editor 1.1.18 → 1.1.19-dev.0

package/dist/libs/common/src/backbone/core/LayoutService.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="backbone" />
+import * as Marionette from 'backbone.marionette';
+import { BaseLayoutView, BaseLayoutViewOptions } from './BaseLayoutView';
+export interface LayoutOptions<T extends BaseLayoutViewOptions> {
+    name: string;
+    options?: T;
+}
+export interface LayoutServiceOptions extends Marionette.ObjectOptions {
+    requiredRegions?: string[];
+}
+export declare class LayoutService extends Marionette.Object {
+    private layouts;
+    private currentLayout;
+    private currentLayoutCacheKey;
+    private requiredRegions;
+    options: LayoutServiceOptions;
+    constructor(options: LayoutServiceOptions);
+    private clearLayout;
+    registerLayout(name: string, layout: typeof BaseLayoutView): this;
+    /**
+     * Either return the existing instance of a layout
+     * or create the layout and cache it before returning.
+     */
+    getLayout<T extends BaseLayoutViewOptions>(layoutOptions: LayoutOptions<T>): BaseLayoutView;
+    /**
+     * Every layout that is registered must have all required/mandatory regions
+     */
+    private checkRequiredRegions;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}

package/dist/libs/common/src/backbone/core/ListenToRadio.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="backbone" />
+declare function ListenToRadio(obj: string | Backbone.Events, events: string, callback: Function, originalListenTo: Function): any;
+export { ListenToRadio };

package/dist/libs/common/src/backbone/core/LocationUtils.d.ts

@@ -0,0 +1,23 @@
+import * as Backbone from 'backbone';
+import { AppLink } from './AppLink';
+/**
+ * This is the only file in the entire project
+ * that should ever reference window.location.
+ */
+declare const LocationUtils: {
+    GetQuery(): Backbone.ObjectHash;
+    UpdateQuery(params: Backbone.ObjectHash): void;
+    UpdateUrl(route: string, appLink: AppLink, options?: Backbone.ObjectHash): void;
+    SerializeQueryParams(params: string | Backbone.ObjectHash): string;
+    DeserializeQueryParams(params: string): Backbone.ObjectHash;
+    StartHistory(): void;
+    PageLoad(href: string, newTab?: boolean): void;
+    Redirect(href: string, replace?: boolean): void;
+    Reload(force?: boolean): void;
+    GetCurrentPath(): string;
+    GetCurrentQueryString(): string;
+    GetCurrentUrl(): string;
+    GetCurrentReferrer(): string;
+    SetPageTitle(title: string): void;
+};
+export { LocationUtils };

package/dist/libs/common/src/backbone/core/Middleware.d.ts

@@ -0,0 +1,10 @@
+export interface MiddlewareNext<T> {
+    (options: T): void;
+}
+export interface MiddlewareFunction<T> {
+    (options: T, next: MiddlewareNext<T>): void;
+}
+export declare class Middleware<T> {
+    use(fn: MiddlewareFunction<T>): void;
+    go(options: T, next: MiddlewareNext<T>): void;
+}

package/dist/libs/common/src/backbone/core/Shell.d.ts

@@ -0,0 +1,79 @@
+import { ObjectHash } from 'backbone';
+import * as Marionette from 'backbone.marionette';
+import { BaseApplication } from './BaseApplication';
+import { BaseError } from './BaseError';
+import { BaseLayoutView } from './BaseLayoutView';
+import { Store } from 'redux';
+interface InitializationStep {
+    (shell: Shell, next: InitializationStep): void;
+}
+interface StartUpSet {
+    (shell: Shell, options: any, next: StartUpSet): void;
+}
+export interface ShellOptions extends Marionette.ApplicationOptions {
+}
+export declare class Shell extends Marionette.Application {
+    /**
+     * Used to retreive and cache layout views.
+     */
+    private layoutService;
+    private applications;
+    private routeLookup;
+    private shellState;
+    initialize(options?: ShellOptions): void;
+    private bindListeners;
+    private bindNavLockListeners;
+    private bindAppLinkListeners;
+    private bindErrorHandlers;
+    private bindErrorListener;
+    /**
+     * Using all the routeLookups passed in during AppRouter initialization
+     * we create a bunch of channel replies on the shell channel.
+     *
+     * Both Core.AppRouter and Core.View use this to reverse engineer
+     * the application routes and regenerate urls with a list of arguments.
+     *
+     * These need to exist on the shell rather than on the Core.AppRouter
+     * because consumers of this reply wont know which instance of Core.AppRoute
+     * to call.
+     */
+    private bindRouteLookup;
+    addRouteLookup(name: string, func: () => string): void;
+    registerApplication(application: typeof BaseApplication, options?: ObjectHash): this;
+    getGlobalRadioChannels(): ObjectHash;
+    isNavLocked(): boolean;
+    start(options?: any): void;
+    hasActiveRoute(): boolean;
+    /**
+     * On Shell start up an instance of each Applications router is instantiated
+     * so that it can listen to application events or route in the current page
+     */
+    onStart(): void;
+    /**
+     * these are based on node/express middleware:
+     * https://gist.github.com/darrenscerri/5c3b3dcbe4d370435cfa
+     *
+     * Initialization steps should be used to do stuff like register
+     * services with the instance manager, register analytics clients
+     * and enrichers, add any data provider middle ware and register layouts
+     */
+    addInitializationStep(fn: InitializationStep): Shell;
+    private runInitializationSteps;
+    addStartUpStep(fn: StartUpSet): Shell;
+    /**
+     * Start up steps should be used to inject options into the shell
+     * or run any other code that we want to run just before the application starts
+     */
+    private runStartUpSteps;
+    registerLayout(name: string, layout: typeof BaseLayoutView): Shell;
+    private errorHandlers;
+    registerErrorHandler<T extends BaseError>(errorType: Function & {
+        prototype: T;
+    }, handler: (error: T) => void): Shell;
+    handleError(error: BaseError): void;
+    store: Store;
+    registerStore(store: Store): void;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}
+export {};

package/dist/libs/common/src/backbone/core/Types.d.ts

@@ -0,0 +1,12 @@
+export declare type ModelCtor<T> = {
+    new (vals: any, options?: any): T;
+};
+export declare type CollectionCtor<T> = {
+    new (models?: any[], options?: any): T;
+};
+export declare type ViewCtor<T> = {
+    new (options: any): T;
+};
+export declare type ErrorCtor<T> = {
+    new (...args: any[]): T;
+};

package/dist/libs/common/src/backbone/core/index.d.ts

@@ -0,0 +1,18 @@
+export { AppLink, AppLinkOptions, AppLinkHash, AppLinkHelper, AppLinkUtility } from './AppLink';
+export { BaseApplication as Application } from './BaseApplication';
+export { BaseAppRouter as AppRouter, ExecuteRouteOptions } from './BaseAppRouter';
+export { BaseBehavior as Behavior } from './BaseBehavior';
+export { BaseCollection as Collection } from './BaseCollection';
+export { BaseCollectionView as CollectionView, BaseCollectionViewOptions as CollectionViewOptions, BaseCollectionView as ComponentCollection, BaseCollectionViewOptions as ComponentCollectionOptions, } from './BaseCollectionView';
+export { BaseError as Error, ErrorHelper, SilentError } from './BaseError';
+export { BaseLayoutView as LayoutView, BaseLayoutViewOptions as LayoutViewOptions } from './BaseLayoutView';
+export { BaseNestedModel as NestedModel, BaseNestedModelOptions as NestedModelOptions } from './BaseNestedModel';
+export { BaseService as Service, BaseServiceOptions as ServiceOptions } from './BaseService';
+export { BaseModel as Model } from './BaseModel';
+export { BaseView as View, BaseViewOptions as ViewOptions, BaseComponent as Component, BaseViewOptions as ComponentOptions, RequiredResourceDefinition, RequiredResourceHash } from './BaseView';
+export { EventNames } from './EventNames';
+export { LayoutService, LayoutOptions } from './LayoutService';
+export { Middleware, MiddlewareFunction, MiddlewareNext } from './Middleware';
+export { LocationUtils } from './LocationUtils';
+export { Shell } from './Shell';
+export * from './Types';

package/dist/libs/common/src/backbone/enums/DataServiceErrorType.d.ts

@@ -0,0 +1,8 @@
+export declare enum DataServiceErrorType {
+    Unknown = 0,
+    BadRequest = 1,
+    Unauthorized = 2,
+    Forbidden = 3,
+    NotFound = 4,
+    InternalServer = 5
+}

package/dist/libs/common/src/backbone/enums/HttpVerbs.d.ts

@@ -0,0 +1,6 @@
+export declare enum HttpVerbs {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE"
+}

package/dist/libs/common/src/backbone/errors/DevError.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "../core/BaseError";
+export declare class DevError extends BaseError {
+    get name(): string;
+}

package/dist/libs/common/src/backbone/errors/NotImplementedError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from "../core/BaseError";
+export declare class NotImplementedError extends BaseError {
+    constructor();
+    get name(): string;
+}

package/dist/libs/common/src/backbone/index.d.ts

@@ -0,0 +1,2 @@
+import * as Core from './core';
+export { Core };

package/dist/libs/common/src/backbone/interfaces/BaseCollectionIdentifier.d.ts

@@ -0,0 +1,18 @@
+import { ObjectHash } from 'backbone';
+export interface BaseCollectionIdentifierOptions<T> {
+    collectionPrefix?: string;
+    id?: string;
+    sort?: T;
+    cursor?: string;
+}
+export declare class BaseCollectionIdentifier<T = {}> {
+    id: string;
+    sort: T;
+    cursor: string;
+    collectionPrefix: string;
+    constructor(options: BaseCollectionIdentifierOptions<T>);
+    protected setData(options: BaseCollectionIdentifierOptions<T>): void;
+    toString(): string;
+    toParams(): ObjectHash;
+    protected getSortTypeParam(): string;
+}

package/dist/libs/common/src/backbone/interfaces/ChainableDataService.d.ts

@@ -0,0 +1,9 @@
+import { DataServiceGetRequest, DataServiceCreateRequest, DataServiceUpdateRequest, DataServiceDeleteRequest } from "./DataServiceRequests";
+export interface ChainableDataService {
+    func(callback: (callback: () => any) => void): ChainableDataService;
+    get<T>(options: DataServiceGetRequest<T>): ChainableDataService;
+    create<T>(options: DataServiceCreateRequest<T>): ChainableDataService;
+    update<T>(options: DataServiceUpdateRequest<T>): ChainableDataService;
+    delete(options: DataServiceDeleteRequest): ChainableDataService;
+    run(): void;
+}

package/dist/libs/common/src/backbone/interfaces/DataCache.d.ts

@@ -0,0 +1,8 @@
+export interface DataCache extends Marionette.Object {
+    has(cacheKey: string): boolean;
+    get(cacheKey: string): any;
+    set(cacheKey: string, value: any): void;
+    getOrSet(cacheKey: string, getter: () => any): any;
+    remove(cacheKey: string): boolean;
+    invalidate(cacheKey: string[], callback?: (cacheKey: string) => void): void;
+}

package/dist/libs/common/src/backbone/interfaces/DataProvider.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="backbone.radio" />
+import { Radio } from 'backbone';
+import { DataServiceError } from "./DataServiceError";
+export interface DataProviderResponseOptions {
+    channel: Radio.Channel;
+    successEvent: string;
+    errorEvent: string;
+}
+export interface DataProvider extends Marionette.Object {
+    parseError(...args: any[]): DataServiceError;
+    create<T>(resource: string, obj: T, options: DataProviderResponseOptions): void;
+    read<T>(resource: string, options: DataProviderResponseOptions): void;
+    update<T>(resource: string, obj: T, options: DataProviderResponseOptions): void;
+    delete(resource: string, options: DataProviderResponseOptions): void;
+}

package/dist/libs/common/src/backbone/interfaces/DataServiceError.d.ts

@@ -0,0 +1,7 @@
+import { DataServiceErrorType } from "../enums/DataServiceErrorType";
+export interface DataServiceError {
+    type: DataServiceErrorType;
+    message: string;
+    code: number;
+}
+export declare const DefaultDataServiceError: DataServiceError;

package/dist/libs/common/src/backbone/interfaces/DataServiceRequests.d.ts

@@ -0,0 +1,218 @@
+import { Events } from 'backbone';
+export interface BaseDataServiceRequest {
+    /**
+     * This will be a url, an event or a cache key
+     * depending on the DataProviderType
+     */
+    resource: string;
+    /**
+     * This is used to generate the events that can be listened to
+     * on the backbone radio channel.
+     *
+     * (e.g. if your eventPrefix was 'library' events would be:
+     * library:request, library:sync, library:success and library:error)
+     */
+    eventPrefix: string;
+    /**
+     * This is the instance that is listening to the events.
+     * We pass this in so we can use the IoC of
+     * listenTo rather than using an on binding.
+     * (https://en.wikipedia.org/wiki/Inversion_of_control)
+     *
+     * This means that there won't be stale event listeners once
+     * the listener is disposed of.
+     */
+    listener?: Events;
+    /**
+     * How long in seconds before the data
+     * is stale and we need to retreive it again
+     */
+    expiryTime?: number;
+    /**
+     * Set of eventPrefix keys that will be evicted from the cache
+     * once the data request has completed.
+     *
+     * Accepts full and partial keys, where partial keys will be used to generate
+     * a regex for matching. Allows for multiple keys to be evicted in bulk.
+     */
+    invalidationKeys?: string[];
+    /**
+     * This is used by a view to gain reference to the model or collection
+     * and store it somewhere. If the data is already cached, the callback will
+     * be called syncronously. Otherwise it will be called when the data becomes
+     * available.
+     */
+    callback?: (data?: any) => any;
+    /**
+     * Callback to be passed from a view to be fired on an error.
+     */
+    errorCallback?: () => void;
+    /**
+     * Success handler is attached as a callback to the successEvent fired on the dataProvider's dataChannel.
+     * Should NOT be used for data manipulation or management by views - use a callback or eventPrefix instead.
+     * Context is not bound at execution time, so ensure that any context is already bound to
+     * the handler when it is passed.
+     */
+    successHandler?: (...args: any[]) => any;
+    /**
+     * Error handler is attached as a callback to the errorEvent fired on the dataProvider's dataChannel.
+     * Context is not bound at execution time, so ensure that any context is already bound to
+     * the handler when it is passed.
+     * A default errorHandler will be bound unless another error handler is passed in.
+     * Alternatively, passing in false will mean that no errorHandler is bound.
+     */
+    errorHandler?: ((...args: any[]) => any) | boolean;
+}
+export interface DataServiceGetRequest<T> extends BaseDataServiceRequest {
+    /**
+     * This should be used to put the data returned from the DataProvider
+     * into an instance of a Model or Collection.
+     *
+     * This should be defined by the children inheriting from BaseDataService
+     * and should not be exposed to views or services consuming BaseDataService.
+     */
+    formatData?: (data: any) => T;
+    /**
+     * Redefine callback with stronger types.
+     */
+    callback?: (data: T) => any;
+    /**
+     * The name of the property on the bootstrap object
+     * that this request will use.
+     */
+    bootstrapName?: string;
+}
+export interface DataServiceClearAndGetRequest<T> extends BaseDataServiceRequest {
+    /**
+     * This should be used to put the data returned from the DataProvider
+     * into an instance of a Model or Collection.
+     *
+     * This should be defined by the children inheriting from BaseDataService
+     * and should not be exposed to views or services consuming BaseDataService.
+     */
+    formatData?: (data: any) => T;
+    /**
+     * Redfine callback as a required option
+     * because this is the only way to retreive the data
+     * in a clearCacheAndGet call
+     */
+    callback: (data: T) => void;
+}
+export interface DataServiceCreateRequest<T> extends BaseDataServiceRequest {
+    /**
+     * This is the data we'll be creating.
+     */
+    data: any;
+    /**
+     * This is how the data should be stored in the cache.
+     */
+    formatData?: (data: any) => T;
+    /**
+     * Redefine callback with stronger types.
+     */
+    callback?: (data: T) => any;
+}
+export interface DataServiceUpdateRequest<T> extends BaseDataServiceRequest {
+    /**
+     * This is the data we'll be sending
+     * to the server.
+     */
+    data: any;
+    /**
+     * This is how the data should be stored in the cache.
+     */
+    formatData?: (data: any) => T;
+    /**
+     * Redefine callback with stronger types.
+     */
+    callback?: (data: T) => any;
+}
+/**
+ * The delete request is the simplest one.
+ * We have this here just incase we need to add to it
+ * in the future.
+ */
+export interface DataServiceDeleteRequest extends BaseDataServiceRequest {
+}
+export interface DataServiceRequestOptions {
+    /**
+     * This is used to generate the events that can be listened to
+     * on the backbone radio channel.
+     *
+     * (e.g. if your eventPrefix was library
+     * our events would be  library:request and library:sync)
+     */
+    eventPrefix: string;
+    /**
+     * Different requests will need to manage/change the cache
+     * in different ways.
+     */
+    cacheOptions?: DataServiceCacheOptions;
+    /**
+     * This should be used to put the data returned from the DataProvider
+     * into an instance of a Model or Collection.
+     *
+     * This should be defined by the children inheriting from BaseDataService
+     * and should not be exposed to views or services consuming BaseDataService.
+     */
+    formatData?: (data: any) => any;
+    /**
+     * After certain requests it may be necessary to refresh
+     * some data in the cache that has become stale.
+     * I.e. Deleting or moving a video
+     * Set of eventPrefix keys that will be evicted from the cache
+     * once the data request has completed.
+     *
+     * Accepts full and partial keys, where partial keys will be used to generate
+     * a regex for matching. Allows for multiple keys to be evicted in bulk.
+     */
+    invalidationKeys?: string[];
+    /**
+     * Redefine callback with stronger types. It is called after a successful request
+     */
+    callback?: (data: any) => any;
+    /**
+     * Callback to be passed from a view to be fired on an error.
+     */
+    errorCallback?: () => void;
+    /**
+     * Success handler is attached as a callback to the successEvent fired on the dataProvider's dataChannel.
+     * Should NOT be used for data manipulation or management by views - use a callback or eventPrefix instead.
+     * Context is not bound at execution time, so ensure that any context is already bound to
+     * the handler when it is passed.
+     */
+    successHandler?: (...args: any[]) => any;
+    /**
+     * Error handler is attached as a callback to the errorEvent fired on the dataProvider's dataChannel.
+     * Context is not bound at execution time, so ensure that any context is already bound to
+     * the handler when it is passed.
+     * A default errorHandler will be bound unless another error handler is passed in.
+     * Alternatively, passing in false will mean that no errorHandler is bound.
+     */
+    errorHandler?: ((...args: any[]) => any) | boolean;
+}
+export interface DataServiceCacheOptions {
+    /**
+     * All requests will be cached by default. In circumstances where the return value
+     * is not required (i.e. after a delete call), set the flag to true.
+     */
+    noCache?: boolean;
+    /**
+     * Certain requets (ie. deletes) may require the current cacheKey to be cleared.
+     * Set to true to clear.
+     */
+    clearCacheKey?: boolean;
+    /**
+     * Where muliple views may require access to the same reource/data, set openRequest to
+     * ensure that any subsequent view can bind it's own callbacks to the existing
+     * network call.
+     */
+    openRequest?: boolean;
+    /**
+     * Cached data will utilise a timestamp to determine it's own expiry time within the cache.
+     */
+    timestamp?: number;
+}
+export interface RequestSignatures {
+    [signature: string]: string;
+}

package/dist/libs/common/src/backbone/interfaces/Pagination.d.ts

@@ -0,0 +1,33 @@
+export interface Pagination {
+    cursors: Cursors;
+    limit: number;
+}
+export interface Cursors {
+    next: string;
+    previous: string;
+}
+/**
+ * Do not extend or implement this interface.
+ * It is only exported for use within the BaseDataService.
+ *
+ * By default, the BaseDataService will convert legacy pagination
+ * objects to cursor-based pagination objects.
+ */
+export interface LegacyPagination {
+    page: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+}
+/**
+ * Do not extend or implement this interface.
+ * It is only exported for use within the BaseDataService.
+ *
+ * By default, the BaseDataService will convert legacy pagination
+ * objects to cursor-based pagination objects.
+ */
+export interface OffsetPagination {
+    offset: number;
+    pageSize: number;
+    totalItems: number;
+}

package/dist/libs/common/src/backbone/interfaces/StickitBinding.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="jquery" />
+/// <reference types="jqueryui" />
+/// <reference types="typeahead" />
+/// <reference types="bootstrap" />
+/// <reference types="dropzone" />
+import { BaseModel } from '../core/BaseModel';
+export interface StickitBinding {
+    observe: string;
+    onGet?: string | ((value: string, options: any) => string);
+    onSet?: string | ((value: string, options: any) => string);
+    getVal?: string | (($el: JQuery, event: Event, options: any) => string);
+    update?: string | (($el: JQuery, value: string, model: BaseModel, options: any) => void);
+    updateModel?: string | boolean | ((value: string, event: Event, options: any) => boolean);
+    updateView?: string | boolean | (() => boolean);
+    afterUpdate?: string | (($el: JQuery, value: string, options: any) => void);
+    updateMethod?: string;
+    escape?: boolean;
+    initialize?: string | (($el: JQuery, model: BaseModel, options: any) => void);
+    destroy?: string | (($el: JQuery, model: BaseModel, options: any) => void);
+    visible?: boolean | ((value: string, options: any) => boolean);
+    visibleFn?: string;
+    events?: string[];
+    name?: string;
+    selectOptions?: {
+        collection: string;
+        labelPath: string;
+        valuePath: string;
+        defaultOption?: string;
+    };
+    setOptions?: {
+        silent?: boolean;
+        validate?: boolean;
+    };
+    classes?: {
+        [className: string]: StickitBinding;
+    };
+    attributes?: StickitBinding[];
+}

package/dist/libs/common/src/backbone/interfaces/Xhr.d.ts

@@ -0,0 +1,9 @@
+export interface Xhr extends Pick<XMLHttpRequest, 'getResponseHeader' | 'status'> {
+    responseJSON?: any;
+}
+/**
+ * We're making getResponseHeader optional for a slightly nicer API
+ */
+export interface SimulatedXhr extends Omit<Xhr, 'getResponseHeader'> {
+    getResponseHeader?: (name: string) => string;
+}

package/dist/libs/common/src/backbone/interfaces/index.d.ts

@@ -0,0 +1,9 @@
+export * from './BaseCollectionIdentifier';
+export * from './ChainableDataService';
+export * from './DataCache';
+export * from './DataProvider';
+export * from './DataServiceError';
+export * from './DataServiceRequests';
+export * from './Pagination';
+export * from './StickitBinding';
+export * from './Xhr';

package/dist/libs/common/src/backbone/runtime/InputValidation.d.ts

@@ -0,0 +1,2 @@
+declare const SetupInputValidation: () => void;
+export { SetupInputValidation };

package/dist/libs/common/src/backbone/services/BaseAlertService.d.ts

@@ -0,0 +1,69 @@
+import * as React from 'react';
+import { ObjectHash } from 'backbone';
+import { AppLink } from "../core/AppLink";
+import { BaseView } from "../core/BaseView";
+import { BaseCollectionView } from "../core/BaseCollectionView";
+import { BaseComponent } from "../core/BaseView";
+import { ViewCtor } from "../core/Types";
+import { BaseService, BaseServiceOptions } from "../core/BaseService";
+export declare enum AlertType {
+    Success = "success",
+    Warning = "warning",
+    Fail = "danger",
+    Info = "info"
+}
+export declare enum DefaultAlertHeading {
+    Success = "Success! \uD83D\uDE4C",
+    Warning = "Whoops...",
+    Fail = "Oops...",
+    Info = "FYI"
+}
+export interface BaseAlert {
+    id?: string;
+    type: AlertType;
+    heading: string;
+    message?: string;
+    appLink?: AppLink;
+    appLinkText?: string;
+    appLinkClassName?: string;
+    timeout?: number;
+}
+export interface DefaultAlertCallback {
+    (message?: string, options?: ObjectHash): void;
+}
+export interface BaseAlertOptions {
+    useXHR: boolean;
+}
+declare type View = BaseView | BaseCollectionView | BaseComponent;
+interface AlertProps {
+    alerts: BaseAlert[];
+    removeAlert: (id: string) => void;
+}
+export interface BaseAlertServiceOptions extends BaseServiceOptions {
+    maxAlerts?: number;
+    defaultSuccessAlert: BaseAlert;
+    defaultErrorAlert: BaseAlert;
+    alertViewCtor?: ViewCtor<View> | ((props: AlertProps) => React.ReactElement);
+}
+export declare class BaseAlertService extends BaseService {
+    private options;
+    private alertCollection;
+    constructor(options: BaseAlertServiceOptions);
+    initialize(): void;
+    get name(): string;
+    get defaults(): ObjectHash;
+    /**
+     * As it's not known which application is currently in scope,
+     * we emit a render event to construct the alert collection view
+     * if required. If the current application already has a alert
+     * view rendered, it will simply be ignored.
+     */
+    private showAlerts;
+    removeAlert(id: string): void;
+    createAlert(alertData: BaseAlert): void;
+    clearAllAlerts(): void;
+    success(successAlert: string | BaseAlert | BaseAlertOptions): DefaultAlertCallback;
+    error(errorAlert: string | BaseAlert | BaseAlertOptions): DefaultAlertCallback;
+    private generateUniqueAlertId;
+}
+export {};