@monterosa/sdk-interact-kit 2.0.0-rc.3 → 2.0.0-rc.5

package/dist/sdk-interact-kit.d.ts

@@ -0,0 +1,1342 @@
+/**
+ * Manages interactive elements such as polls, votes, and leaderboards.
+ *
+ * @packageDocumentation
+ */
+
+import { Connect as Connect_2 } from '@monterosa/sdk-connect-kit';
+import { Emitter } from '@monterosa/sdk-util';
+import { MonterosaKit } from '@monterosa/sdk-core';
+import { MonterosaSdk } from '@monterosa/sdk-core';
+import { Unsubscribe } from '@monterosa/sdk-util';
+
+/**
+ * An `Answer` contains data of the user answer. Can be used to manage number of
+ * votes that the user placed for a specific option.
+ */
+export declare class Answer {
+    private _answers;
+    constructor(answers?: AnswerValue[]);
+    /**
+     * The array of user answers
+     */
+    get answers(): AnswerValue[];
+    /**
+     * Instantiate Answer class with the provided options indices. Number
+     * of votes will be set to 1 for all options
+     *
+     * @example
+     * ```javascript
+     * // user votes for the first and fourth options
+     * const answer = Answer.fromIndices([0, 3]);
+     * ```
+     *
+     * @param indices - The array of option indices
+     */
+    static fromIndices(indices: number[]): Answer;
+    /**
+     * Adds a vote for the provided option index
+     *
+     * @param option - The index of the option, starting with 0
+     * @param value - The number of votes that will be placed against the option
+     */
+    set(option: number, value: number): Answer;
+    /**
+     * Removes the vote for the provided option index
+     *
+     * @param option - The index of the option, starting with 0
+     */
+    remove(option: number): Answer;
+    /** @internal */
+    toJSON(): AnswerValue[];
+    /** @internal */
+    static fromJSON(value: string): Answer;
+}
+
+/**
+ * Submits an Element answer as a spread of options indices
+ *
+ * @example
+ * ```javascript
+ * // vote for the first and third options
+ * answer(element, 0, 2);
+ * ```
+ *
+ * @param element - An Element instance
+ * @param indices - Spread of options indices (starting with 0) to vote for
+ */
+export declare function answer(element: InteractElement, ...indices: number[]): void;
+
+/**
+ * Submits an Element answer as an array of options indices
+ *
+ * @example
+ * ```javascript
+ * // vote for the first and third options
+ * answer(element, [0, 2]);
+ * ```
+ *
+ * @param element - An Element instance
+ * @param arrayOfIndices - Array of options indices (starting with 0) to vote for
+ */
+export declare function answer(element: InteractElement, arrayOfIndices: number[]): void;
+
+/**
+ * Submits an Element answer as a spread of answer values
+ *
+ * @example
+ * ```javascript
+ * // vote for the first and third options
+ * answer(element,
+ *   {option: 0, value: 1},
+ *   {option: 2, value: 1},
+ * );
+ * ```
+ *
+ * @param element - An Element instance
+ * @param answerValues - Spread of answer values to vote for
+ */
+export declare function answer(element: InteractElement, ...answerValues: AnswerValue[]): void;
+
+/**
+ * Submits an Element answer as an array of answer values
+ *
+ * @example
+ * ```javascript
+ * // vote for the first and third options
+ * answer(element, [
+ *   {option: 0, value: 1},
+ *   {option: 2, value: 1},
+ * ]);
+ * ```
+ *
+ * @param element - An Element instance
+ * @param arrayOfAnswerValues - Array of answer values to vote for
+ */
+export declare function answer(element: InteractElement, arrayOfAnswerValues: AnswerValue[]): void;
+
+/**
+ * Submits an Element answer as an Answer instance
+ *
+ * @example
+ * ```javascript
+ * // vote for the first and third options
+ * const value = new Answer();
+ * value.set(0, 1);
+ * value.set(2, 1);
+ *
+ * answer(element, value);
+ * ```
+ *
+ * @param element - An Element instance
+ * @param answerObject - Array of answer values to vote for
+ */
+export declare function answer(element: InteractElement, answerObject: Answer): void;
+
+/**
+ * A map of potential error codes to compare with errors thrown by
+ * vote() or validateAnswer() functions.
+ */
+export declare enum AnswerError {
+    /** Selected option index is out of range. */
+    OptionIndexOutOfRange = "out_of_range",
+    /** Fewer options selected than the minimum required. */
+    BelowMinVoteOptions = "below_min_vote_options",
+    /** More options selected than the maximum allowed. */
+    AboveMaxVoteOptions = "above_max_vote_options",
+    /** User has exceeded the maximum votes allowed. */
+    AboveMaxVotesPerUser = "above_max_per_user",
+    /** A single option received more votes than allowed. */
+    AboveMaxVotesPerOption = "above_max_per_option",
+    /** Attempted to vote on a non-interactive element. */
+    VotedOnNonInteractiveElement = "non_interactive_element",
+    /** Attempted to vote on a closed element. */
+    VotedOnClosedElement = "closed_element",
+    /** No vote value was provided. */
+    EmptyVote = "empty_vote"
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Declares a user answer object interface. Answer value is a single item of
+ * {@link Answer | answer instance}
+ */
+export declare interface AnswerValue {
+    /**
+     * The option index (starting with 0)
+     */
+    option: number;
+    /**
+     * The number of votes that will be placed against the option
+     */
+    value: number;
+}
+
+/**
+ * @internal
+ */
+export declare enum Channel {
+    Poll = "p",
+    Live = "l"
+}
+
+/**
+ * @internal
+ */
+export declare interface Connect extends Emitter {
+    state: State;
+    enmasse: Connect_2 | null;
+    init(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): void;
+    subscribeProject(id: string): Promise<void>;
+    subscribeEvent(id: string): Promise<void>;
+    unsubscribeProject(id: string): void;
+    unsubscribeEvent(id: string): void;
+    sendVote(eventId: string, pollId: number, answer: string): void;
+}
+
+/**
+ * `ConnectionHealth` monitors connection state
+ */
+export declare interface ConnectionHealth extends Emitter {
+    /**
+     * State of the connection
+     */
+    state: ConnectionHealthState;
+}
+
+/**
+ * Provides states of the connection health
+ */
+export declare enum ConnectionHealthState {
+    /**
+     * The client is connected and the connection is healthy
+     */
+    Ok = "ok",
+    /**
+     * The client is either trying to establish a connection but failing, or
+     * the client has been explicitly {@link @monterosa/sdk-connect-kit#disconnect() | disconnected}
+     */
+    Error = "error"
+}
+
+declare interface ElementContext {
+    sdk: MonterosaSdk;
+    project: InteractProject;
+    event: InteractEvent;
+}
+
+/**
+ * @internal
+ */
+export declare class ElementImpl extends Emitter implements InteractElement {
+    private _data;
+    private _context;
+    private _state;
+    private _results;
+    private _userAnswer;
+    private _correctOption;
+    private unsubscribeStateHandler;
+    constructor(data: ElementOptions, context: ElementContext);
+    private calculateState;
+    private handleState;
+    update(data: ElementOptions): void;
+    destroy(): void;
+    get context(): ElementContext;
+    get id(): string;
+    get eventId(): string;
+    get state(): ElementState;
+    get type(): ElementType;
+    get contentType(): string;
+    get publishedAt(): number;
+    get publishedAtIso(): string;
+    get updatedAt(): number;
+    get updatedAtIso(): string;
+    get duration(): number;
+    get fields(): Record<string, unknown>;
+    get interactive(): boolean;
+    get pollId(): number | null;
+    get question(): Record<string, unknown> | null;
+    get answerOptions(): Record<string, unknown>[] | null;
+    get minOptionsPerVote(): number;
+    get maxOptionsPerVote(): number;
+    get maxVotesPerOption(): number;
+    get maxVotesPerUser(): number | null;
+    get userAnswer(): Answer | null;
+    set userAnswer(value: Answer | null);
+    get hasBeenAnswered(): boolean;
+    get showResultsMode(): ShowResultsMode | null;
+    get canShowResults(): boolean;
+    get results(): ElementResult[] | null;
+    set results(results: ElementResult[] | null);
+    get correctOption(): number | null;
+    set correctOption(value: number | null);
+    get isCorrectOptionRevealed(): boolean;
+}
+
+declare interface ElementOptions {
+    id: string;
+    type: ElementType;
+    content_type: string;
+    fixed: boolean;
+    published_at: number;
+    published_at_iso: string;
+    updated_at: number;
+    updated_at_iso: string;
+    duration: number;
+    custom_fields: Localised<Record<string, unknown>>;
+    data: {
+        id?: number;
+        question?: Localised<Record<string, unknown>>;
+        options?: Localised<Record<string, unknown>[]>;
+        min_options_per_vote?: number;
+        max_options_per_vote?: number;
+        max_votes_per_option?: number;
+        max_votes_per_user?: number;
+        reveal_results_mode?: ShowResultsMode;
+        results?: ElementResult[];
+        correct_option?: number;
+    };
+}
+
+/**
+ * A dataset that describes the result for a single option
+ */
+export declare interface ElementResult {
+    /**
+     * Total number of votes placed against the Element's option
+     */
+    votes: number;
+    /**
+     * Percentage of all votes
+     */
+    percentage: number;
+}
+
+/**
+ * The ElementState represents the potential states an Element is in.
+ */
+export declare enum ElementState {
+    /**
+     * Element is opened and active. The user can vote if
+     * the Element is `interactive`
+     */
+    Opened = "opened",
+    /**
+     * Element is closed and the user can no longer vote for
+     * `interactive` Elements
+     */
+    Closed = "closed"
+}
+
+/**
+ * Describes Element types
+ */
+export declare enum ElementType {
+    /**
+     * Data Element
+     */
+    Data = "data",
+    /**
+     * Poll Element
+     */
+    Poll = "poll",
+    /**
+     * Regular poll Element
+     */
+    RegularPoll = "rpoll",
+    /**
+     * Diametric poll Element
+     */
+    DiametricPoll = "dpoll",
+    /**
+     * Emoting poll Element
+     */
+    EmotingPoll = "emo",
+    /**
+     * Powerbar Element
+     */
+    Powerbar = "powerbar",
+    /**
+     * Prediction Element
+     */
+    Prediction = "prediction",
+    /**
+     * Trivia Element
+     */
+    Trivia = "trivia"
+}
+
+declare interface EventContext {
+    sdk: MonterosaSdk;
+    project: InteractProject;
+}
+
+declare interface EventHistory {
+    timeline: ElementOptions[];
+    config: EventOptions;
+    version: number;
+}
+
+/**
+ * @internal
+ */
+export declare class EventImpl extends Emitter implements InteractEvent {
+    readonly _data: EventOptions;
+    private _context;
+    private _state;
+    private _internalState;
+    private _initState;
+    private _history;
+    private boundHandleState;
+    private boundHandleInternalState;
+    private boundHandleEventsUpdated;
+    private unsubscribeStateHandler;
+    private unsubscribeInternalStateHandler;
+    private unsubscribeListingsHandler;
+    constructor(data: EventOptions, context: EventContext);
+    private calculateState;
+    private calculateInternalState;
+    private handleState;
+    private handleInternalState;
+    private handleEventsUpdated;
+    /** @internal */
+    destroy(): void;
+    get context(): EventContext;
+    get id(): string;
+    get name(): string;
+    get startAt(): number;
+    get startAtIso(): string;
+    get endAt(): number;
+    get endAtIso(): string;
+    get duration(): number;
+    get fields(): Record<string, unknown>;
+    get state(): EventState;
+    get internalState(): EventState;
+    get initState(): InitState;
+    set initState(state: InitState);
+    get history(): EventHistory | null;
+    set history(value: EventHistory | null);
+    get canSubscribe(): boolean;
+    get canLoadHistory(): boolean;
+}
+
+declare interface EventOptions {
+    id: string;
+    name: string;
+    start_at: number;
+    start_at_iso: string;
+    end_at: number;
+    end_at_iso: string;
+    started: boolean;
+    custom_fields: Localised<Record<string, unknown>>;
+    extra_time: number;
+    on_demand_time: number;
+    duration: number;
+    original_duration: number;
+    digest: string;
+}
+
+/**
+ * Describes the Event state.
+ */
+export declare enum EventState {
+    /**
+     * The Event is in the `upcoming` state when its {@link InteractEvent | startAt}
+     * less than the {@link @monterosa/sdk-util#now | current time}.
+     */
+    Upcoming = "upcoming",
+    /**
+     * The Event is in the `active` state when its {@link InteractEvent | startAt}
+     * equal or more than the {@link @monterosa/sdk-util#now | current time} and less than the
+     * {@link InteractEvent | endAt}.
+     */
+    Active = "active",
+    /**
+     * @internal
+     */
+    Prolonged = "prolonged",
+    /**
+     * The Event is in the `finished` state when its {@link InteractEvent | endAt}
+     * equal or more than the {@link @monterosa/sdk-util#now | current time}.
+     */
+    Finished = "finished"
+}
+
+/**
+ * Describes an extension asset
+ */
+export declare interface ExtensionAsset {
+    /**
+     * Extension's unique name
+     */
+    name: string;
+    /**
+     * An arbitrary data (e.g. url or extension-specific value)
+     */
+    data: string;
+    /**
+     * Defines autoload behaviour
+     *
+     * @remarks
+     *  - when `js` is set, JS script from the URL in `data` will be injected
+     *
+     *  - when `css` is set, CSS file from the URL in `data` will be injected
+     *
+     *  - when `false` is set, a developer can decide on their own how to handle it
+     */
+    autoload?: 'js' | 'css' | false;
+}
+
+/**
+ * @internal
+ */
+export declare function getConnect(host: string): Promise<Connect>;
+
+/**
+ * Returns {@link ConnectionHealth | connection health} instance
+ *
+ * @param sdk - The SDK instance to monitor
+ * @returns The connection health instance.
+ */
+export declare function getConnectionHealth(sdk?: MonterosaSdk): Promise<ConnectionHealth>;
+
+/**
+ * Returns an Element of a specific Event by its id.
+ *
+ * @param event - The Event that owns the Element
+ * @param id - The Element identifier
+ */
+export declare function getElement(event: InteractEvent, id: string): Promise<InteractElement | null>;
+
+/**
+ * @internal
+ */
+export declare const getElementMemoized: (...args: any[]) => Promise<InteractElement | null>;
+
+/**
+ * Returns the list of Elements published in a specific Event
+ *
+ * @param event - The Event to fetch Elements for
+ * @returns The published Elements, sorted oldest first.
+ */
+export declare function getElements(event: InteractEvent): Promise<InteractElement[]>;
+
+/**
+ * @internal
+ */
+export declare const getElementsMemoized: (...args: any[]) => Promise<InteractElement[]>;
+
+/**
+ * Returns an Event by its id
+ *
+ * @param id - Id of the Event
+ * @param project - A Project instance. If not provided,
+ *   the one from the default SDK will be fetched.
+ *
+ * @returns The Event associated with the provided id,
+ *   or null if no such Event exists in the Project.
+ */
+export declare function getEvent(id: string, project?: InteractProject): Promise<InteractEvent | null>;
+
+/**
+ * @internal
+ */
+export declare const getEventMemoized: (...args: any[]) => Promise<InteractEvent | null>;
+
+/**
+ * Returns all Events in a Project, including all active Events and
+ * past/upcoming Events, according to Listings settings in Project Setup
+ * in Studio.
+ *
+ * @param project - A Project instance. If not provided,
+ *   the one from the default SDK will be fetched.
+ * @returns A promise that resolves to an array of Events.
+ */
+export declare function getEvents(project?: InteractProject): Promise<InteractEvent[]>;
+
+/**
+ * @internal
+ */
+export declare const getEventsMemoized: (...args: any[]) => Promise<InteractEvent[]>;
+
+export declare function getPresenceCounter(project?: InteractProject): Promise<PresenceCounter>;
+
+/**
+ * Returns {@link InteractProject | Project instance} associated
+ * with the
+ * {@link @monterosa/sdk-core#MonterosaSdk | configured SDK}
+ *
+ * @param sdk - The SDK instance. Defaults to the default SDK.
+ * @returns The Project instance.
+ */
+export declare function getProject(sdk?: MonterosaSdk): Promise<InteractProject>;
+
+/**
+ * @internal
+ */
+export declare const getProjectMemoized: (...args: any[]) => Promise<InteractProject>;
+
+declare enum InitState {
+    Uninitialised = "uninitialised",
+    Initialising = "initialising",
+    Initialised = "initialised"
+}
+
+/**
+ * Represents an interactive Element such as a poll,
+ * prediction, or trivia question. Obtain via
+ * {@link getElements} or {@link getElement}.
+ *
+ * @remarks
+ * Elements are interactive components with configuration
+ * fields such as duration, publish time, question, answers,
+ * etc. Developers can add custom fields of various
+ * types via the
+ * {@link https://products.monterosa.co/mic/developer-guides/app-spec/elements-spec | app's Element spec}.
+ *
+ * Elements are triggered to appear at a certain time and
+ * process both the appearance of the content, the way it
+ * behaves, and the data sent back from the audience.
+ *
+ * See {@link https://products.monterosa.co/mic/core-concepts/elements | Elements} in
+ * the platform documentation for more details.
+ */
+export declare interface InteractElement extends Emitter {
+    /**
+     * Element uuid.
+     */
+    id: string;
+    /**
+     * Element state
+     */
+    state: ElementState;
+    /**
+     * Basic type of the Element
+     */
+    type: ElementType;
+    /**
+     * Returns `content type` of a custom Element if any is set in
+     * the Element spec. Otherwise returns the basic `type`.
+     */
+    contentType: ElementType | string;
+    /**
+     * Returns the Element publish time as UNIX time in seconds.
+     */
+    publishedAt: number;
+    /**
+     * Returns the Element publish time as ISO string.
+     */
+    publishedAtIso: string;
+    /**
+     * Returns the Element update as UNIX time in seconds.
+     */
+    updatedAt: number;
+    /**
+     * Returns the Element update time as ISO string.
+     */
+    updatedAtIso: string;
+    /**
+     * Returns the total duration in seconds of the Element.
+     */
+    duration: number;
+    /**
+     * Studio supports custom fields within Elements. This returns an object
+     * populated with the custom fields. Object property names will match keys
+     * as provided as part of custom fields definition in the feed and values
+     * will be as collected by Studio.
+     *
+     * @example
+     * ```javascript
+     * // {
+     * //   "name": "Canis lupus",
+     * //   "family": "Canidae",
+     * //   ...
+     * //   "species": "C. lupus"
+     * // }
+     * ```
+     */
+    fields: Record<string, unknown>;
+    /**
+     * Returns `true` if the user can vote for the Element
+     */
+    interactive: boolean;
+    /**
+     * Returns the question object
+     *
+     * @example
+     * ```javascript
+     * {
+     *   text: "Mumford and Sons is an internationally-famous what?",
+     *   imageUrl: '//path/to/my/question-image'
+     * }
+     * ```
+     */
+    question: Record<string, unknown> | null;
+    /**
+     * Returns a set of options
+     *
+     * @example
+     * ```javascript
+     * [{
+     *   text: "Option 1",
+     *   imageUrl: '//path/to/my/image1'
+     * },
+     * {
+     *   text: "Option 2",
+     *   imageUrl: '//path/to/my/image2'
+     * }]
+     * ```
+     */
+    answerOptions: Record<string, unknown>[] | null;
+    /**
+     * Returns the minimum number of options user can vote for.
+     */
+    minOptionsPerVote: number | null;
+    /**
+     * Returns the maximum number of options user can vote for.
+     */
+    maxOptionsPerVote: number | null;
+    /**
+     * Returns maximum number of votes a user can cast per option.
+     */
+    maxVotesPerOption: number | null;
+    /**
+     * Returns maximum number of votes a user can cast.
+     */
+    maxVotesPerUser: number | null;
+    /**
+     * Returns Element results if they exist. Otherwise, returns `null`.
+     *
+     * @example
+     * ```javascript
+     * [
+     *   {
+     *     votes: 15,
+     *     percentage: 75
+     *   },
+     *   {
+     *     votes: 5,
+     *     percentage: 25
+     *   }
+     * ]
+     * ```
+     */
+    results: ElementResult[] | null;
+    /**
+     * Returns user answer object
+     */
+    userAnswer: Answer | null;
+    /**
+     * Returns correct option index (starting with 0) if the correct answer has
+     * already been revealed. Otherwise, returns `null`.
+     *
+     * Note that the correct answer reveal is different from the results reveal.
+     */
+    correctOption: number | null;
+    /** @internal */
+    pollId: number | null;
+    /** @internal */
+    showResultsMode: ShowResultsMode | null;
+    /**
+     * Returns `true` if results present and the state of the Element satisfies
+     * reveal mode. Otherwise, returns `false`.
+     */
+    canShowResults: boolean;
+    /**
+     * Returns `true` if the user voted and `false` if not. The user answer
+     * could be retrieved by calling {@link InteractElement | userAnswer} getter.
+     */
+    hasBeenAnswered: boolean;
+    /**
+     * Returns `true` if the correct option has already been revealed.
+     */
+    isCorrectOptionRevealed: boolean;
+    /** @internal */
+    context: ElementContext;
+    /** @internal */
+    eventId: string;
+    /** @internal */
+    update(options: ElementOptions): void;
+    /** @internal */
+    destroy(): void;
+}
+
+/**
+ * Represents an Event, a time-bound period of
+ * interactivity. Obtain via {@link getEvent} or
+ * {@link getEvents}.
+ *
+ * @remarks
+ * Events represent a sports game, TV show, or any period of time in which you
+ * want to push interactivity to users. Each Event has a duration, start time,
+ * start mode, and
+ * {@link https://products.monterosa.co/mic/developer-guides/app-spec/event-settings-spec | custom fields}
+ * that can be configured by developers.
+ *
+ * See {@link https://products.monterosa.co/mic/core-concepts/schedule-and-events | Events} in
+ * the platform documentation for more details.
+ */
+export declare interface InteractEvent extends Emitter {
+    /**
+     * Event uuid.
+     */
+    id: string;
+    /**
+     * Event name.
+     */
+    name: string;
+    /**
+     * Returns the Event start time as UNIX time in seconds.
+     */
+    startAt: number;
+    /**
+     * Returns the Event start time as ISO string.
+     */
+    startAtIso: string;
+    /**
+     * Returns the Event end time as UNIX time in seconds.
+     */
+    endAt: number;
+    /**
+     * Returns the Event end time as ISO string.
+     */
+    endAtIso: string;
+    /**
+     * Studio supports custom fields within an Event. This returns an object
+     * populated with the custom fields. Object property names will match keys
+     * as provided as part of custom fields definition in the feed and values
+     * will be as collected by Studio.
+     *
+     * @example
+     * ```javascript
+     * // {
+     * //   "name": "Canis lupus",
+     * //   "family": "Canidae",
+     * //   ...
+     * //   "species": "C. lupus"
+     * // }
+     * ```
+     */
+    fields: Record<string, unknown>;
+    /**
+     * Event state
+     */
+    state: EventState;
+    /**
+     * Returns the total duration in seconds of the Event.
+     */
+    duration: number;
+    /** @internal */
+    canSubscribe: boolean;
+    /** @internal */
+    canLoadHistory: boolean;
+    /** @internal */
+    internalState: EventState;
+    /** @internal */
+    initState: InitState;
+    /** @internal */
+    context: EventContext;
+    /** @internal */
+    history: EventHistory | null;
+    /** @internal */
+    destroy(): void;
+}
+
+/**
+ * Represents a Project, a container for configuration,
+ * theming, and Events. Obtain via {@link getProject}.
+ *
+ * @remarks
+ * Every Project in Studio has an id, host, embedUrl, and a set of fields
+ * associated with an
+ * {@link https://products.monterosa.co/mic/developer-guides/whats-an-app | App}.
+ * Project fields are
+ * {@link https://products.monterosa.co/mic/producer-guide/studio/app-setup | configuration options}
+ * created by the
+ * {@link https://products.monterosa.co/mic/developer-guides/app-spec/project-settings-spec | app developer}
+ * and vary from App to App.
+ *
+ * See {@link https://products.monterosa.co/mic/core-concepts | Projects} in
+ * the platform documentation for more details.
+ */
+export declare interface InteractProject extends MonterosaKit, Emitter {
+    /**
+     * Project uuid.
+     */
+    id: string;
+    /**
+     * Project static host.
+     */
+    host: string;
+    /**
+     * Project embed url.
+     */
+    embedUrl: string;
+    /**
+     * Returns `true` if the Project supports localisation.
+     */
+    isLocalisationSupported: boolean;
+    /**
+     * The list of available locales as configured in Studio
+     */
+    locales: string[];
+    /**
+     * Project locale
+     */
+    locale: string;
+    /**
+     * Monterosa / Interaction Cloud supports custom fields within a Project.
+     * This returns an object populated with the custom fields. Object property
+     * names will match keys as provided as part of custom fields definition in
+     * the feed and values will be as collected by Studio.
+     *
+     * @example
+     * ```javascript
+     * // {
+     * //   "name": "Canis lupus",
+     * //   "family": "Canidae",
+     * //   ...
+     * //   "species": "C. lupus"
+     * // }
+     * ```
+     */
+    fields: Record<string, unknown>;
+    /**
+     * https://products.monterosa.co/mic/extensions/overview
+     * Monterosa / Interaction Cloud functionality can be extended with
+     * {@link https://products.monterosa.co/mic/extensions/overview | extensions}
+     * without changing the core platform codebase. An Extension can visually integrate
+     * into Studio, aid data collection for a Creator and provide data for the App
+     * and feeds. Extension can provide assets which Studio passes to the App. Sdk can
+     * fetch assets and provide it for the developers.
+     *
+     * @example
+     * ```
+     * {
+     *   "extension-name": [
+     *     {
+     *       "name": "js asset",
+     *       "data": "http://example.com/asset.js",
+     *       "autoload": "js"
+     *     },
+     *     {
+     *       "name": "css asset",
+     *       "data": "http://example.com/asset.css",
+     *       "autoload": "css"
+     *     }
+     *   ]
+     * }
+     * ```
+     */
+    extensions: Record<string, ExtensionAsset[]>;
+    /** @internal */
+    eventsChecksum: string | null;
+    /** @internal */
+    context: ProjectContext;
+    /** @internal */
+    events: EventOptions[];
+    /** @internal */
+    listings: Listings;
+    /** @internal */
+    historyIgnore: number;
+    /** @internal */
+    delete(): void;
+}
+
+/**
+ * @internal
+ */
+export declare enum Klass {
+    Listings = "listings",
+    History = "history",
+    Create = "create",
+    Revoke = "revoke",
+    Stop = "stop",
+    Reveal = "reveal",
+    Poll = "p",
+    Feedback = "fb",
+    Eoc = "eoc",
+    Vote = "v",
+    SubsCounter = "subscounter"
+}
+
+declare interface Listings {
+    project: {
+        uuid: string;
+        embed: string;
+        app_settings: string;
+        app_settings_digest: string;
+        audio_sync_default_delay: number;
+        audio_sync_max_delay: number;
+        history_ignore: number;
+        is_localisation_supported: boolean;
+        locales: ProjectLocale[];
+    };
+    events: EventOptions[];
+    assets: Record<string, ExtensionAsset[]>;
+}
+
+declare interface Localised<T> {
+    [lang: string]: T;
+    all: T;
+}
+
+/**
+ * @internal
+ */
+export declare interface Message {
+    id: string;
+    klass: Klass;
+    data: string[];
+}
+
+/**
+ * Adds an observer for when
+ * {@link ConnectionHealth | connection health state} changed
+ *
+ * @param connectionHealth - The instance to observe
+ * @param callback - Called with the new state
+ */
+export declare function onConnectionHealthState(connectionHealth: ConnectionHealth, callback: (state: ConnectionHealthState) => void): Unsubscribe;
+
+/**
+ * Adds an observer for when a new Element is published
+ *
+ * @param event - The Event to observe
+ * @param callback - Called with the published Element
+ */
+export declare function onElementPublished(event: InteractEvent, callback: (element: InteractElement) => void): Unsubscribe;
+
+/**
+ * Adds an observer for when
+ * {@link InteractElement | Element results} are updated
+ *
+ * @param element - The Element to observe
+ * @param callback - Called when results are updated
+ */
+export declare function onElementResults(element: InteractElement, callback: () => void): Unsubscribe;
+
+/**
+ * Adds an observer for when an Element is revoked
+ *
+ * @param event - The Event to observe
+ * @param callback - Called with the revoked Element
+ */
+export declare function onElementRevoked(event: InteractEvent, callback: (element: InteractElement) => void): Unsubscribe;
+
+/**
+ * Adds an observer for when
+ * {@link InteractElement | Element state} changed
+ *
+ * @param element - The Element to observe
+ * @param callback - Called when the state changes
+ */
+export declare function onElementStateChanged(element: InteractElement, callback: () => void): Unsubscribe;
+
+/**
+ * Adds an observer for when
+ * {@link InteractElement | Element fields} are updated
+ *
+ * @param event - The Event containing the Elements
+ * @param callback - Called with the updated Element
+ */
+export declare function onElementUpdated(event: InteractEvent, callback: (element: InteractElement) => void): Unsubscribe;
+
+/**
+ * Adds an observer that is called when an Event is added to listings.
+ *
+ * @remarks
+ * The following actions will result in adding an Event to listings:
+ *
+ * - The start of the Event in Studio
+ *
+ * - The scheduling of a future Event in Studio, when listings are configured
+ *   to include future Events in Project Settings.
+ *
+ * - When a future Event starts, a new future Event may be added to the list,
+ *   depending on the Project configuration, to ensure a minimum number of
+ *   upcoming Events are always available.
+ *
+ * @param project - The Project to observe
+ * @param callback - Called with the added Event
+ */
+export declare function onEventAdded(project: InteractProject, callback: (event: InteractEvent) => void): Unsubscribe;
+
+/**
+ * Adds an observer that is called when an Event is removed from listings.
+ *
+ * @remarks
+ * The following actions will result in removing an Event from listings:
+ *
+ * - The deletion of the Event from Studio
+ *
+ * - The change of listings configuration in Project Settings to exclude future
+ *   or past Events.
+ *
+ * - The Event is removed after a period of time since its completion. This period
+ *   is calculated as 45 seconds plus the Maximum allowed delay (configured in
+ *   Project Settings in Studio).
+ *
+ * @param project - The Project to observe
+ * @param callback - Called with the removed Event
+ */
+export declare function onEventRemoved(project: InteractProject, callback: (event: InteractEvent) => void): Unsubscribe;
+
+/**
+ * Adds an observer for when
+ * {@link InteractEvent | Event state} changed
+ *
+ * @param event - The Event to observe
+ * @param callback - Called with the new state
+ */
+export declare function onEventState(event: InteractEvent, callback: (state: EventState) => void): Unsubscribe;
+
+/**
+ * Adds an observer for when Event's data changed
+ *
+ * @param event - The Event to observe
+ * @param callback - Called when the Event data changes
+ */
+export declare function onEventUpdated(event: InteractEvent, callback: () => void): Unsubscribe;
+
+export declare function onPresenceCounterClose(presenceCounter: PresenceCounter, callback: () => void): Unsubscribe;
+
+export declare function onPresenceCounterOpen(presenceCounter: PresenceCounter, callback: () => void): Unsubscribe;
+
+export declare function onPresenceCounterUpdate(presenceCounter: PresenceCounter, callback: (count: number) => void): Unsubscribe;
+
+/**
+ * Adds an observer for when
+ * {@link InteractProject | Project fields} are updated
+ *
+ * @param project - The Project to observe
+ * @param callback - Called when Project fields change
+ */
+export declare function onProjectFieldsUpdated(project: InteractProject, callback: () => void): Unsubscribe;
+
+export declare interface PresenceCounter extends Emitter {
+    readonly isOpened: boolean;
+    readonly lastCount: number;
+}
+
+export declare enum PresenceCounterState {
+    Opened = "opened",
+    Closed = "closed"
+}
+
+declare interface ProjectContext {
+    sdk: MonterosaSdk;
+}
+
+/**
+ * @internal
+ */
+export declare class ProjectImpl extends Emitter implements InteractProject {
+    host: string;
+    id: string;
+    eventsChecksum: string | null;
+    private _context;
+    private _listings;
+    private _fields;
+    private _locales;
+    private _locale;
+    constructor(options: ProjectOptions, context: ProjectContext);
+    get context(): ProjectContext;
+    get embedUrl(): string;
+    get uuid(): string;
+    get events(): EventOptions[];
+    get listings(): Listings;
+    set listings(newListings: Listings);
+    /**
+     * Calculates events that were created (present in new listings but not in old)
+     */
+    private _calculateCreatedEvents;
+    /**
+     * Calculates events that were updated (present in old listings and new,
+     * but with different digest)
+     */
+    private _calculateUpdatedEvents;
+    /**
+     * Calculates events that were deleted (present in old listings but not in new)
+     */
+    private _calculateDeletedEvents;
+    /**
+     * Processes and updates locales from project listings
+     */
+    private _updateLocales;
+    /**
+     * Updates the events checksum based on new listings
+     */
+    private _updateEventsChecksum;
+    /**
+     * Emits events based on created and deleted events
+     */
+    private _emitListingsEvents;
+    get isLocalisationSupported(): boolean;
+    get locale(): string;
+    set locale(locale: string);
+    get locales(): string[];
+    get fields(): Record<string, unknown>;
+    /**
+     * Sets custom fields
+     *
+     * It accepts both Localised<Record<string, unknown>> and Record<string, unknown> to
+     * avoid mistyping between setter and getter
+     *
+     * @internal
+     */
+    set fields(value: Localised<Record<string, unknown>> | Record<string, unknown>);
+    get extensions(): Record<string, ExtensionAsset[]>;
+    get historyIgnore(): number;
+    delete(): void;
+}
+
+declare interface ProjectLocale {
+    default: boolean;
+    key: string;
+    name: string;
+}
+
+declare interface ProjectOptions {
+    id: string;
+    host: string;
+}
+
+declare enum ShowResultsMode {
+    OnVote = "vote",
+    OnClose = "close",
+    OnEventEnd = "event_end",
+    Manual = "manual",
+    Never = "never",
+    Always = "always"
+}
+
+/**
+ * @internal
+ */
+export declare enum State {
+    Ok = "ok",
+    Error = "error"
+}
+
+/**
+ * Validates user's answer as a spread of options indices and
+ * throws {@link @monterosa/sdk-util#MonterosaError%20class | error} with one of the
+ * {@link AnswerError | error code} if the answer doesn't match
+ * Element's constraints
+ *
+ *
+ * @example
+ * ```javascript
+ * try {
+ *   validateAnswer(element, 0, 2);
+ * } catch (err) {
+ *   console.log(err);
+ * }
+ * ```
+ *
+ * @param element - An Element instance
+ * @param indices - Spread of options indices (starting with 0) to vote for
+ */
+export declare function validateAnswer(element: InteractElement, ...indices: number[]): void;
+
+/**
+ * Validates user's answer as an array of options indices and
+ * throws {@link @monterosa/sdk-util#MonterosaError%20class | error} with one of the
+ * {@link AnswerError | error code} if the answer doesn't match
+ * Element's constraints
+ *
+ * @example
+ * ```javascript
+ * try {
+ *   validateAnswer(element, [0, 2]);
+ * } catch (err) {
+ *   console.log(err);
+ * }
+ * ```
+ *
+ * @param element - An Element instance
+ * @param arrayOfIndices - Array of options indices (starting with 0) to vote for
+ */
+export declare function validateAnswer(element: InteractElement, arrayOfIndices: number[]): void;
+
+/**
+ * Validates user's answer as a spread of answer values and
+ * throws {@link @monterosa/sdk-util#MonterosaError%20class | error} with one of the
+ * {@link AnswerError | error code} if the answer doesn't match
+ * Element's constraints
+ *
+ * @example
+ * ```javascript
+ * try {
+ *   validateAnswer(element,
+ *     {option: 0, value: 1},
+ *     {option: 2, value: 1},
+ *   );
+ * } catch (err) {
+ *   console.log(err);
+ * }
+ * ```
+ *
+ * @param element - An Element instance
+ * @param answerValues - Spread of answer values to vote for
+ */
+export declare function validateAnswer(element: InteractElement, ...answerValues: AnswerValue[]): void;
+
+/**
+ * Validates user's answer  as an array of answer values and
+ * throws {@link @monterosa/sdk-util#MonterosaError%20class | error} with one of the
+ * {@link AnswerError | error code} if the answer doesn't match
+ * Element's constraints
+ *
+ * @example
+ * ```javascript
+ * try {
+ *   validateAnswer(element, [
+ *     {option: 0, value: 1},
+ *     {option: 2, value: 1},
+ *   ]);
+ * } catch (err) {
+ *   console.log(err);
+ * }
+ * ```
+ *
+ * @param element - An Element instance
+ * @param arrayOfAnswerValues - Array of answer values to vote for
+ */
+export declare function validateAnswer(element: InteractElement, arrayOfAnswerValues: AnswerValue[]): void;
+
+/**
+ * Validates user's answer as an Answer instance and
+ * throws {@link @monterosa/sdk-util#MonterosaError%20class | error} with one of the
+ * {@link AnswerError | error code} if the answer doesn't match
+ * Element's constraints
+ *
+ * @example
+ * ```javascript
+ * try {
+ *   const value = new Answer();
+ *   value.set(0, 1);
+ *   value.set(2, 1);
+ *
+ *   validateAnswer(element, value);
+ * } catch (err) {
+ *   console.log(err);
+ * }
+ * ```
+ *
+ * @param element - An Element instance
+ * @param answerObject - Array of answer values to vote for
+ */
+export declare function validateAnswer(element: InteractElement, answerObject: Answer): void;
+
+export { }

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.23.0"
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monterosa/sdk-interact-kit",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0-rc.5",
   "description": "Monterosa JS SDK / Interact Kit",
   "author": "Monterosa Productions Limited <hello@monterosa.co.uk> (https://www.monterosa.co/)",
   "main": "./dist/index.cjs",
@@ -32,11 +32,11 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@monterosa/sdk-connect-kit": "2.0.0-rc.3",
-    "@monterosa/sdk-core": "2.0.0-rc.3",
-    "@monterosa/sdk-interact-interop": "2.0.0-rc.3",
-    "@monterosa/sdk-storage-kit": "2.0.0-rc.3",
-    "@monterosa/sdk-util": "2.0.0-rc.3"
+    "@monterosa/sdk-connect-kit": "2.0.0-rc.5",
+    "@monterosa/sdk-core": "2.0.0-rc.5",
+    "@monterosa/sdk-interact-interop": "2.0.0-rc.5",
+    "@monterosa/sdk-storage-kit": "2.0.0-rc.5",
+    "@monterosa/sdk-util": "2.0.0-rc.5"
   },
   "devDependencies": {
     "@faker-js/faker": "^6.3.1",
@@ -58,5 +58,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d692ad26af0b5ea7cd7b664168bffa069f9ab911"
+  "gitHead": "4f697a9733d36fb689a35b8e1dd6d589a9ae284c"
 }