@clickview/curator 1.0.14-rc.0 → 1.0.15-dev.0

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

@@ -0,0 +1,11 @@
+import { Dispatch, Middleware, AnyAction } from 'redux';
+import { HashObject } from "../interfaces/HashObject";
+import { ApplicationState } from "../interfaces/ApplicationState";
+import { HttpRequest } from './interfaces';
+interface MiddlewareOptions {
+    fetchData: HttpRequest;
+    bootstrappedData?: HashObject;
+    defaultExpiryTime?: number;
+}
+export declare function createMiddleware(options: MiddlewareOptions): Middleware<{}, ApplicationState, Dispatch<AnyAction>>;
+export {};

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

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

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

@@ -0,0 +1,24 @@
+import { HashObject } from "../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<any>[]): HashObject<any>[];
+    get(name: string, id: string): HashObject<any>;
+    create(name: string, item: HashObject<any>): HashObject<any>;
+    update(name: string, item: HashObject<any>): HashObject<any>;
+    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;
+    dissoc(objectName: string, objectId: string, assocName: string, ids: string | string[]): HashObject<any>[];
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +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';

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

@@ -0,0 +1,28 @@
+import { NormalizedEntities, Request, Normalized } from '..';
+import { Xhr } from "../../../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

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

@@ -0,0 +1,22 @@
+import { RequestStatus } from '../enums';
+import { Request } from './Request';
+import { HashObject } from "../../interfaces/HashObject";
+export interface FlightState {
+    readonly entities: NormalizedEntities;
+    readonly resources: Resources;
+}
+export interface NormalizedEntities {
+    readonly [key: string]: object;
+}
+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[];
+}
+export interface Resources {
+    readonly [key: string]: Resource;
+}

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

@@ -0,0 +1,24 @@
+import { HttpVerbs } from "../../../backbone/enums/HttpVerbs";
+import { HashObject } from "../../interfaces/HashObject";
+import { Xhr } from "../../../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;
+}
+export interface HttpRequest {
+    (options: HttpRequestOptions): void;
+}
+export {};

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { HttpVerbs } from "../../../backbone/enums/HttpVerbs";
+import { HashObject } from "../../interfaces/HashObject";
+import { Xhr, SimulatedXhr } from "../../../backbone/interfaces/Xhr";
+import { NormalizeOptions } from './NormalizeOptions';
+import { Resources } from './FlightState';
+import { UpdateStateOptions } from './UpdateStateOptions';
+export interface Request {
+    key: string;
+    url: string;
+    type?: HttpVerbs;
+    expiryTime?: number;
+    data?: HashObject | HashObject[];
+    normalize?: boolean;
+    normalizeOptions?: NormalizeOptions;
+    formatData?: (data: HashObject | HashObject[]) => HashObject | HashObject[];
+    bootstrapName?: string;
+    invalidationKeys?: string | string[];
+    updateState?: UpdateStateOptions | UpdateStateOptions[];
+    success?: (data: HashObject | HashObject[] | number) => void;
+    error?: (Xhr: Xhr) => void;
+    always?: () => void;
+    maintainState?: (resources: Resources) => Resources;
+}
+export interface SimulatedRequest extends Request {
+    successResponse?: () => (HashObject | HashObject[]);
+    errorResponse?: () => SimulatedXhr;
+    timeout?: number;
+    noResponse?: boolean;
+}

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

@@ -0,0 +1,9 @@
+import { HttpStatus } from "../../../backbone/enums/HttpStatus";
+export interface Response<T> {
+    data?: T;
+    statusCode?: HttpStatus;
+    shouldFetch: boolean;
+    isFetching: boolean;
+    hasError: boolean;
+    isComplete: boolean;
+}

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

@@ -0,0 +1,15 @@
+import { HashObject } from "../../interfaces/HashObject";
+export interface UpdateStateOptions {
+    keys: string | string[];
+    /**
+     * updateData takes a hash where the keys are keys for resources
+     * from the application state that match the keys above.
+     * The value is the denormalized (where applicable) data corresponding
+     * to that resource.
+     */
+    updateData: (data: {
+        [key: string]: HashObject;
+    }) => {
+        [key: string]: HashObject;
+    };
+}

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

@@ -0,0 +1,9 @@
+export * from './Request';
+export * from './Action';
+export * from './FlightState';
+export * from './HttpRequest';
+export * from './NormalizedData';
+export * from './Response';
+export * from './NormalizeOptions';
+export * from './Dispatch';
+export * from './UpdateStateOptions';

package/dist/libs/common/src/react/flight/normalizer/Denormalizer.d.ts

@@ -0,0 +1,3 @@
+import { HashObject } from "../../interfaces/HashObject";
+import { NormalizedEntities, Normalized } from '../interfaces';
+export declare function denormalize(ids: Normalized, collection: NormalizedEntities): HashObject | HashObject[];

package/dist/libs/common/src/react/flight/normalizer/Normalizer.d.ts

@@ -0,0 +1,8 @@
+import { HashObject } from "../../interfaces/HashObject";
+import { NormalizeOptions, NormalizedData } from '../interfaces';
+/**
+ * This is a pure function, while normalize() above is not.
+ * normalize() manipulates it's parameters. If we ever write unit tests for this
+ * only test this function, not the above ones.
+ */
+export declare function normalize(data: HashObject | HashObject[], options?: NormalizeOptions): NormalizedData;

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

@@ -0,0 +1,2 @@
+export * from './Normalizer';
+export * from './Denormalizer';

package/dist/libs/common/src/react/flight/utils/SimulatorHelper.d.ts

@@ -0,0 +1,5 @@
+import { Request, HttpRequestOptions } from '../interfaces';
+export declare const SimulatorHelper: {
+    isSimulated(request: Request): boolean;
+    simulateFetchData(options: HttpRequestOptions, request: Request): void;
+};

package/dist/libs/common/src/react/flight/utils/StateHelper.d.ts

@@ -0,0 +1,11 @@
+import { FlightState } from '../interfaces';
+export declare const StateHelper: {
+    /**
+     * Returns a map of keys state.resources which match the keys param.
+     *
+     * @param state FlightState.
+     * @param keys a key or array of keys to match on.
+     * @param requestKey optionally include the current request key to exclude it from the map.
+     */
+    getMatchingKeyMap(state: FlightState, keys: string | string[], requestKey?: string): any;
+};

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

@@ -0,0 +1,2 @@
+export * from './StateHelper';
+export * from './SimulatorHelper';

package/dist/libs/common/src/react/hooks/UseBulkFetch.d.ts

@@ -0,0 +1,10 @@
+import { FetchOptions } from "../utils/FetchHelper";
+/**
+ * Hook function to make multiple data calls using the useEffect hook.
+ *
+ * @param optionCollection - array of FetchOptions, one for each data call.
+ * @param dependencies - values from the component (e.g. state, props and functions) that are used
+ * inside the effect hook. The hook will only run when a dependency changes. If an empty array is
+ * passed in, the hook will just run once. If null is passed in, the hook will run on every update.
+ */
+export declare function useBulkFetch(fetchOptions: FetchOptions[], dependencies: any[], shouldFetch?: boolean): void;

package/dist/libs/common/src/react/hooks/UseFetch.d.ts

@@ -0,0 +1,10 @@
+import { FetchOptions } from "../utils/FetchHelper";
+/**
+ * Hook function to fetch data using the useEffect hook.
+ *
+ * @param options - FetchOptions
+ * @param dependencies - values from the component (e.g. state, props and functions) that are used
+ * inside the effect hook. The hook will only run when a dependency changes. If an empty array is
+ * passed in, the hook will just run once. If null is passed in, the hook will run on every update.
+ */
+export declare function useFetch(options: FetchOptions, dependencies: any[], shouldFetch?: boolean): void;

package/dist/libs/common/src/react/hooks/UseInstance.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hook to retrieve an instance from InstanceManager.
+ * It handles releasing the instance in the cleanup function.
+ * @param instanceName
+ */
+export declare function useInstance<T>(instanceName: string): T;

package/dist/libs/common/src/react/hooks/UseService.d.ts

@@ -0,0 +1,2 @@
+import { BaseService } from "../../backbone/core/BaseService";
+export declare function useService<T extends BaseService>(serviceName: string): T;

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

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

package/dist/libs/common/src/react/interfaces/ApplicationData.d.ts

@@ -0,0 +1,3 @@
+export interface ApplicationData {
+    version: string;
+}

package/dist/libs/common/src/react/interfaces/ApplicationState.d.ts

@@ -0,0 +1,8 @@
+import { ApplicationData } from "./ApplicationData";
+import { FlightState } from "../flight/interfaces/FlightState";
+import { HashObject } from "./HashObject";
+export interface ApplicationState {
+    readonly flightData: FlightState;
+    readonly applicationData: ApplicationData;
+    readonly viewModelData: HashObject;
+}

package/dist/libs/common/src/react/interfaces/BaseReducerActions.d.ts

@@ -0,0 +1,4 @@
+export interface ReducerActions<TActionType, TPayloadType = any> {
+    type: TActionType;
+    payload?: TPayloadType;
+}

package/dist/libs/common/src/react/interfaces/HashObject.d.ts

@@ -0,0 +1,3 @@
+export interface HashObject<T = any> {
+    [key: string]: T;
+}

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

@@ -0,0 +1,4 @@
+export * from './ApplicationData';
+export * from './ApplicationState';
+export * from './BaseReducerActions';
+export * from './HashObject';

package/dist/libs/common/src/react/utils/ArrayHelper.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="react" />
+import * as _ from 'underscore';
+declare type Iterator<T, TResult = T> = (value: T, index: number, list: T[]) => TResult;
+export declare const ArrayHelper: {
+    first<T>(arr: T[]): T;
+    firstFew<T_1>(arr: T_1[], count: number): T_1[];
+    last<T_2>(arr: T_2[]): T_2;
+    lastFew<T_3>(arr: T_3[], count: number): T_3[];
+    max<T_4, TResult = T_4>(arr: T_4[], iterator?: Iterator<T_4, TResult>): T_4;
+    cloneAndReplaceAtIdx<T_5>(arr: T_5[], idx: number, newVal: T_5, defaultValue?: any): T_5[];
+    moveItem<T_6>(arr: T_6[], fromIdx: number, toIdx: number): T_6[];
+    isEmpty<T_7>(arr: T_7[]): boolean;
+    findIndex<T_8>(arr: T_8[], predicate: (item: T_8) => boolean): number;
+    where<T_9, U extends {}>(arr: T_9[], properties: U): T_9[];
+    groupBy<T_10>(arr: T_10[], property: string): {
+        [index: string]: T_10[];
+    };
+    flatten<T_11>(arr: T_11[], shallow?: boolean): T_11[];
+    intersection<T_12>(...arrays: T_12[][]): T_12[];
+    /**
+     * Add a value to an array, or if it is already in the array, remove it.
+     *
+     * @param arr array of values
+     * @param value value to be added or removed.
+     */
+    addOrRemove<T_13 = import("react").Key>(arr: T_13[], value: T_13): T_13[];
+    addOrRemoveImmutable<T_14>(arr: T_14[], value: T_14): T_14[];
+    /**
+     * Returns a (stably) sorted copy of list, ranked in ascending order
+     * by the results of running each value through iteratee.
+     *
+     * @param arr array of values
+     * @param iteratee an iterator function or a string name of the property to sort by.
+     */
+    sortBy<T_15 extends {}, TSort = T_15>(arr: T_15[], iteratee?: Iterator<T_15, TSort> | keyof T_15): T_15[];
+    chunk<T_16>(array: _.Collection<T_16>, count: number): T_16[][];
+    uniq<T_17>(array: _.List<T_17>): T_17[];
+};
+export {};

package/dist/libs/common/src/react/utils/FetchHelper.d.ts

@@ -0,0 +1,50 @@
+import { BaseDataService } from "../../backbone/services/BaseDataService";
+import { DataServiceError } from "../../backbone/interfaces/DataServiceError";
+export interface FetchOptions {
+    /**
+     * Name of the required data service for fetchData.
+     */
+    dataServiceName: string;
+    /**
+     * @deprecated
+     * DataChannelName is now referenced directly from the data service
+     * instance itself.
+     *
+     * The channelName of the data service's dataChannel.
+     */
+    dataChannelName?: string;
+    /**
+     * The eventPrefix for the data being fetched.
+     */
+    eventPrefix: string;
+    /**
+     * Callback fn to fetch data give a data service instance.
+     */
+    fetchData: (dataService: BaseDataService) => any;
+    /**
+     * Callback fn to set the data when it is returned from the data service.
+     * This will usually be a setState function.
+     *
+     * Deliberately a loose Function type so that we can use React setState setters.
+     */
+    setData: Function;
+    /**
+     * onError callback fn.
+     */
+    onError?: (error: DataServiceError) => void;
+    /**
+     * The eventPrefix for the corresponding delete event for the object being
+     * fetched. This is used to listen to the delete event so that any cache
+     * invalidation listeners can be unbound to prevent an attempt to re-fetch
+     * the now deleted data.
+     */
+    deleteEventPrefix?: string;
+}
+export declare const FetchHelper: {
+    /**
+     * Helper function to fetch data inside a hook. Listeners are bound to the data channel
+     * request and sync events, then the request is sent. If data is returned it will be
+     * set using the setData function passed in.
+     */
+    fetch<T extends BaseDataService>(options: FetchOptions, setDataFetched: (fetched: boolean) => void): () => void;
+};

package/dist/libs/common/src/react/utils/ObjectHelper.d.ts

@@ -0,0 +1,10 @@
+export declare const ObjectHelper: {
+    isEmpty(obj: any): boolean;
+    values(obj: any): any[];
+    keys(obj: any): string[];
+    deepClone(obj: any): any;
+    getEnumKeys(obj: any): any[];
+    isObject(obj: any): boolean;
+    isEqual(obj1: any, obj2: any): boolean;
+    omit(obj: any, keys: string[]): any;
+};

package/dist/libs/common/src/react/utils/RandomHelper.d.ts

@@ -0,0 +1,3 @@
+export declare const RandomHelper: {
+    getRandomInt(max?: number): number;
+};

package/dist/libs/common/src/react/utils/TimeHelper.d.ts

@@ -0,0 +1,7 @@
+declare type TimeOfDay = 'morning' | 'afternoon' | 'evening';
+export declare const TimeHelper: {
+    currentTimestamp(): number;
+    isExpired(timestamp: number, cacheDuration: number): boolean;
+    currentTimeOfDay(currentTime?: Date): TimeOfDay;
+};
+export {};

package/dist/libs/common/src/react/utils/TypeHelper.d.ts

@@ -0,0 +1,5 @@
+export declare const TypeHelper: {
+    isNumber(obj: any): boolean;
+    isString(obj: any): boolean;
+    isType(obj: any, type: string): boolean;
+};

package/dist/libs/shared/src/apps/notifications/enums/NotificationType.d.ts

@@ -0,0 +1,16 @@
+export declare enum NotificationType {
+    ExchangeVideoAvailable = "exchange-video-available",
+    WorkspaceVideoAvailable = "workspace-video-available",
+    Marketing = "marketing",
+    EditedVideoAvailable = "edited-video-available",
+    VideoRequestAvailable = "pay-tv-video-available",
+    VideoRequestDenied = "pay-tv-video-denied",
+    VideoReviewReminder = "term-update-review-reminder",
+    VideoReviewAddedToLibrary = "term-update-review-videos-added-to-library",
+    CustomLibraryVideoAvailable = "custom-library-video-available",
+    VideoProcessingFailed = "video-processing-failed",
+    StaffRequest = "new-staff-request",
+    StaffRequestFulfilled = "staff-request-fulfilment",
+    ChapterMergeSuccess = "media-concatenate-success",
+    SuggestEdit = "suggest-an-edit"
+}

package/dist/libs/shared/src/apps/playlists/enums/PlaylistSortType.d.ts

@@ -0,0 +1,5 @@
+export declare enum PlaylistSortType {
+    Newest = "newest",
+    RecentlyUpdated = "recentlyupdated",
+    AtoZ = "atoz"
+}

package/dist/libs/shared/src/apps/playlists/interfaces/data-requests/CreateOrUpdatePlaylistRequest.d.ts

@@ -0,0 +1,7 @@
+import { Cover, Banner } from "../../../../interfaces";
+export interface CreateOrUpdatePlaylistRequest {
+    name: string;
+    description?: string;
+    cover?: Cover;
+    banner?: Banner;
+}

package/dist/libs/shared/src/apps/playlists/interfaces/data-requests/index.d.ts

@@ -0,0 +1 @@
+export * from './CreateOrUpdatePlaylistRequest';

package/dist/libs/shared/src/apps/playlists/interfaces/identifiers/PlaylistCollectionIdentifier.d.ts

@@ -0,0 +1,5 @@
+import { BaseCollectionIdentifier } from "../../../../../../common/src/backbone/interfaces";
+import { PlaylistSortType } from "../../enums/PlaylistSortType";
+export declare class PlaylistCollectionIdentifier extends BaseCollectionIdentifier<PlaylistSortType> {
+    constructor(sort?: PlaylistSortType, cursor?: string);
+}

package/dist/libs/shared/src/apps/playlists/interfaces/identifiers/PlaylistVideoCollectionIdentifier.d.ts

@@ -0,0 +1,4 @@
+import { BaseCollectionIdentifier } from "../../../../../../common/src/backbone/interfaces";
+export declare class PlaylistVideoCollectionIdentifier extends BaseCollectionIdentifier {
+    constructor(id: string, cursor?: string);
+}

package/dist/libs/shared/src/apps/playlists/interfaces/identifiers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './PlaylistCollectionIdentifier';
+export * from './PlaylistVideoCollectionIdentifier';

package/dist/libs/shared/src/apps/playlists/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data-requests';
+export * from './identifiers';

package/dist/libs/shared/src/components/actions/ActionButton.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { ActionOptions } from './Actions';
+interface ActionButtonProps {
+    actionOptions: ActionOptions;
+}
+export declare function ActionButton(props: React.PropsWithChildren<ActionButtonProps>): JSX.Element;
+export {};

package/dist/libs/shared/src/components/actions/Actions.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { Core } from "../../../../common/src/backbone";
+import { BaseObject } from "../../interfaces";
+export interface ActionOptions {
+    label: string;
+    appLink?: Core.AppLink;
+    onClick?: (e: React.MouseEvent) => void;
+    svgName?: string;
+    className?: string;
+    button?: boolean;
+    tooltip?: string;
+}
+export declare type ActionGenerator = (obj: BaseObject) => ActionOptions[];
+interface ActionsProps {
+    actions: ActionOptions[];
+    className?: string;
+    actionsDropdownClassName?: string;
+    sortComponent?: JSX.Element;
+}
+export declare function Actions(props: ActionsProps): JSX.Element;
+export {};

package/dist/libs/shared/src/components/actions/ActionsDropdown.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { ActionOptions } from './Actions';
+interface ActionsDropdownProps {
+    actions: ActionOptions[];
+    className?: string;
+    dropdownToggleClassName?: string;
+}
+export declare function ActionsDropdown(props: ActionsDropdownProps): React.ReactElement;
+export declare namespace ActionsDropdown {
+    var defaultProps: {
+        dropdownToggleClassName: string;
+    };
+}
+export {};

package/dist/libs/shared/src/components/alert/Alert.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { BaseAlert } from "../../../../common/src/backbone/services/BaseAlertService";
+export interface AlertProps {
+    alert: BaseAlert;
+    closeAlert: () => void;
+}
+export declare function Alert({ alert, closeAlert }: AlertProps): React.ReactElement;

package/dist/libs/shared/src/components/alert/AlertContent.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { AlertProps } from './Alert';
+interface AlertContentProps extends AlertProps {
+    svgName: string;
+    svgClassName: string;
+}
+export declare function AlertContent(props: AlertContentProps): React.ReactElement;
+export {};

package/dist/libs/shared/src/components/alert/AlertList.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { BaseAlert } from "../../../../common/src/backbone/services/BaseAlertService";
+interface AlertListProps {
+    alerts: BaseAlert[];
+    removeAlert: (id: string) => void;
+}
+export declare function AlertList({ alerts, removeAlert }: AlertListProps): React.ReactElement;
+export {};

package/dist/libs/shared/src/components/app-link/AppLink.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { Core } from "../../../../common/src/backbone";
+export interface AppLinkProps {
+    appLink: Core.AppLink;
+    className?: string;
+    tag?: 'a' | 'button';
+    onClick?: (e: React.MouseEvent) => void;
+}
+export declare function AppLink(props: React.PropsWithChildren<AppLinkProps>): React.ReactElement;