@clickview/online 0.0.10-dev.1 → 0.0.10-rc.1

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

@@ -1,218 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,38 +0,0 @@
-/// <reference types="jquery" />
-/// <reference types="jqueryui" />
-/// <reference types="typeahead" />
-/// <reference types="dropzone" />
-/// <reference types="bootstrap" />
-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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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/services/BaseAlertService.d.ts

@@ -1,69 +0,0 @@
-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 {};

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

@@ -1,82 +0,0 @@
-import { ObjectHash } from 'backbone';
-import { Cursors } from "../interfaces/Pagination";
-import { DataProvider } from "../interfaces/DataProvider";
-import { DataServiceGetRequest, DataServiceCreateRequest, DataServiceUpdateRequest, DataServiceDeleteRequest } from "../interfaces/DataServiceRequests";
-import { DataCache } from "../interfaces/DataCache";
-import { BaseService } from "../core/BaseService";
-import { DataServiceClearAndGetRequest } from "../interfaces/DataServiceRequests";
-import { ChainableDataService } from "../interfaces/ChainableDataService";
-import { BaseAlertService } from './BaseAlertService';
-export interface BaseDataServiceOptions {
-    dataProvider: DataProvider;
-    cache: DataCache;
-    bootstrapData?: ObjectHash;
-    defaultErrorHandler?: (...args: any[]) => any;
-    alertService: BaseAlertService;
-}
-export declare class BaseDataService extends BaseService {
-    private bootstrapData;
-    /**
-     * This is what is used to actually fetch the data.
-     * This can be an AjaxDataProvider, a SignalRDataProvider
-     * or a LocalStorageDataProvider.
-     */
-    private dataProvider;
-    /**
-     * Store fetched data.
-     */
-    private cache;
-    /**
-     * Maintain a hash of dataRequestSignatures to ensure
-     * that we only bind listeners for the first data event
-     * for a given eventprefix.
-     */
-    private dataRequestSignatures;
-    /**
-     * Default errorHandler attached as a callback to the errorEvent fired on the dataProvider's dataChannel.
-     * Will not be bound if an alternative errorHandler is passed in as an option when making a data request
-     * or if false is passed in as the errorHandler option.
-     */
-    private defaultErrorHandler;
-    /**
-     * A reference to the consuming applications alert service.
-     */
-    protected alertService: BaseAlertService;
-    /**
-     * Specify the properties you want to be
-     * taken from `options` and added to the context.
-     */
-    props: string[];
-    /**
-     * The default properties that will be taken
-     * from `options` and added to the context.
-     */
-    private get defaultProps();
-    constructor(options: BaseDataServiceOptions);
-    protected getCursors(cacheKey: string): Cursors;
-    protected clearCacheAndGet<T>(options: DataServiceClearAndGetRequest<T>): void;
-    protected get<T>(options: DataServiceGetRequest<T>): T;
-    protected create<T>(options: DataServiceCreateRequest<T>): void;
-    protected update<T>(options: DataServiceUpdateRequest<T>): void;
-    protected delete(options: DataServiceDeleteRequest): void;
-    private listenToResponse;
-    private cacheData;
-    private processPagination;
-    private formatData;
-    /**
-     * Used to syncronously execute dataService operations.
-     * This will mainly be used if we need to update a model
-     * or collection after an api call.
-     */
-    protected chain(): ChainableDataService;
-    protected invalidateCache(invalidationKeys?: string[]): void;
-    private currentTimestamp;
-    private isExpired;
-    private getEventNames;
-    private getTransportChannel;
-    private getAlertChannel;
-    private setRequestSignature;
-    private hasRequestSignature;
-    private convertOffsetPaginationToCursors;
-    private convertLegacyPaginationToCursors;
-}

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

@@ -1,13 +0,0 @@
-import { ObjectHash } from 'backbone';
-declare class StaticEnvironmentVariables {
-    private static instance;
-    private variables;
-    constructor();
-    static get Instance(): StaticEnvironmentVariables;
-    get name(): string;
-    get isDevelopment(): boolean;
-    get(name: string): any;
-    setUpVariables(variables: ObjectHash): void;
-}
-export declare const EnvironmentVariables: StaticEnvironmentVariables;
-export {};

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

@@ -1,33 +0,0 @@
-import { ObjectHash } from 'backbone';
-import { BaseDataServiceOptions, BaseDataService } from "./BaseDataService";
-import { BaseService } from "../core/BaseService";
-import { BaseAlertService } from './BaseAlertService';
-interface DataServiceConstructor {
-    new (options: BaseDataServiceOptions): BaseDataService;
-}
-interface DataServiceInstanceOptions {
-    cache: string;
-    dataProvider: string;
-    bootstrapData?: ObjectHash;
-    defaultErrorHandler?: (...args: any[]) => any;
-    alertService: BaseAlertService;
-}
-declare class StaticInstanceManager extends BaseService {
-    private static instance;
-    private constructors;
-    private destructors;
-    private instances;
-    private singletonInstances;
-    private referenceCounts;
-    private constructor();
-    get name(): string;
-    static get Instance(): StaticInstanceManager;
-    registerDataService(ctor: DataServiceConstructor, options: DataServiceInstanceOptions): this;
-    registerInstance<TInstanceOptions>(ctor: new (...args: any[]) => any, options?: TInstanceOptions): this;
-    registerSingleton(instance: any): this;
-    getInstance<T>(name: string, owner?: Backbone.Events): T;
-    releaseInstance(name: string): this;
-    private validateConstructor;
-}
-export declare const InstanceManager: StaticInstanceManager;
-export {};

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

@@ -1,22 +0,0 @@
-import { ObjectHash } from 'backbone';
-import { BaseService } from "../core/BaseService";
-interface LanguageInterpolationOptions {
-    smartCount?: number;
-    [propName: string]: any;
-}
-interface LanguageConfig {
-    locale: string;
-    phrases: ObjectHash;
-}
-declare class StaticLanguageService extends BaseService {
-    private static instance;
-    private polyglot;
-    private cache;
-    static get Instance(): StaticLanguageService;
-    get name(): string;
-    setConfig(config: LanguageConfig): void;
-    getPhrase(namespace: string, phraseKey: string, options?: LanguageInterpolationOptions): string;
-    encloseNamespace(namespace: string): (phraseKey: string, options?: LanguageInterpolationOptions) => string;
-}
-export declare const LanguageService: StaticLanguageService;
-export {};

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

@@ -1,68 +0,0 @@
-import { ObjectHash } from 'backbone';
-import { StorageType } from "../utils/LocalStorageHelper";
-import { BaseService } from "../core/BaseService";
-import { BaseModel } from "../core/BaseModel";
-import { BaseNestedModel } from "../core/BaseNestedModel";
-interface ViewModel extends BaseModel {
-}
-interface ViewNestedModel extends BaseNestedModel {
-}
-declare type ViewData = ViewModel | ViewNestedModel;
-export declare type ViewModelData = ObjectHash | ObjectHash[];
-export interface ViewModelStorage {
-    /**
-     * Auto-persist properties when a change event occurs
-     */
-    persistProps: string | string[];
-    type: StorageType;
-}
-export interface ViewModelOptions<TData> {
-    update?: boolean;
-    ctor?: {
-        new (vals: ViewModelData, options?: ObjectHash): TData;
-    };
-    storage?: ViewModelStorage;
-}
-declare class StaticViewModelService extends BaseService {
-    private static instance;
-    private viewObjects;
-    private constructor();
-    static get Instance(): StaticViewModelService;
-    get name(): string;
-    /**
-     * Update the view model attributes to include defaults, only  where they haven't already
-     * been set previously on the model.
-     *
-     * Note: Checking model instance type is deliberate for Model & NestedModel, otherwise the type system
-     * doesn't know which set() is being invoked. ¯\_(ツ)_/¯
-     */
-    private updateViewModel;
-    get<TData extends ViewData>(key: string, defaultValues?: ViewModelData, options?: ViewModelOptions<TData>): TData;
-    private set;
-    clear(key: string): boolean;
-    /**
-     * Retrieve any data we've previous stored within local storage
-     */
-    private getLocalData;
-    /**
-     * Store changed properties in local storage
-     *
-     * It is not possible to blindly save entire models, instead, specific model properties must be passed
-     * via the storage persistProps. These props will all be set together, even if only one has changed, this
-     * saves us from unncessarily polluting local storage with single props.
-     *
-     * @param key
-     * @param viewData
-     * @param value
-     * @param options
-     */
-    private setLocalData;
-    /**
-     * Setup model listeners to store changes to local storage automatically
-     */
-    private setupChangeListeners;
-    private mergeData;
-    private getStorageHelper;
-}
-export declare const ViewModelService: StaticViewModelService;
-export {};

package/dist/libs/common/src/backbone/services/caches/FifoMemoryCache.d.ts

@@ -1,20 +0,0 @@
-import { DataCache } from "../../interfaces/DataCache";
-import { BaseService } from "../../core/BaseService";
-interface FifoMemoryCacheOptions {
-    size: number;
-}
-export declare class FifoMemoryCache extends BaseService implements DataCache {
-    private size;
-    private cache;
-    private cachedkeys;
-    constructor(options: FifoMemoryCacheOptions);
-    get name(): string;
-    private removeCacheKey;
-    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(cacheKeys: string[], callback?: (cacheKey: string) => void): void;
-}
-export {};

package/dist/libs/common/src/backbone/services/data-providers/AjaxDataProvider.d.ts

@@ -1,31 +0,0 @@
-/// <reference types="jquery" />
-import { ObjectHash } from 'backbone';
-import * as Marionette from 'backbone.marionette';
-import { DataServiceError } from "../../interfaces/DataServiceError";
-import { DataProvider, DataProviderResponseOptions } from "../../interfaces/DataProvider";
-interface MiddlewareCallback {
-    (data: any, textStatus: any, jqXHR: any): any;
-}
-interface AjaxDataProviderOptions {
-    dataServiceErrorMessageMappings: ObjectHash;
-    defaultErrorMessageKey: string;
-}
-export declare class AjaxDataProvider extends Marionette.Object implements DataProvider {
-    private successMiddleware;
-    private errorMiddleware;
-    private dataServiceErrorMessageMappings;
-    private defaultErrorMessageKey;
-    constructor(options?: AjaxDataProviderOptions);
-    get name(): string;
-    private parseUrl;
-    private makeHttps;
-    private base;
-    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;
-    useMiddleware(name: string, callback: MiddlewareCallback): void;
-    useErrorMiddleware(name: string, callback: MiddlewareCallback): void;
-    parseError(jqXHR: JQuery.jqXHR): DataServiceError;
-}
-export {};

package/dist/libs/common/src/backbone/utils/ConcurrencyHelper.d.ts

@@ -1,13 +0,0 @@
-/**
- * Not really for concurrency 😂
- * But useful in circumstances where we need to manually wait for
- * a sequence of callbacks or other resources to execute and don't
- * want the overhead of promises.
- */
-export declare class ConcurrencyHelper {
-    private value;
-    constructor(initialValue: number);
-    increment(): void;
-    decrement(): void;
-    getValue(): number;
-}

package/dist/libs/common/src/backbone/utils/DataServiceErrorHelper.d.ts

@@ -1,2 +0,0 @@
-import { ObjectHash } from 'backbone';
-export declare const DataServiceErrorHelper: ObjectHash;