@clickview/player 0.0.25-rc.0 → 0.0.26-dev.0

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

@@ -1,38 +1,38 @@
-import { ObjectHash } from 'backbone';
-import { BaseService } from 'libs/common/backbone/core/BaseService';
-interface LanguageInterpolationOptions {
-    smartCount?: number;
-    escapeText?: boolean;
-    [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;
-    /**
-     * This function manages two security and safety aspects of our templates:
-     * 1. Sanitization occurs for all phrase inputs and cannot be overriden.
-     * 2. Escaping of potentially dangerous markup is opt-in and can be enabled using the `escapeText` option.
-     *
-     * Both of these steps are applied to all values on the `options` object that will be used for interpolation.
-     * This provides us with the flexibility to continue using HTML within our own lang templates where necessary.
-     *
-     * If the output is being set on an element directly with `dangerouslySetInnerHTML` or via Alerts, ensure
-     * that you pass the `escapeText` option to also escape any user data that may be interpolated within
-     * the template string.
-     *
-     * If the output is being passed to the <Text /> component, you do not need to set the `escapeText` option
-     * as this component handles escaping input by default.
-     */
-    getPhrase(namespace: string, phraseKey: string, options?: LanguageInterpolationOptions): string;
-    encloseNamespace(namespace: string): (phraseKey: string, options?: LanguageInterpolationOptions) => string;
-}
-export declare const LanguageService: StaticLanguageService;
-export {};
+import { ObjectHash } from 'backbone';
+import { BaseService } from 'libs/common/backbone/core/BaseService';
+interface LanguageInterpolationOptions {
+    smartCount?: number;
+    escapeText?: boolean;
+    [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;
+    /**
+     * This function manages two security and safety aspects of our templates:
+     * 1. Sanitization occurs for all phrase inputs and cannot be overriden.
+     * 2. Escaping of potentially dangerous markup is opt-in and can be enabled using the `escapeText` option.
+     *
+     * Both of these steps are applied to all values on the `options` object that will be used for interpolation.
+     * This provides us with the flexibility to continue using HTML within our own lang templates where necessary.
+     *
+     * If the output is being set on an element directly with `dangerouslySetInnerHTML` or via Alerts, ensure
+     * that you pass the `escapeText` option to also escape any user data that may be interpolated within
+     * the template string.
+     *
+     * If the output is being passed to the <Text /> component, you do not need to set the `escapeText` option
+     * as this component handles escaping input by default.
+     */
+    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/utils/FunctionHelper.d.ts

@@ -1,8 +1,8 @@
-import * as _ from 'underscore';
-export declare const FunctionHelper: {
-    debounce<T extends (...args: any) => any>(fn: T, wait: number, immediate?: boolean): T & _.Cancelable;
-    throttle<T_1 extends (...args: any) => any>(fn: T_1, wait: number, options?: _.ThrottleSettings): T_1 & _.Cancelable;
-    isFunction(object: any): object is Function;
-    useIdentity<T_2>(): (...args: any[]) => T_2;
-    memoize<T_3 = (...args: any) => any>(fn: T_3, hashFn?: (...args: any[]) => string): T_3;
-};
+import * as _ from 'underscore';
+export declare const FunctionHelper: {
+    debounce<T extends (...args: any) => any>(fn: T, wait: number, immediate?: boolean): T & _.Cancelable;
+    throttle<T_1 extends (...args: any) => any>(fn: T_1, wait: number, options?: _.ThrottleSettings): T_1 & _.Cancelable;
+    isFunction(object: any): object is Function;
+    useIdentity<T_2>(): (...args: any[]) => T_2;
+    memoize<T_3 = (...args: any) => any>(fn: T_3, hashFn?: (...args: any[]) => string): T_3;
+};

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

@@ -1,58 +1,58 @@
-export declare enum StorageType {
-    LocalStorage = "localStorage",
-    SessionStorage = "sessionStorage"
-}
-export interface StorageHelper {
-    get(key: string): any;
-    set(key: string, data: any): boolean;
-    remove(key: string): any;
-    length(): number;
-    clear(): any;
-    cacheSet(key: string, data: any, expire?: number): any;
-    cacheGet(key: string): any;
-    cacheExists(key: string): boolean;
-    cacheRemove(key: string): any;
-    cacheFlush(): void;
-}
-interface StaticBaseStorageHelperOptions {
-    type: StorageType;
-}
-declare abstract class StaticBaseStorageHelper implements StorageHelper {
-    private cachePrefix;
-    private expireTime;
-    private hasSupport;
-    private storage;
-    protected type: StorageType;
-    protected constructor(options: StaticBaseStorageHelperOptions);
-    get(key: string): any;
-    set(key: string, data: any): boolean;
-    remove(key: string): void;
-    length(): number;
-    clear(): void;
-    /**
-     * Caching Ops
-     */
-    cacheSet(key: string, data: any, expire?: number): boolean;
-    cacheGet(key: string): any;
-    cacheExists(key: string): boolean;
-    cacheRemove(key: string): void;
-    cacheFlush(): void;
-    /**
-     * Privates
-     */
-    private cacheClean;
-    private isExpired;
-    private getCurrentTime;
-    private hasBrowserSupport;
-}
-declare class StaticLocalStorageHelper extends StaticBaseStorageHelper {
-    protected static instance: StaticLocalStorageHelper;
-    static get Instance(): StaticLocalStorageHelper;
-}
-declare class StaticSessionStorageHelper extends StaticBaseStorageHelper {
-    protected static instance: StaticSessionStorageHelper;
-    static get Instance(): StaticSessionStorageHelper;
-}
-export declare const LocalStorageHelper: StaticLocalStorageHelper;
-export declare const SessionStorageHelper: StaticSessionStorageHelper;
-export {};
+export declare enum StorageType {
+    LocalStorage = "localStorage",
+    SessionStorage = "sessionStorage"
+}
+export interface StorageHelper {
+    get(key: string): any;
+    set(key: string, data: any): boolean;
+    remove(key: string): any;
+    length(): number;
+    clear(): any;
+    cacheSet(key: string, data: any, expire?: number): any;
+    cacheGet(key: string): any;
+    cacheExists(key: string): boolean;
+    cacheRemove(key: string): any;
+    cacheFlush(): void;
+}
+interface StaticBaseStorageHelperOptions {
+    type: StorageType;
+}
+declare abstract class StaticBaseStorageHelper implements StorageHelper {
+    private cachePrefix;
+    private expireTime;
+    private hasSupport;
+    private storage;
+    protected type: StorageType;
+    protected constructor(options: StaticBaseStorageHelperOptions);
+    get(key: string): any;
+    set(key: string, data: any): boolean;
+    remove(key: string): void;
+    length(): number;
+    clear(): void;
+    /**
+     * Caching Ops
+     */
+    cacheSet(key: string, data: any, expire?: number): boolean;
+    cacheGet(key: string): any;
+    cacheExists(key: string): boolean;
+    cacheRemove(key: string): void;
+    cacheFlush(): void;
+    /**
+     * Privates
+     */
+    private cacheClean;
+    private isExpired;
+    private getCurrentTime;
+    private hasBrowserSupport;
+}
+declare class StaticLocalStorageHelper extends StaticBaseStorageHelper {
+    protected static instance: StaticLocalStorageHelper;
+    static get Instance(): StaticLocalStorageHelper;
+}
+declare class StaticSessionStorageHelper extends StaticBaseStorageHelper {
+    protected static instance: StaticSessionStorageHelper;
+    static get Instance(): StaticSessionStorageHelper;
+}
+export declare const LocalStorageHelper: StaticLocalStorageHelper;
+export declare const SessionStorageHelper: StaticSessionStorageHelper;
+export {};

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

@@ -1,14 +1,14 @@
-import { ObjectHash } from 'backbone';
-interface FilterParams {
-    limit?: number;
-    cursor?: string;
-    before?: string;
-}
-export declare const UrlHelper: {
-    urlBuilder(base: string, queryStringObj: ObjectHash): string;
-    buildFilter(params: FilterParams): string;
-    makeHttps(url: string): string;
-    safeUrlConcat(baseUrl: string, path: string): string;
-    removeTrailingSlash(baseUrl: string): string;
-};
-export {};
+import { ObjectHash } from 'backbone';
+interface FilterParams {
+    limit?: number;
+    cursor?: string;
+    before?: string;
+}
+export declare const UrlHelper: {
+    urlBuilder(base: string, queryStringObj: ObjectHash): string;
+    buildFilter(params: FilterParams): string;
+    makeHttps(url: string): string;
+    safeUrlConcat(baseUrl: string, path: string): string;
+    removeTrailingSlash(baseUrl: string): string;
+};
+export {};

package/dist/libs/common/src/react/flight/FlightHelpers.d.ts

@@ -1,16 +1,16 @@
-import { Store } from 'redux';
-import { ApplicationState } from 'libs/common/react/interfaces/ApplicationState';
-import { Request, Response, Dispatch } from './interfaces';
-export declare function emptyResponse<T>(): Response<T>;
-export declare function getResponse<T>(state: ApplicationState, key: string): Response<T>;
-export declare function getFetch(dispatch: Dispatch, request: Request): () => void;
-export declare function fetch(dispatch: Dispatch, request: Request): void;
-export declare function hooklessFetch(store: Store, request: Request): void;
-export declare function useGetFetch(request: Request): () => void;
-interface GetResponseOptions {
-    optimize: boolean;
-}
-export declare function useGetResponse<T>(key: string, options?: GetResponseOptions): Response<T>;
-export declare function useBasicFetch<T>(request: Request, options?: GetResponseOptions): Response<T>;
-export declare function fetchAsync<T>(store: Store, request: Request): Promise<T>;
-export {};
+import { Store } from 'redux';
+import { ApplicationState } from 'libs/common/react/interfaces/ApplicationState';
+import { Request, Response, Dispatch } from './interfaces';
+export declare function emptyResponse<T>(): Response<T>;
+export declare function getResponse<T>(state: ApplicationState, key: string): Response<T>;
+export declare function getFetch(dispatch: Dispatch, request: Request): () => void;
+export declare function fetch(dispatch: Dispatch, request: Request): void;
+export declare function hooklessFetch(store: Store, request: Request): void;
+export declare function useGetFetch(request: Request): () => void;
+interface GetResponseOptions {
+    optimize: boolean;
+}
+export declare function useGetResponse<T>(key: string, options?: GetResponseOptions): Response<T>;
+export declare function useBasicFetch<T>(request: Request, options?: GetResponseOptions): Response<T>;
+export declare function fetchAsync<T>(store: Store, request: Request): Promise<T>;
+export {};

package/dist/libs/common/src/react/flight/FlightMiddleware.d.ts

@@ -1,12 +1,12 @@
-import { Dispatch, Middleware, MiddlewareAPI, AnyAction } from 'redux';
-import { HashObject } from 'libs/common/react/interfaces/HashObject';
-import { ApplicationState } from 'libs/common/react/interfaces/ApplicationState';
-import { HttpRequest } from './interfaces';
-export declare type MiddlewareApi = MiddlewareAPI<Dispatch<AnyAction>, ApplicationState>;
-interface MiddlewareOptions {
-    fetchData: HttpRequest;
-    bootstrappedData?: HashObject;
-    defaultExpiryTime?: number;
-}
-export declare function createMiddleware(options: MiddlewareOptions): Middleware<HashObject, ApplicationState, Dispatch<AnyAction>>;
-export {};
+import { Dispatch, Middleware, MiddlewareAPI, AnyAction } from 'redux';
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+import { ApplicationState } from 'libs/common/react/interfaces/ApplicationState';
+import { HttpRequest } from './interfaces';
+export declare type MiddlewareApi = MiddlewareAPI<Dispatch<AnyAction>, ApplicationState>;
+interface MiddlewareOptions {
+    fetchData: HttpRequest;
+    bootstrappedData?: HashObject;
+    defaultExpiryTime?: number;
+}
+export declare function createMiddleware(options: MiddlewareOptions): Middleware<HashObject, ApplicationState, Dispatch<AnyAction>>;
+export {};

package/dist/libs/common/src/react/flight/FlightReducer.d.ts

@@ -1,2 +1,2 @@
-import { FlightState, Action } from './interfaces';
-export declare function FlightReducer(state: FlightState, action: Action): FlightState;
+import { FlightState, Action } from './interfaces';
+export declare function FlightReducer(state: FlightState, action: Action): FlightState;

package/dist/libs/common/src/react/flight/FlightSimulator.d.ts

@@ -1,24 +1,24 @@
-import { HashObject } from 'libs/common/react/interfaces/HashObject';
-/**
- * This is a very basic implementation and we almost definitely will
- * need to extend upon this, so please don't be afraid to add to it.
- */
-export declare const Simulator: {
-    getAll(name: string, init?: HashObject[]): HashObject[];
-    get(name: string, id: string): HashObject;
-    create(name: string, item: HashObject): HashObject;
-    update(name: string, item: HashObject): HashObject;
-    delete(name: string, ids: string | string[]): void;
-    /**
-     *
-     * @param objectName - the name your object can be found under in local storage (e.g. `classrooms`).
-     * @param objectId - the id of the object you want to associate something to.
-     * @param assocName - the field name of your assoc, which will go on your object (e.g. `students`).
-     * @param flightSimName - the name your assoc objects will be created under (e.g. `school:students`).
-     * @param assocObject - the object you're creating and associating.
-     *
-     * Having a difficult time coming up with good param names here. Feel free to update, ty
-     */
-    assoc(objectName: string, objectId: string, assocName: string, flightSimName: string, assocObjects: any | any[]): any | any[];
-    dissoc(objectName: string, objectId: string, assocName: string, ids: string | string[]): HashObject[];
-};
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+/**
+ * This is a very basic implementation and we almost definitely will
+ * need to extend upon this, so please don't be afraid to add to it.
+ */
+export declare const Simulator: {
+    getAll(name: string, init?: HashObject[]): HashObject[];
+    get(name: string, id: string): HashObject;
+    create(name: string, item: HashObject): HashObject;
+    update(name: string, item: HashObject): HashObject;
+    delete(name: string, ids: string | string[]): void;
+    /**
+     *
+     * @param objectName - the name your object can be found under in local storage (e.g. `classrooms`).
+     * @param objectId - the id of the object you want to associate something to.
+     * @param assocName - the field name of your assoc, which will go on your object (e.g. `students`).
+     * @param flightSimName - the name your assoc objects will be created under (e.g. `school:students`).
+     * @param assocObject - the object you're creating and associating.
+     *
+     * Having a difficult time coming up with good param names here. Feel free to update, ty
+     */
+    assoc(objectName: string, objectId: string, assocName: string, flightSimName: string, assocObjects: any | any[]): any | any[];
+    dissoc(objectName: string, objectId: string, assocName: string, ids: string | string[]): HashObject[];
+};

package/dist/libs/common/src/react/flight/constants/Actions.d.ts

@@ -1,7 +1,7 @@
-export declare const Actions: {
-    API_REQUEST: string;
-    API_RESPONSE: string;
-    API_ERROR: string;
-    INVALIDATE: string;
-    UPDATE: string;
-};
+export declare const Actions: {
+    API_REQUEST: string;
+    API_RESPONSE: string;
+    API_ERROR: string;
+    INVALIDATE: string;
+    UPDATE: string;
+};

package/dist/libs/common/src/react/flight/constants/index.d.ts

@@ -1 +1 @@
-export * from './Actions';
+export * from './Actions';

package/dist/libs/common/src/react/flight/data-layers/AjaxRequest.d.ts

@@ -1,2 +1,2 @@
-import { HttpRequestOptions } from '../interfaces';
-export declare function ajaxRequest(options: HttpRequestOptions): void;
+import { HttpRequestOptions } from '../interfaces';
+export declare function ajaxRequest(options: HttpRequestOptions): void;

package/dist/libs/common/src/react/flight/data-layers/index.d.ts

@@ -1 +1 @@
-export * from './AjaxRequest';
+export * from './AjaxRequest';

package/dist/libs/common/src/react/flight/enums/RequestStatus.d.ts

@@ -1,6 +1,6 @@
-export declare enum RequestStatus {
-    None = "None",
-    Fetching = "Fetching",
-    Success = "Success",
-    Error = "Error"
-}
+export declare enum RequestStatus {
+    None = "None",
+    Fetching = "Fetching",
+    Success = "Success",
+    Error = "Error"
+}

package/dist/libs/common/src/react/flight/enums/index.d.ts

@@ -1 +1 @@
-export * from './RequestStatus';
+export * from './RequestStatus';

package/dist/libs/common/src/react/flight/index.d.ts

@@ -1,9 +1,9 @@
-export * from './constants';
-export * from './enums';
-export * from './interfaces';
-export * from './data-layers';
-export * from './normalizer';
-export * from './FlightHelpers';
-export * from './FlightMiddleware';
-export * from './FlightReducer';
-export * from './FlightSimulator';
+export * from './constants';
+export * from './enums';
+export * from './interfaces';
+export * from './data-layers';
+export * from './normalizer';
+export * from './FlightHelpers';
+export * from './FlightMiddleware';
+export * from './FlightReducer';
+export * from './FlightSimulator';

package/dist/libs/common/src/react/flight/interfaces/Action.d.ts

@@ -1,28 +1,28 @@
-import { NormalizedEntities, Request, Normalized } from '..';
-import { Xhr } from 'libs/common/backbone/interfaces/Xhr';
-interface BaseAction {
-    type: string;
-    request: Request;
-}
-export interface RequestAction extends BaseAction {
-}
-interface BaseResponseAction extends BaseAction {
-    timestamp: number;
-    xhr?: Xhr;
-}
-export interface ResponseAction extends BaseResponseAction {
-    result: Normalized;
-    entities: NormalizedEntities;
-}
-export interface ErrorAction extends BaseResponseAction {
-    errorResponse?: any;
-}
-export interface InvalidateAction extends BaseAction {
-    keys?: string | string[];
-}
-export interface UpdateAction extends BaseAction {
-    result: Normalized;
-    entities: NormalizedEntities;
-}
-export declare type Action = RequestAction | ResponseAction | ErrorAction | InvalidateAction;
-export {};
+import { NormalizedEntities, Request, Normalized } from '..';
+import { Xhr } from 'libs/common/backbone/interfaces/Xhr';
+interface BaseAction {
+    type: string;
+    request: Request;
+}
+export interface RequestAction extends BaseAction {
+}
+interface BaseResponseAction extends BaseAction {
+    timestamp: number;
+    xhr?: Xhr;
+}
+export interface ResponseAction extends BaseResponseAction {
+    result: Normalized;
+    entities: NormalizedEntities;
+}
+export interface ErrorAction extends BaseResponseAction {
+    errorResponse?: any;
+}
+export interface InvalidateAction extends BaseAction {
+    keys?: string | string[];
+}
+export interface UpdateAction extends BaseAction {
+    result: Normalized;
+    entities: NormalizedEntities;
+}
+export declare type Action = RequestAction | ResponseAction | ErrorAction | InvalidateAction;
+export {};

package/dist/libs/common/src/react/flight/interfaces/Dispatch.d.ts

@@ -1,3 +1,3 @@
-/// <reference types="react" />
-import { RequestAction } from './Action';
-export declare type Dispatch = React.Dispatch<RequestAction>;
+/// <reference types="react" />
+import { RequestAction } from './Action';
+export declare type Dispatch = React.Dispatch<RequestAction>;

package/dist/libs/common/src/react/flight/interfaces/FlightState.d.ts

@@ -1,23 +1,23 @@
-import { RequestStatus } from '../enums';
-import { Request } from './Request';
-import { HashObject } from 'libs/common/react/interfaces/HashObject';
-export interface FlightState {
-    readonly entities: NormalizedEntities;
-    readonly resources: Resources;
-}
-export interface NormalizedEntities {
-    readonly [key: string]: HashObject;
-}
-export interface Resource {
-    readonly request: Request;
-    readonly status: RequestStatus;
-    readonly response?: string | string[] | HashObject | HashObject[];
-    readonly errorResponse?: any;
-    readonly timestamp?: number;
-    readonly statusCode?: number;
-    readonly entityIds?: string[];
-    readonly hasCompleted?: boolean;
-}
-export interface Resources {
-    readonly [key: string]: Resource;
-}
+import { RequestStatus } from '../enums';
+import { Request } from './Request';
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+export interface FlightState {
+    readonly entities: NormalizedEntities;
+    readonly resources: Resources;
+}
+export interface NormalizedEntities {
+    readonly [key: string]: HashObject;
+}
+export interface Resource {
+    readonly request: Request;
+    readonly status: RequestStatus;
+    readonly response?: string | string[] | HashObject | HashObject[];
+    readonly errorResponse?: any;
+    readonly timestamp?: number;
+    readonly statusCode?: number;
+    readonly entityIds?: string[];
+    readonly hasCompleted?: boolean;
+}
+export interface Resources {
+    readonly [key: string]: Resource;
+}

package/dist/libs/common/src/react/flight/interfaces/HttpRequest.d.ts

@@ -1,27 +1,27 @@
-import { HttpVerbs } from 'libs/common/backbone/enums/HttpVerbs';
-import { HashObject } from 'libs/common/react/interfaces/HashObject';
-import { Xhr } from 'libs/common/backbone/interfaces/Xhr';
-interface SuccessFunction {
-    (data: HashObject, xhr: Xhr): void;
-}
-interface ErrorFunction {
-    (xhr: Xhr): void;
-}
-interface AlwaysFunction {
-    (): void;
-}
-export interface HttpRequestOptions {
-    resource: string;
-    type: HttpVerbs;
-    data?: HashObject;
-    success: SuccessFunction;
-    error: ErrorFunction;
-    always?: AlwaysFunction;
-    headers?: {
-        authorization?: string;
-    };
-}
-export interface HttpRequest {
-    (options: HttpRequestOptions): void;
-}
-export {};
+import { HttpVerbs } from 'libs/common/backbone/enums/HttpVerbs';
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+import { Xhr } from 'libs/common/backbone/interfaces/Xhr';
+interface SuccessFunction {
+    (data: HashObject, xhr: Xhr): void;
+}
+interface ErrorFunction {
+    (xhr: Xhr): void;
+}
+interface AlwaysFunction {
+    (): void;
+}
+export interface HttpRequestOptions {
+    resource: string;
+    type: HttpVerbs;
+    data?: HashObject;
+    success: SuccessFunction;
+    error: ErrorFunction;
+    always?: AlwaysFunction;
+    headers?: {
+        authorization?: string;
+    };
+}
+export interface HttpRequest {
+    (options: HttpRequestOptions): void;
+}
+export {};

package/dist/libs/common/src/react/flight/interfaces/NormalizeOptions.d.ts

@@ -1,4 +1,4 @@
-export interface NormalizeOptions {
-    namespace?: string;
-    idAttribute?: string;
-}
+export interface NormalizeOptions {
+    namespace?: string;
+    idAttribute?: string;
+}

package/dist/libs/common/src/react/flight/interfaces/NormalizedData.d.ts

@@ -1,7 +1,7 @@
-import { NormalizedEntities } from './FlightState';
-import { HashObject } from 'libs/common/react/interfaces/HashObject';
-export declare type Normalized = string | string[] | HashObject | HashObject[];
-export interface NormalizedData {
-    result: Normalized;
-    entities: NormalizedEntities;
-}
+import { NormalizedEntities } from './FlightState';
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+export declare type Normalized = string | string[] | HashObject | HashObject[];
+export interface NormalizedData {
+    result: Normalized;
+    entities: NormalizedEntities;
+}