@reveldigital/player-client 1.0.13 → 1.0.15

package/README.md

@@ -1,3 +1,236 @@
-# Revel Digital Angular Client
-
-Libary for Angular based Revel Digital gadgets
+# Revel Digital gadget library for Angular
+
+Angular library for building custom Revel Digital gadgets. This library simplies the player/gadget interface making it easier
+to build full featured gadgets utilizing the Angular framework.
+
+## Quickstart
+
+**New to Angular?** [Check out the Angular documentation](https://angular.io/guide/setup-local) for getting your environment configured for development.
+
+
+### **Step 1.** GitHub Repository Creation (Optional)
+
+**Not hosting your app on Github? Skip to step #2.**
+
+Create a new repository on [GitHub.com](https://github.com/). For more information, see "[Creating a new repository](https://docs.github.com/en/repositories/creating-and-managing-repositories/creating-a-new-repository)."
+
+
+Copy your remote repository URL
+
+![Alt text](https://reveldigital.github.io/reveldigital-client-library/images/copy-remote-repository-url-quick-setup.jpg)
+
+```sh
+git remote add origin <REMOTE_URL>
+# Sets the new remote
+git remote -v
+# Verifies the new remote URL
+```
+
+### **Step 2.** Create a new Angular app
+
+From within your working folder, run the following Angular CLI command using the name of your app.
+
+```sh
+ng new my-app --directory ./
+# Generates the boilerplate code for a new Angular app
+```
+
+### **Step 3.** Add the Revel Digital libaries
+
+Run the Revel Digital angular schematic which will configure your app for use as a Revel Digital gadget.
+
+```sh
+ng add @reveldigital/player-client@latest
+# Run the Revel Digital Angular schematic
+```
+
+### **Step 4.** Build
+
+The build script will generate the Angular app along with a the gadget XML definition file.
+
+```sh
+npm run build:gadget
+# Run the gadget build script
+```
+
+### **Step 5.** Deploy
+
+The app can be hosted using any number of hosting services, however the provided schematic includes a simplified option for publishing to [GitHub Pages](https://pages.github.com/).
+
+Assuming your working folder is associated with your GitHub repository, simply run the following command to deploy the app to the `gh-pages` branch. The gadget app and associated XML file will be publicly visibile and available for use in your signage.
+
+```sh
+npm run deploy:gadget
+# Deploy to GitHub Pages
+```
+
+## Sample usage
+
+The majority of the functionality is contained within the [PlayerClientService](https://reveldigital.github.io/reveldigital-client-library/injectables/PlayerClientService.html). The service and supporting library exposes the following functionality:
+
+- Methods for obtaining player details such as device time, locale, etc
+- Methods for interfacting with the player including sending commands and calling into player scripting
+- Player lifecycle methods (ready/start/stop)
+- Gadget property accessors such as user preferences
+- Miscellaneous helpers such as the SafeStyle pipe
+
+Simply inject this service in your Angular component constructor in order to access the player client interface.
+
+```ts
+  constructor(public client: PlayerClientService) {
+
+    this.prefs = client.getPrefs();
+    
+    this.style = this.prefs.getString('myStylePref');
+    
+    this.client.onReady$.subscribe((val) => {
+      console.log(val ? 'Ready' : 'Not ready');
+    });
+
+    this.client.onCommand$.subscribe((cmd) => {
+      console.log(`onCommand: ${cmd.name}, ${cmd.arg}`);
+    });
+
+    this.client.onStart$.subscribe(() => {
+      console.log("onStart");
+    });
+
+    this.client.onStop$.subscribe(() => {
+      console.log("onStop");
+    });
+  }
+```
+
+## Gadget Definition & Preferences
+
+The `assets/gadget.yaml` file is the definition file for your gadget, responsible for defining the basic properties and features of the gadget as presented to the user. These properties include the gadget name, description, support URL, and preferences. A sample `gadgets.yaml` file is included in your project after running the schematic.
+
+Preferences are the primary method for providing customization options of your gadget. They allow signage designers to change and preview gadget properties at design time within the Revel Digital CMS.
+
+The following is the sample `gadgets.yaml` included with the schematic:
+
+```yaml
+# Basic properties of the gadget must include the following:
+#   title: Title of the gadget as it will appear in the Revel Digital CMS UX
+#   title_url: Optional support URL for the gadget
+#   description: Details of the gadget. Will appear within the Revel Digital CMS
+#   author: Name of author or organization credited with developing the gadget
+#   background: (Deprecated) should always be transparent for most gadgets
+#
+title: My Gadget
+title_url: https://mysupporturl.org
+description: Describe the purpose of your gadget here
+author: My Organization
+background: transparent
+
+# Requirements enable certain features of the gadget. Available options include:
+#   reveldigital (core Revel Digital features)
+#   offline (Enable service worker caching for offline support)
+#   webfont (Enable Google WebFonts for dynamic font loading)
+#   moment (Enable the moment library for localized date/time, initialized with device timezone)
+#   jquery (Enable the jQuery libary)
+#
+requirements:
+  - reveldigital
+  - offline
+  - webfont
+  - moment
+  - jquery
+
+# Locales are use for localization within the gadget definition (XML) itself.
+#  Docs for using the Gadget API for i18n are available here: https://developers.google.com/gadgets/docs/i18n
+#
+# Angular applications should use the i18n support provided by the Angular framework:
+#  https://angular.io/guide/i18n-overview
+#
+locales:
+  - messages: https://reveldigital.github.io/reveldigital-gadgets/ALL_ALL.xml
+
+  - lang: fr
+    messages: https://reveldigital.github.io/reveldigital-gadgets/ALL_ALL.xml
+
+# Preferences provide customization options for the gadget and are accessible at both design time and runtime.
+#
+# Propreties of a preference include:
+#   name: Unique name or ID for the preference
+#   display_name: Name as shown in the UX
+#   datatype: string, enum, hidden, bool, style, list
+#   default_value: Default value
+#   required: Make this prefence mandatory, must have a value
+#   multiple: Allows for multiple selection of list items (enum pref type only)
+#   multiline: Enables multiline text (string pref type only)
+#   depends: The visibility of this preference depends on other preferences. This requires the name
+#     of the dependent preference along with a list of values. Condition types can include
+#     any_of, all_of, none_of. Nested depends conditions are also supported.
+#
+prefs:
+  - name: myStringPref
+    display_name: Sample string preference
+    datatype: string
+    default_value: test string
+    required: true
+    multiline: false
+
+  - name: myBoolPref
+    display_name: Sample boolean preference
+    datatype: bool
+    default_value: true
+    required: true
+    depends:
+      - name: myEnumPref
+        any_of:
+          - values:
+            - fast
+          
+  - name: myStylePref
+    display_name: Sample style preference
+    datatype: style
+    default_value: font-family:Verdana;color:rgb(255, 255, 255);font-size:18px;
+    required: true
+
+  - name: myEnumPref
+    display_name: Sample enum preference
+    datatype: enum
+    default_value: fast
+    required: true
+    multiple: false
+    options:
+      - value: fastest
+        display_value: Fastest
+      - value: fast
+        display_value: Fast
+      - value: medium
+        display_value: Medium
+
+  - name: myListPref
+    display_name: Sample list preference
+    datatype: list
+    default_value: dog|cat
+    required: false
+```
+
+This definition file results in the following user experience when designing your gadget in a template:
+
+![Alt text](https://reveldigital.github.io/reveldigital-client-library/images/sample-gadget-editor.png)
+
+You will see the preferences exposed in the editor which can then be modified at design time.
+
+Individual preferences are able to be accessed in your gadget code like so:
+
+```ts
+this.prefs = client.getPrefs();
+
+this.prefs.getString('myStringPref');
+this.prefs.getBool('myBoolPref');
+this.prefs.getFloat('myFloatPref');
+this.prefs.getInt('myIntPref');
+this.prefs.getArray('myListPref');
+```
+
+## Angular Library Documentation
+
+NPM: [https://www.npmjs.com/package/@reveldigital/player-client](https://www.npmjs.com/package/@reveldigital/player-client)
+
+Library documentation is available here: [https://reveldigital.github.io/reveldigital-client-library/](https://reveldigital.github.io/reveldigital-client-library/)
+
+A sample Angular app is available in this repo under [https://github.com/RevelDigital/reveldigital-client-library/tree/master/projects/test-app](https://github.com/RevelDigital/reveldigital-client-library/tree/master/projects/test-app).

package/esm2020/lib/interfaces/client.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.interface.js","sourceRoot":"","sources":["../../../../../../projects/reveldigital/player-client/src/lib/interfaces/client.interface.ts"],"names":[],"mappings":"","sourcesContent":["import { IDictionary } from \"./config.interface\";\r\n\r\n/**\r\n * Core interface defining the contract for Revel Digital player client implementations.\r\n * \r\n * This interface represents the complete API available for gadgets and web applications\r\n * to interact with the Revel Digital player environment. It provides methods for:\r\n * \r\n * - **Device Information**: Access device details, timezone, language, and hardware specs\r\n * - **Communication**: Send commands locally and to remote devices\r\n * - **Analytics**: Track events, measure performance, and manage user sessions\r\n * - **Player Control**: Manage gadget lifecycle and player transitions\r\n * - **Configuration**: Apply and manage gadget preferences and settings\r\n * \r\n * Implementations of this interface handle the actual communication with the player\r\n * environment, while providing a consistent API for client code regardless of the\r\n * underlying platform or deployment scenario.\r\n * \r\n * ```typescript\r\n * // Typical usage through PlayerClientService\r\n * class MyGadget {\r\n *   constructor(private client: PlayerClientService) {}\r\n *   \r\n *   async initialize() {\r\n *     const device = await this.client.getDevice();\r\n *     const time = await this.client.getDeviceTime();\r\n *     this.client.track('gadget_initialized', { deviceType: device.deviceType });\r\n *   }\r\n * }\r\n * ```\r\n * \r\n * @export\r\n * @interface IClient\r\n * @since 1.0.0\r\n */\r\nexport interface IClient {\r\n\r\n    /**\r\n     * Sends a callback to the player with optional arguments.\r\n     * \r\n     * This is the primary method for bi-directional communication between the gadget\r\n     * and player scripting. When called, it triggers any callback handlers that have\r\n     * been configured in the player template scripting.\r\n     * \r\n     * @param args - Variable number of arguments to pass to the player callback handler\r\n     * \r\n     * ```typescript\r\n     * // Simple callback without arguments\r\n     * client.callback();\r\n     * \r\n     * // Callback with data\r\n     * client.callback('user_action', { buttonId: 'start', timestamp: Date.now() });\r\n     * \r\n     * // Multiple arguments\r\n     * client.callback('event_name', 'event_data', { additional: 'context' });\r\n     * ```\r\n     */\r\n    callback(...args: any[]): void;\r\n\r\n    /**\r\n     * Gets the current device time in the device's configured timezone.\r\n     * \r\n     * Returns the current time adjusted to the timezone assigned to the device\r\n     * in the Revel Digital CMS. If a date is provided, it will be converted\r\n     * to the device's timezone.\r\n     * \r\n     * @param date - Optional date to convert to device time. If omitted, returns current device time\r\n     * @returns Promise resolving to ISO8601 formatted date string in device timezone\r\n     * \r\n     * ```typescript\r\n     * // Get current device time\r\n     * const now = await client.getDeviceTime();\r\n     * \r\n     * // Convert specific time to device timezone  \r\n     * const utcTime = new Date('2023-12-25T12:00:00Z');\r\n     * const localTime = await client.getDeviceTime(utcTime);\r\n     * ```\r\n     */\r\n    getDeviceTime(date?: Date): Promise<string | null>;\r\n\r\n    /**\r\n     * Gets the timezone name currently assigned to the device.\r\n     * \r\n     * Returns the human-readable timezone name as configured in the device\r\n     * settings within the Revel Digital CMS.\r\n     * \r\n     * @returns Promise resolving to timezone name (e.g., \"America/New_York\", \"Europe/London\")\r\n     * \r\n     * ```typescript\r\n     * const timezoneName = await client.getDeviceTimeZoneName();\r\n     * console.log(`Device timezone: ${timezoneName}`);\r\n     * ```\r\n     */\r\n    getDeviceTimeZoneName(): Promise<string | null>;\r\n\r\n    /**\r\n     * Gets the timezone identifier currently assigned to the device.\r\n     * \r\n     * Returns the timezone ID/identifier as configured for this device.\r\n     * This may be different from the timezone name depending on the system configuration.\r\n     * \r\n     * @returns Promise resolving to timezone identifier\r\n     * \r\n     * ```typescript\r\n     * const timezoneId = await client.getDeviceTimeZoneID();\r\n     * // Use for timezone-specific operations\r\n     * ```\r\n     */\r\n    getDeviceTimeZoneID(): Promise<string | null>;\r\n\r\n    /**\r\n     * Gets the numerical offset from GMT for the device's configured timezone.\r\n     * \r\n     * Returns the number of hours the device's timezone is offset from GMT.\r\n     * Positive values indicate timezones east of GMT, negative values indicate\r\n     * timezones west of GMT.\r\n     * \r\n     * @returns Promise resolving to timezone offset in hours (e.g., -5 for EST, +1 for CET)\r\n     * \r\n     * ```typescript\r\n     * const offset = await client.getDeviceTimeZoneOffset();\r\n     * console.log(`Device is ${offset} hours from GMT`);\r\n     * ```\r\n     */\r\n    getDeviceTimeZoneOffset(): Promise<number | null>;\r\n\r\n    /**\r\n     * Gets the language code currently assigned to the device.\r\n     * \r\n     * Returns the language/locale code configured for this device in the CMS.\r\n     * This can be used for localization and internationalization purposes.\r\n     * \r\n     * @returns Promise resolving to language code (e.g., \"en-US\", \"fr-FR\", \"de-DE\")\r\n     * \r\n     * ```typescript\r\n     * const langCode = await client.getLanguageCode();\r\n     * if (langCode === 'fr-FR') {\r\n     *   this.loadFrenchContent();\r\n     * }\r\n     * ```\r\n     */\r\n    getLanguageCode(): Promise<string | null>;\r\n\r\n    /**\r\n     * Gets the unique device key (registration key) for this player device.\r\n     * \r\n     * The device key is a unique identifier assigned to each device when it's\r\n     * registered with the Revel Digital system. This key can be used for\r\n     * device-specific operations and remote command targeting.\r\n     * \r\n     * @returns Promise resolving to the device's unique registration key\r\n     * \r\n     * ```typescript\r\n     * const deviceKey = await client.getDeviceKey();\r\n     * console.log(`This device key: ${deviceKey}`);\r\n     * // Use for analytics or device-specific configuration\r\n     * ```\r\n     */\r\n    getDeviceKey(): Promise<string | null>;\r\n\r\n    /**\r\n     * Sends a command to the local player device.\r\n     * \r\n     * Commands are used to trigger specific behaviors or actions on the player.\r\n     * The command is processed immediately by the local player only.\r\n     * \r\n     * @param name - The command identifier/name\r\n     * @param arg - Command argument or payload data\r\n     * \r\n     * ```typescript\r\n     * // Simple command\r\n     * client.sendCommand('restart', '');\r\n     * \r\n     * // Command with parameters\r\n     * client.sendCommand('setVolume', '75');\r\n     * client.sendCommand('loadContent', JSON.stringify({ url: 'http://example.com' }));\r\n     * ```\r\n     */\r\n    sendCommand(name: string, arg: string): void;\r\n\r\n    /**\r\n     * Sends a command to one or more remote player devices.\r\n     * \r\n     * Enables cross-device communication by sending commands to other devices\r\n     * within the same Revel Digital account. Useful for synchronized displays,\r\n     * coordinated actions, or remote device control.\r\n     * \r\n     * @param deviceKeys - Array of target device keys to receive the command\r\n     * @param name - The command identifier/name  \r\n     * @param arg - Command argument or payload data\r\n     * \r\n     * ```typescript\r\n     * // Send to multiple devices\r\n     * const targets = ['lobby-display', 'kiosk-001', 'kiosk-002'];\r\n     * client.sendRemoteCommand(targets, 'updateContent', 'new-content-id');\r\n     * \r\n     * // Broadcast synchronization command\r\n     * client.sendRemoteCommand(['device1', 'device2'], 'sync', Date.now().toString());\r\n     * ```\r\n     */\r\n    sendRemoteCommand(deviceKeys: string[], name: string, arg: string): void;\r\n\r\n    /**\r\n     * Tracks an analytics event with optional properties.\r\n     * \r\n     * Events are logged for analytics and reporting purposes, providing insights\r\n     * into gadget usage, performance, and user interactions. For timed events,\r\n     * the duration is automatically calculated from the timeEvent() call to this track() call.\r\n     * \r\n     * @param eventName - Unique identifier for the event\r\n     * @param properties - Optional JSON string containing event properties and metadata\r\n     * \r\n     * ```typescript\r\n     * // Simple event\r\n     * client.track('gadget_loaded', '');\r\n     * \r\n     * // Event with properties\r\n     * const props = JSON.stringify({ \r\n     *   action: 'button_click', \r\n     *   button_id: 'submit',\r\n     *   timestamp: Date.now() \r\n     * });\r\n     * client.track('user_interaction', props);\r\n     * ```\r\n     */\r\n    track(eventName: string, properties?: string): void;\r\n\r\n    /**\r\n     * Begins timing measurement for a named event.\r\n     * \r\n     * This starts a timer for performance measurement. The timer is stopped\r\n     * and duration calculated when track() is called with the same event name.\r\n     * Multiple concurrent timers can be active for different event names.\r\n     * \r\n     * @param eventName - Unique identifier for the timed event\r\n     * \r\n     * ```typescript\r\n     * // Start timing a video playback\r\n     * client.timeEvent('video_playback');\r\n     * // ... video plays for some duration ...\r\n     * client.track('video_playback', JSON.stringify({ videoId: 'abc123' }));\r\n     * // Duration is automatically included in the tracked event\r\n     * ```\r\n     */\r\n    timeEvent(eventName: string): void;\r\n\r\n    /**\r\n     * Creates a new analytics event session for grouping related events.\r\n     * \r\n     * Sessions provide a way to group related events together for analysis.\r\n     * Each subsequent event tracked will be associated with this session\r\n     * until a new session is started.\r\n     * \r\n     * @param id - Optional custom session identifier. If not provided, a random ID is generated\r\n     * \r\n     * ```typescript\r\n     * // Start new session with auto-generated ID\r\n     * client.newEventSession();\r\n     * client.track('session_start', '');\r\n     * \r\n     * // Start session with custom ID\r\n     * client.newEventSession('user-123-workflow');\r\n     * client.track('workflow_begin', '');\r\n     * ```\r\n     */\r\n    newEventSession(id?: string): void;\r\n\r\n    /**\r\n     * Gets the root directory path where the Revel Digital system stores files.\r\n     * \r\n     * Returns the base file system path used by the player for storing\r\n     * content, cache, and other system files on the local device.\r\n     * \r\n     * @returns Promise resolving to the root directory path\r\n     * \r\n     * ```typescript\r\n     * const rootPath = await client.getRevelRoot();\r\n     * console.log(`System root: ${rootPath}`);\r\n     * // Use for file operations or path construction\r\n     * ```\r\n     */\r\n    getRevelRoot(): Promise<string | null>;\r\n\r\n    /**\r\n     * Gets the current command map configuration for this device.\r\n     * \r\n     * Returns a JSON string containing the mapping of command names to their\r\n     * configurations as defined in the device's current template or playlist.\r\n     * \r\n     * @returns Promise resolving to JSON string of command mappings\r\n     * \r\n     * ```typescript\r\n     * const commandMapJson = await client.getCommandMap();\r\n     * const commandMap = JSON.parse(commandMapJson);\r\n     * if (commandMap['customCommand']) {\r\n     *   console.log('Custom command is available');\r\n     * }\r\n     * ```\r\n     */\r\n    getCommandMap(): Promise<string | null>;\r\n\r\n    /**\r\n     * Signals that the gadget has completed its visualization and the player can proceed.\r\n     * \r\n     * This notifies the player that the current content has finished displaying\r\n     * and it's safe to transition to the next item in a playlist or perform\r\n     * other scheduled actions.\r\n     * \r\n     * ```typescript\r\n     * // After animation completes\r\n     * setTimeout(() => {\r\n     *   client.finish();\r\n     * }, 5000);\r\n     * \r\n     * // After user interaction\r\n     * button.onclick = () => {\r\n     *   this.processAction();\r\n     *   client.finish();\r\n     * };\r\n     * ```\r\n     */\r\n    finish(): void;\r\n\r\n    /**\r\n     * Gets comprehensive information about the current device.\r\n     * \r\n     * Returns detailed device information including registration details,\r\n     * hardware type, location, and configuration as a JSON string.\r\n     * \r\n     * @returns Promise resolving to JSON string containing device information\r\n     * \r\n     * ```typescript\r\n     * const deviceJson = await client.getDevice();\r\n     * const device = JSON.parse(deviceJson);\r\n     * console.log(`Device: ${device.name} (${device.devicetype})`);\r\n     * console.log(`Location: ${device.location?.city}, ${device.location?.state}`);\r\n     * ```\r\n     */\r\n    getDevice(): Promise<string | null>;\r\n\r\n    /**\r\n     * Gets the width of the available visualization area in pixels.\r\n     * \r\n     * Returns the display width available for gadget content, which may\r\n     * differ from screen resolution based on template layout and player configuration.\r\n     * \r\n     * @returns Promise resolving to width in pixels\r\n     * \r\n     * ```typescript\r\n     * const width = await client.getWidth();\r\n     * if (width < 800) {\r\n     *   this.enableMobileLayout();\r\n     * }\r\n     * ```\r\n     */\r\n    getWidth(): Promise<number | null>;\r\n\r\n    /**\r\n     * Gets the height of the available visualization area in pixels.\r\n     * \r\n     * Returns the display height available for gadget content, which may\r\n     * differ from screen resolution based on template layout and player configuration.\r\n     * \r\n     * @returns Promise resolving to height in pixels\r\n     * \r\n     * ```typescript\r\n     * const height = await client.getHeight();\r\n     * const width = await client.getWidth();\r\n     * const aspectRatio = width / height;\r\n     * this.adjustLayout(aspectRatio);\r\n     * ```\r\n     */\r\n    getHeight(): Promise<number | null>;\r\n\r\n    /**\r\n     * Gets the duration assigned to the current playlist item.\r\n     * \r\n     * Returns the time duration (in milliseconds) that this content should\r\n     * be displayed when running as part of a playlist. Only applicable\r\n     * when the gadget is associated with a playlist.\r\n     * \r\n     * @returns Promise resolving to duration in milliseconds\r\n     * \r\n     * ```typescript\r\n     * const duration = await client.getDuration();\r\n     * if (duration) {\r\n     *   // Auto-finish after the assigned duration\r\n     *   setTimeout(() => client.finish(), duration);\r\n     * }\r\n     * ```\r\n     */\r\n    getDuration(): Promise<number | null>;\r\n\r\n    /**\r\n     * Gets the version of the Revel Digital SDK.\r\n     * \r\n     * Returns the current version string of the SDK/client library.\r\n     * \r\n     * @returns Promise resolving to version string\r\n     * \r\n     * ```typescript\r\n     * const version = await client.getSdkVersion();\r\n     * console.log(`SDK Version: ${version}`);\r\n     * ```\r\n     */\r\n    getSdkVersion(): Promise<string | null>;\r\n\r\n    /**\r\n     * Applies configuration preferences to the gadget (design-time only).\r\n     * \r\n     * This method is used during gadget design/configuration to apply\r\n     * preference changes. It sends the updated preferences to the CMS\r\n     * for assignment to the gadget configuration. Only available during\r\n     * design-time operations.\r\n     * \r\n     * @param prefs - Dictionary of preference key-value pairs to apply\r\n     * \r\n     * ```typescript\r\n     * // Apply configuration changes in design mode\r\n     * client.applyConfig({\r\n     *   'title': 'Updated Title',\r\n     *   'backgroundColor': '#ff0000',\r\n     *   'autoRefresh': true\r\n     * });\r\n     * ```\r\n     */\r\n    applyConfig(prefs: IDictionary<any>): void;\r\n}\r\n"]}

package/esm2020/lib/interfaces/command.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWFuZC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9yZXZlbGRpZ2l0YWwvcGxheWVyLWNsaWVudC9zcmMvbGliL2ludGVyZmFjZXMvY29tbWFuZC5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgSUNvbW1hbmQge1xyXG4gICAgLyoqXHJcbiAgICAgKiBDb21tYW5kIG5hbWVcclxuICAgICAqIFxyXG4gICAgICogQHR5cGUge3N0cmluZ31cclxuICAgICAqIFxyXG4gICAgICogQG1lbWJlcm9mIENvbW1hbmRcclxuICAgICAqL1xyXG4gICAgbmFtZTogc3RyaW5nO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogQ29tbWFuZCBhcmd1bWVudHNcclxuICAgICAqIFxyXG4gICAgICogQHR5cGUge0FycmF5PHN0cmluZz59XHJcbiAgICAgKiBcclxuICAgICAqIEBtZW1iZXJvZiBJQ29tbWFuZFxyXG4gICAgICovXHJcbiAgICBhcmc6IHN0cmluZztcclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/interfaces/config.interface.mjs

@@ -1,6 +1,50 @@
+/**
+ * Enumeration of configuration operation types.
+ *
+ * Defines the different types of configuration-related operations
+ * that can be performed between gadgets and the player environment.
+ *
+ * @export
+ * @enum ConfigType
+ * @since 1.0.0
+ */
 export var ConfigType;
 (function (ConfigType) {
+    /**
+     * Request to open the configuration interface.
+     *
+     * This type indicates that the configuration UI should be displayed,
+     * typically in response to a user action or system event.
+     *
+     * ```typescript
+     * // Trigger config UI opening
+     * const openConfigEvent: IConfig = {
+     *   prefs: {},
+     *   type: ConfigType.OpenConfig,
+     *   isOpener: false
+     * };
+     * ```
+     */
     ConfigType["OpenConfig"] = "openConfig";
+    /**
+     * Instruction to apply new configuration values.
+     *
+     * This type indicates that the provided preferences should be
+     * applied to the gadget's configuration, typically after the
+     * user has made changes in the configuration UI.
+     *
+     * ```typescript
+     * // Apply new configuration
+     * const applyConfigEvent: IConfig = {
+     *   prefs: {
+     *     'title': 'Updated Title',
+     *     'interval': 60
+     *   },
+     *   type: ConfigType.ApplyConfig,
+     *   isOpener: true
+     * };
+     * ```
+     */
     ConfigType["ApplyConfig"] = "applyConfig";
 })(ConfigType || (ConfigType = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9saWIvaW50ZXJmYWNlcy9jb25maWcuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWtDQSxNQUFNLENBQU4sSUFBWSxVQUdYO0FBSEQsV0FBWSxVQUFVO0lBQ2xCLHVDQUF5QixDQUFBO0lBQ3pCLHlDQUEyQixDQUFBO0FBQy9CLENBQUMsRUFIVyxVQUFVLEtBQVYsVUFBVSxRQUdyQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgSUNvbmZpZyB7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBQcmVmZXJlbmNlc1xyXG4gICAgICogXHJcbiAgICAgKiBAdHlwZSB7YW55fVxyXG4gICAgICogXHJcbiAgICAgKiBAbWVtYmVyb2YgSUNvbmZpZ1xyXG4gICAgICovXHJcbiAgICBwcmVmczogSURpY3Rpb25hcnk8YW55PjtcclxuXHJcbiAgICAvKipcclxuICAgICAqIENvbmZpZyB0eXBlXHJcbiAgICAgKiBcclxuICAgICAqIEB0eXBlIHtDb25maWdUeXBlfVxyXG4gICAgICogXHJcbiAgICAgKiBAbWVtYmVyb2YgSUNvbmZpZ1xyXG4gICAgICovXHJcbiAgICB0eXBlOiBDb25maWdUeXBlO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogSXMgdGhpcyBldmVudCB0cmlnZ2VyZWQgYnkgdGhlIG9wZW5lclxyXG4gICAgICogXHJcbiAgICAgKiBAdHlwZSB7Ym9vbGVhbn1cclxuICAgICAqIFxyXG4gICAgICogQG1lbWJlcm9mIElDb25maWdcclxuICAgICAqL1xyXG4gICAgaXNPcGVuZXI6IGJvb2xlYW47XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSURpY3Rpb25hcnk8VD4ge1xyXG4gICAgW0tleTogc3RyaW5nXTogVDtcclxufVxyXG5cclxuZXhwb3J0IGVudW0gQ29uZmlnVHlwZSB7XHJcbiAgICBPcGVuQ29uZmlnID0gJ29wZW5Db25maWcnLFxyXG4gICAgQXBwbHlDb25maWcgPSAnYXBwbHlDb25maWcnXHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/interfaces/device.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGV2aWNlLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9saWIvaW50ZXJmYWNlcy9kZXZpY2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJTG9jYXRpb24gfSBmcm9tIFwiLi9sb2NhdGlvbi5pbnRlcmZhY2VcIjtcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSURldmljZSB7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBEZXZpY2UgbmFtZVxyXG4gICAgICogXHJcbiAgICAgKiBAdHlwZSB7c3RyaW5nfVxyXG4gICAgICovXHJcbiAgICBuYW1lOiBzdHJpbmc7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBEZXZpY2Uga2V5XHJcbiAgICAgKiBcclxuICAgICAqIEB0eXBlIHtzdHJpbmd9XHJcbiAgICAgKi9cclxuICAgIHJlZ2lzdHJhdGlvbktleTogc3RyaW5nO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogRGV2aWNlIHR5cGVcclxuICAgICAqIFxyXG4gICAgICogQHR5cGUge3N0cmluZ31cclxuICAgICAqL1xyXG4gICAgZGV2aWNlVHlwZTogc3RyaW5nO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogRW50ZXJlZCBzZXJ2aWNlIGRhdGVcclxuICAgICAqIFxyXG4gICAgICogQHR5cGUge0RhdGV9XHJcbiAgICAgKi9cclxuICAgIGVudGVyZWRTZXJ2aWNlOiBEYXRlO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogTGFuZ3VhZ2UgY29kZVxyXG4gICAgICogXHJcbiAgICAgKiBAdHlwZSB7c3RyaW5nfVxyXG4gICAgICovXHJcbiAgICBsYW5nQ29kZT86IHN0cmluZztcclxuXHJcbiAgICAvKipcclxuICAgICAqIFRpbWUgem9uZVxyXG4gICAgICogXHJcbiAgICAgKiBAdHlwZSB7c3RyaW5nfVxyXG4gICAgICovXHJcbiAgICB0aW1lWm9uZT86IHN0cmluZztcclxuXHJcbiAgICAvKipcclxuICAgICAqIERldmljZSBwcm9wZXJ0aWVzXHJcbiAgICAgKiBcclxuICAgICAqIEB0eXBlIHtBcnJheTxzdHJpbmc+fVxyXG4gICAgICovXHJcbiAgICB0YWdzOiBBcnJheTxzdHJpbmc+O1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogRGV2aWNlIGxvY2F0aW9uXHJcbiAgICAgKiBcclxuICAgICAqIEB0eXBlIHtJTG9jYXRpb259XHJcbiAgICAgKi9cclxuICAgIGxvY2F0aW9uPzogSUxvY2F0aW9uO1xyXG59XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/interfaces/event-properties.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtcHJvcGVydGllcy5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9yZXZlbGRpZ2l0YWwvcGxheWVyLWNsaWVudC9zcmMvbGliL2ludGVyZmFjZXMvZXZlbnQtcHJvcGVydGllcy5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgSUV2ZW50UHJvcGVydGllcyB7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBFdmVudCBwcm9wZXJ0aWVzXHJcbiAgICAgKiBcclxuICAgICAqIEB0eXBlIHthbnl9XHJcbiAgICAgKiBcclxuICAgICAqIEBtZW1iZXJvZiBJRXZlbnRQcm9wZXJ0aWVzXHJcbiAgICAgKi9cclxuICAgIFtrZXk6IHN0cmluZ106IGFueTtcclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/interfaces/location.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYXRpb24uaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvcmV2ZWxkaWdpdGFsL3BsYXllci1jbGllbnQvc3JjL2xpYi9pbnRlcmZhY2VzL2xvY2F0aW9uLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiXHJcbmV4cG9ydCBpbnRlcmZhY2UgSUxvY2F0aW9uIHtcclxuICAgIC8qKlxyXG4gICAgICogTGF0aXR1ZGVcclxuICAgICAqIFxyXG4gICAgICogQHR5cGUge251bWJlcn1cclxuICAgICAqIFxyXG4gICAgICogQG1lbWJlcm9mIElMb2NhdGlvblxyXG4gICAgICovXHJcbiAgICBsYXRpdHVkZTogbnVtYmVyO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogTG9uZ2l0dWRlXHJcbiAgICAgKiBcclxuICAgICAqIEB0eXBlIHtudW1iZXJ9XHJcbiAgICAgKiBcclxuICAgICAqIEBtZW1iZXJvZiBJTG9jYXRpb25cclxuICAgICAqL1xyXG4gICAgbG9uZ2l0dWRlOiBudW1iZXI7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBDaXR5XHJcbiAgICAgKiBcclxuICAgICAqIEB0eXBlIHtzdHJpbmd9XHJcbiAgICAgKiBcclxuICAgICAqIEBtZW1iZXJvZiBJTG9jYXRpb25cclxuICAgICAqL1xyXG4gICAgY2l0eTogc3RyaW5nO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogU3RhdGVcclxuICAgICAqIFxyXG4gICAgICogQHR5cGUge3N0cmluZ31cclxuICAgICAqIFxyXG4gICAgICogQG1lbWJlcm9mIElMb2NhdGlvblxyXG4gICAgICovXHJcbiAgICBzdGF0ZTogc3RyaW5nO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogQWRkcmVzc1xyXG4gICAgICogXHJcbiAgICAgKiBAdHlwZSB7c3RyaW5nfVxyXG4gICAgICogXHJcbiAgICAgKiBAbWVtYmVyb2YgSUxvY2F0aW9uXHJcbiAgICAgKi9cclxuICAgIGFkZHJlc3M6IHN0cmluZztcclxuXHJcbiAgICAvKipcclxuICAgICAqIENvdW50cnlcclxuICAgICAqIFxyXG4gICAgICogQHR5cGUge3N0cmluZ31cclxuICAgICAqIFxyXG4gICAgICogQG1lbWJlcm9mIElMb2NhdGlvblxyXG4gICAgICovXHJcbiAgICBjb3VudHJ5OiBzdHJpbmc7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBQb3N0YWwgY29kZVxyXG4gICAgICogXHJcbiAgICAgKiBAdHlwZSB7c3RyaW5nfVxyXG4gICAgICogXHJcbiAgICAgKiBAbWVtYmVyb2YgSUxvY2F0aW9uXHJcbiAgICAgKi9cclxuICAgIHBvc3RhbENvZGU6IHN0cmluZztcclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"location.interface.js","sourceRoot":"","sources":["../../../../../../projects/reveldigital/player-client/src/lib/interfaces/location.interface.ts"],"names":[],"mappings":"","sourcesContent":["\r\n/**\r\n * Interface representing comprehensive geographical and address information for a device location.\r\n * \r\n * This interface defines the complete location data structure used throughout\r\n * the Revel Digital system for device positioning, content localization,\r\n * and geographic analytics. Location information enables:\r\n * \r\n * - **Geographic Content Targeting**: Deliver region-specific content\r\n * - **Localization**: Adjust language, currency, and cultural content\r\n * - **Analytics Segmentation**: Group and analyze by geographic regions\r\n * - **Weather Integration**: Display local weather conditions\r\n * - **Distance Calculations**: Proximity-based features and routing\r\n * - **Compliance**: Regional regulatory and legal requirements\r\n * \r\n * ```typescript\r\n * // Access device location information\r\n * const device = await this.client.getDevice();\r\n * \r\n * if (device?.location) {\r\n *   const location = device.location;\r\n *   \r\n *   // Display local information\r\n *   console.log(`Device located at: ${location.address}`);\r\n *   console.log(`${location.city}, ${location.state} ${location.postalCode}`);\r\n *   console.log(`${location.country}`);\r\n *   \r\n *   // Use coordinates for mapping\r\n *   this.showOnMap(location.latitude, location.longitude);\r\n *   \r\n *   // Load region-specific content\r\n *   if (location.country === 'US') {\r\n *     this.loadUSContent();\r\n *   } else if (location.country === 'CA') {\r\n *     this.loadCanadianContent();\r\n *   }\r\n *   \r\n *   // City-specific customization\r\n *   switch (location.city) {\r\n *     case 'New York':\r\n *       this.enableSubwayAlerts();\r\n *       break;\r\n *     case 'London':\r\n *       this.showTubeStatus();\r\n *       break;\r\n *   }\r\n * }\r\n * ```\r\n * \r\n * @export\r\n * @interface ILocation\r\n * @since 1.0.0\r\n */\r\nexport interface ILocation {\r\n    /**\r\n     * Geographic latitude coordinate in decimal degrees.\r\n     * \r\n     * Represents the north-south position on Earth's surface.\r\n     * Positive values indicate northern hemisphere, negative values\r\n     * indicate southern hemisphere.\r\n     * \r\n     * ```typescript\r\n     * // Examples of latitude values:\r\n     * // 40.7128 (New York City)\r\n     * // 51.5074 (London)\r\n     * // -33.8688 (Sydney)\r\n     * // 35.6762 (Tokyo)\r\n     * \r\n     * const lat = location.latitude;\r\n     * const hemisphere = lat >= 0 ? 'Northern' : 'Southern';\r\n     * console.log(`Location is in the ${hemisphere} hemisphere`);\r\n     * ```\r\n     */\r\n    latitude: number;\r\n\r\n    /**\r\n     * Geographic longitude coordinate in decimal degrees.\r\n     * \r\n     * Represents the east-west position on Earth's surface.\r\n     * Positive values indicate eastern hemisphere, negative values\r\n     * indicate western hemisphere.\r\n     * \r\n     * ```typescript\r\n     * // Examples of longitude values:\r\n     * // -74.0060 (New York City)\r\n     * // -0.1278 (London)  \r\n     * // 151.2093 (Sydney)\r\n     * // 139.6503 (Tokyo)\r\n     * \r\n     * const lng = location.longitude;\r\n     * const hemisphere = lng >= 0 ? 'Eastern' : 'Western';\r\n     * console.log(`Location is in the ${hemisphere} hemisphere`);\r\n     * \r\n     * // Calculate distance between two points\r\n     * const distance = this.calculateDistance(\r\n     *   location.latitude, location.longitude,\r\n     *   otherLat, otherLng\r\n     * );\r\n     * ```\r\n     */\r\n    longitude: number;\r\n\r\n    /**\r\n     * City name where the device is located.\r\n     * \r\n     * The municipal or city-level administrative division.\r\n     * Used for city-specific content, local services, and\r\n     * urban area customizations.\r\n     * \r\n     * \"New York\", \"London\", \"Tokyo\", \"Sydney\"\r\n     */\r\n    city: string;\r\n\r\n    /**\r\n     * State, province, or regional administrative division.\r\n     * \r\n     * The sub-national administrative unit such as state (US),\r\n     * province (Canada), or region (EU). Format varies by country.\r\n     * \r\n     * \"California\", \"Ontario\", \"Bavaria\", \"New South Wales\"\r\n     */\r\n    state: string;\r\n\r\n    /**\r\n     * Full street address of the device location.\r\n     * \r\n     * Complete physical address including street number, street name,\r\n     * and any additional address components. Used for precise location\r\n     * identification and delivery purposes.\r\n     * \r\n     * ```typescript\r\n     * // Typical address formats:\r\n     * // \"123 Main Street, Suite 456\"\r\n     * // \"1600 Pennsylvania Avenue NW\"\r\n     * // \"10 Downing Street\"\r\n     * // \"1-1-1 Chiyoda\"\r\n     * \r\n     * if (location.address) {\r\n     *   console.log(`Full address: ${location.address}`);\r\n     *   this.displayAddressOnMap(location.address);\r\n     * }\r\n     * ```\r\n     */\r\n    address: string;\r\n\r\n    /**\r\n     * Country name or country code.\r\n     * \r\n     * The nation-state where the device is located. May be provided\r\n     * as full country name or standardized country code (ISO 3166).\r\n     * Used for country-specific content, legal compliance, and\r\n     * international customizations.\r\n     * \r\n     * ```typescript\r\n     * // Country name formats:\r\n     * // \"United States\", \"Canada\", \"United Kingdom\", \"Japan\"\r\n     * // Or country codes:\r\n     * // \"US\", \"CA\", \"GB\", \"JP\"\r\n     * \r\n     * // Handle different formats\r\n     * const countryCode = location.country.length === 2 \r\n     *   ? location.country \r\n     *   : this.getCountryCode(location.country);\r\n     *   \r\n     * this.loadCountrySpecificContent(countryCode);\r\n     * ```\r\n     */\r\n    country: string;\r\n\r\n    /**\r\n     * Postal or ZIP code for the location.\r\n     * \r\n     * The postal delivery code used by the local postal service.\r\n     * Format varies by country (ZIP codes in US, postal codes in Canada/UK, etc.).\r\n     * Used for local delivery, regional targeting, and demographic analysis.\r\n     * \r\n     * ```typescript\r\n     * // Postal code formats by country:\r\n     * // US: \"90210\", \"10001-1234\"\r\n     * // Canada: \"K1A 0A6\", \"M5V 3L9\"  \r\n     * // UK: \"SW1A 1AA\", \"M1 1AA\"\r\n     * // Germany: \"10115\", \"80331\"\r\n     * \r\n     * // Use for regional content targeting\r\n     * if (location.postalCode.startsWith('90')) {\r\n     *   this.loadLosAngelesContent();\r\n     * }\r\n     * \r\n     * // Validate postal code format\r\n     * const isValidUS = /^\\d{5}(-\\d{4})?$/.test(location.postalCode);\r\n     * ```\r\n     */\r\n    postalCode: string;\r\n}\r\n"]}