helpdesk-app-framework-sdk 1.0.0

package/build/baf_sdk.js

@@ -0,0 +1,2107 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["BAFClient"] = factory();
+	else
+		root["BAFClient"] = factory();
+})(Object(typeof self !== "undefined" ? self : this), () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./lib/apis/context.js"
+/*!*****************************!*\
+  !*** ./lib/apis/context.js ***!
+  \*****************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * BoldDesk App Framework - Context API
+ * Provides information about the current runtime environment
+ */
+
+class ContextAPI {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    this._data = {
+      orgId: data.orgId || null,
+      orgName: data.orgName || null,
+      brandId: data.brandId || null,
+      brandName: data.brandName || null,
+      brandUrl: data.brandUrl || null,
+      defaultBrandUrl: data.defaultBrandUrl || null,
+      planId: data.planId || null,
+      planName: data.planName || null,
+      module: data.module || null,
+      objectId: data.objectId || null,
+      product: data.product || 'BoldDesk',
+      user: data.user || {
+        id: null,
+        email: null,
+        name: null,
+        displayName: null,
+        language: null,
+        timezone: null
+      }
+    };
+  }
+
+  /**
+   * Get organization ID
+   * @returns {string} Organization ID
+   */
+  getOrgId() {
+    return this._data.orgId;
+  }
+
+  /**
+   * Get organization name
+   * @returns {string} Organization name
+   */
+  getOrgName() {
+    return this._data.orgName;
+  }
+
+  /**
+   * Get brand ID
+   * @returns {string} Brand ID
+   */
+  getBrandId() {
+    return this._data.brandId;
+  }
+
+  /**
+   * Get brand name
+   * @returns {string} Brand name
+   */
+  getBrandName() {
+    return this._data.brandName;
+  }
+
+  /**
+   * Get brand URL
+   * @returns {string} Brand URL
+   */
+  getBrandUrl() {
+    return this._data.brandUrl;
+  }
+
+  /**
+   * Get current module (ticket, contact, chat, etc.)
+   * @returns {string} Current module
+   */
+  getModule() {
+    return this._data.module;
+  }
+
+  /**
+   * Get current object ID in context
+   * @returns {string} Object ID
+   */
+  getObjectId() {
+    return this._data.objectId;
+  }
+
+  /**
+   * Get current product
+   * @returns {string} Product name
+   */
+  getProduct() {
+    return this._data.product;
+  }
+
+  /**
+   * Get current user information
+   * @returns {Object} User object
+   */
+  getUser() {
+    return this._data.user;
+  }
+
+  /**
+   * Get user ID
+   * @returns {string} User ID
+   */
+  getUserId() {
+    return this._data.user?.id;
+  }
+
+  /**
+   * Get user email
+   * @returns {string} User email
+   */
+  getUserEmail() {
+    return this._data.user?.email;
+  }
+
+  /**
+   * Get user name
+   * @returns {string} User name
+   */
+  getUserName() {
+    return this._data.user?.name;
+  }
+
+  /**
+   * Get user language preference
+   * @returns {string} Language code (e.g., en-US)
+   */
+  getUserLanguage() {
+    return this._data.user?.language;
+  }
+
+  /**
+   * Get user timezone
+   * @returns {string} Timezone (e.g., Asia/Kolkata)
+   */
+  getUserTimezone() {
+    return this._data.user?.timezone;
+  }
+
+  /**
+   * Get plan information
+   * @returns {Object} Plan object with id and name
+   */
+  getPlan() {
+    return {
+      id: this._data.planId,
+      name: this._data.planName
+    };
+  }
+
+  /**
+   * Get all context data
+   * @returns {Object} Full context object
+   */
+  getAll() {
+    return JSON.parse(JSON.stringify(this._data));
+  }
+
+  /**
+   * Update context data (internal use)
+   * @param {Object} data - New data to merge
+   * @internal
+   */
+  _updateData(data) {
+    Object.assign(this._data, data);
+  }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ContextAPI);
+
+/***/ },
+
+/***/ "./lib/apis/instance.js"
+/*!******************************!*\
+  !*** ./lib/apis/instance.js ***!
+  \******************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Instance: () => (/* binding */ Instance),
+/* harmony export */   InstanceAPI: () => (/* binding */ InstanceAPI)
+/* harmony export */ });
+/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils */ "./lib/utils.js");
+/**
+ * BoldDesk App Framework - Instance API
+ * Provides access to app instances and instance-level operations
+ */
+
+
+class Instance {
+  constructor(id) {
+    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.id = id || (0,_utils__WEBPACK_IMPORTED_MODULE_0__.generateUUID)();
+    this.config = config;
+    this.widgets = config.widgets || [];
+    this.isActive = true;
+  }
+
+  /**
+   * Get instance ID
+   * @returns {string}
+   */
+  getId() {
+    return this.id;
+  }
+
+  /**
+   * Check if instance is active
+   * @returns {boolean}
+   */
+  getIsActive() {
+    return this.isActive;
+  }
+}
+class InstanceAPI {
+  constructor(client) {
+    this._client = client;
+    this._instances = {};
+    this._messageHandlers = {};
+  }
+
+  /**
+   * Get current active instance
+   * @returns {Instance}
+   */
+  current() {
+    const currentId = this._client._currentInstanceId;
+    return this._instances[currentId] || null;
+  }
+
+  /**
+   * Get instance by ID
+   * @param {string} id - Instance ID
+   * @returns {Instance}
+   */
+  get(id) {
+    return this._instances[id] || null;
+  }
+
+  /**
+   * Get all active instances
+   * @returns {Array} Array of instances
+   */
+  all() {
+    return Object.values(this._instances).filter(inst => inst && inst.getIsActive());
+  }
+
+  /**
+   * Create a new instance
+   * @param {Object} config - Instance configuration
+   * @returns {Promise} Resolves with instance
+   */
+  create() {
+    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return new Promise((resolve, reject) => {
+      try {
+        const instance = new Instance(null, config);
+        this._instances[instance.id] = instance;
+
+        // Post message to host to register instance
+        this._client.postMessage('instance.create', {
+          id: instance.id,
+          config
+        });
+        resolve(instance);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Send message/data to other instances
+   * @param {string|Array} instanceIds - Instance ID or array of IDs
+   * @param {string} channel - Channel name
+   * @param {*} payload - Data to send
+   * @returns {Promise}
+   */
+  send(instanceIds, channel, payload) {
+    return new Promise((resolve, reject) => {
+      try {
+        const ids = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.isArray)(instanceIds) ? instanceIds : [instanceIds];
+        this._client.postMessage('instance.send', {
+          instanceIds: ids,
+          channel,
+          payload
+        });
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Register handler to receive messages from other instances
+   * @param {string} channel - Channel name
+   * @param {Function} handler - Message handler
+   * @returns {void}
+   */
+  receive(channel, handler) {
+    if (!(0,_utils__WEBPACK_IMPORTED_MODULE_0__.isFunction)(handler)) {
+      throw new Error('Handler must be a function');
+    }
+    if (!this._messageHandlers[channel]) {
+      this._messageHandlers[channel] = [];
+    }
+    this._messageHandlers[channel].push(handler);
+
+    // Inform host about subscription
+    this._client.postMessage('instance.receive', {
+      channel
+    });
+  }
+
+  /**
+   * Unregister message handler
+   * @param {string} channel - Channel name
+   * @param {Function} handler - Optional specific handler to remove
+   * @returns {void}
+   */
+  unreceive(channel, handler) {
+    if (!this._messageHandlers[channel]) return;
+    if (handler) {
+      const index = this._messageHandlers[channel].indexOf(handler);
+      if (index > -1) {
+        this._messageHandlers[channel].splice(index, 1);
+      }
+    } else {
+      this._messageHandlers[channel] = [];
+    }
+  }
+
+  /**
+   * Close current instance
+   * @returns {Promise}
+   */
+  close() {
+    return new Promise((resolve, reject) => {
+      try {
+        const instance = this.current();
+        if (instance) {
+          instance.isActive = false;
+          delete this._instances[instance.id];
+        }
+        this._client.postMessage('instance.close', {
+          instanceId: instance?.id
+        });
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Resize widget container
+   * @param {number} height - Height in pixels
+   * @returns {Promise}
+   */
+  resize(height) {
+    return new Promise((resolve, reject) => {
+      if (typeof height !== 'number' || height < 0) {
+        return reject(new Error('Height must be a positive number'));
+      }
+      try {
+        this._client.postMessage('instance.resize', {
+          height
+        });
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Trigger instance event (for receiving messages)
+   * @internal
+   * @param {string} channel - Channel name
+   * @param {*} payload - Message payload
+   */
+  _triggerMessage(channel, payload) {
+    if (this._messageHandlers[channel]) {
+      this._messageHandlers[channel].forEach(handler => {
+        try {
+          handler(payload);
+        } catch (error) {
+          console.error(`Error in instance message handler for channel ${channel}:`, error);
+        }
+      });
+    }
+  }
+
+  /**
+   * Register instance (internal use)
+   * @internal
+   * @param {Object} data - Instance data from host
+   */
+  _registerInstance(data) {
+    if (data.id) {
+      if (!this._instances[data.id]) {
+        this._instances[data.id] = new Instance(data.id, data.config);
+      }
+      if (data.isCurrent) {
+        this._client._currentInstanceId = data.id;
+      }
+    }
+  }
+}
+
+
+/***/ },
+
+/***/ "./lib/apis/metadata.js"
+/*!******************************!*\
+  !*** ./lib/apis/metadata.js ***!
+  \******************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * BoldDesk App Framework - Metadata API
+ * Provides app and installation metadata information
+ */
+
+class MetadataAPI {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    this._data = {
+      appId: data.appId || null,
+      installationId: data.installationId || null,
+      appName: data.appName || null,
+      version: data.version || null,
+      locations: data.locations || [],
+      hasAllBrandAccess: data.hasAllBrandAccess || false,
+      hasReadAccess: data.hasReadAccess || false,
+      hasWriteAccess: data.hasWriteAccess || false,
+      isActive: data.isActive || false,
+      isEnabled: data.isEnabled || false,
+      frameworkVersion: data.frameworkVersion || null,
+      installDate: data.installDate || null,
+      developer: data.developer || null
+    };
+  }
+
+  /**
+   * Get app ID
+   * @returns {string} App ID
+   */
+  getAppId() {
+    return this._data.appId;
+  }
+
+  /**
+   * Get installation ID (unique per installation)
+   * @returns {string} Installation ID
+   */
+  getInstallationId() {
+    return this._data.installationId;
+  }
+
+  /**
+   * Get app name
+   * @returns {string} App name
+   */
+  getAppName() {
+    return this._data.appName;
+  }
+
+  /**
+   * Get app version
+   * @returns {string} Version (semantic versioning)
+   */
+  getVersion() {
+    return this._data.version;
+  }
+
+  /**
+   * Get widget locations where app is available
+   * @returns {Array} Array of location strings
+   */
+  getLocations() {
+    return Array.from(this._data.locations);
+  }
+
+  /**
+   * Check if app has all brand access
+   * @returns {boolean}
+   */
+  hasAllBrandAccess() {
+    return this._data.hasAllBrandAccess === true;
+  }
+
+  /**
+   * Check if app has read permissions
+   * @returns {boolean}
+   */
+  hasReadAccess() {
+    return this._data.hasReadAccess === true;
+  }
+
+  /**
+   * Check if app has write permissions
+   * @returns {boolean}
+   */
+  hasWriteAccess() {
+    return this._data.hasWriteAccess === true;
+  }
+
+  /**
+   * Check if app is active
+   * @returns {boolean}
+   */
+  isActive() {
+    return this._data.isActive === true;
+  }
+
+  /**
+   * Check if app is enabled
+   * @returns {boolean}
+   */
+  isEnabled() {
+    return this._data.isEnabled === true;
+  }
+
+  /**
+   * Get framework version
+   * @returns {string} Framework version
+   */
+  getFrameworkVersion() {
+    return this._data.frameworkVersion;
+  }
+
+  /**
+   * Get installation date
+   * @returns {string} ISO date string
+   */
+  getInstallDate() {
+    return this._data.installDate;
+  }
+
+  /**
+   * Get developer information
+   * @returns {Object} Developer object
+   */
+  getDeveloper() {
+    return this._data.developer ? JSON.parse(JSON.stringify(this._data.developer)) : null;
+  }
+
+  /**
+   * Check if location is supported
+   * @param {string} location - Location to check
+   * @returns {boolean}
+   */
+  isLocationSupported(location) {
+    return this._data.locations.includes(location);
+  }
+
+  /**
+   * Get all metadata
+   * @returns {Object} Full metadata object
+   */
+  getAll() {
+    return JSON.parse(JSON.stringify(this._data));
+  }
+
+  /**
+   * Update metadata (internal use)
+   * @param {Object} data - New data to merge
+   * @internal
+   */
+  _updateData(data) {
+    Object.assign(this._data, data);
+  }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (MetadataAPI);
+
+/***/ },
+
+/***/ "./lib/apis/request.js"
+/*!*****************************!*\
+  !*** ./lib/apis/request.js ***!
+  \*****************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils */ "./lib/utils.js");
+/**
+ * BoldDesk App Framework - Request API (Proxy)
+ * Provides secure HTTP request capability through server-side proxy
+ */
+
+
+class RequestAPI {
+  constructor(client) {
+    this._client = client;
+  }
+
+  /**
+   * Make an HTTP request through BoldDesk proxy
+   * Prevents exposing sensitive data and handles CORS automatically
+   *
+   * @param {Object} options - Request options
+   * @param {string} options.url - Full URL of the API endpoint (required)
+   * @param {string} options.method - HTTP method (GET, POST, PUT, DELETE, PATCH) (required)
+   * @param {Object} options.headers - HTTP headers (optional)
+   * @param {Object} options.params - Query parameters (optional)
+   * @param {Object|string} options.body - Request payload (optional, for POST/PUT/PATCH)
+   * @param {number} options.timeout - Request timeout in ms (optional, default: 15000, max: 30000)
+   * @param {boolean} options.autoRetry - Auto-retry on 429/5xx (optional, default: true)
+   * @param {number} options.maxRetry - Max retry attempts (optional, default: 3)
+   * @param {number} options.retryDelay - Delay between retries in ms (optional, default: 1000)
+   *
+   * @returns {Promise} Resolves with response object { status, statusText, headers, data, body }
+   *
+   * @example
+   * // Simple GET request
+   * sdk.request({
+   *   url: 'https://api.example.com/users',
+   *   method: 'GET'
+   * }).then(response => console.log(response.data))
+   *
+   * @example
+   * // POST with data
+   * sdk.request({
+   *   url: 'https://api.example.com/tickets',
+   *   method: 'POST',
+   *   headers: { 'Content-Type': 'application/json' },
+   *   body: JSON.stringify({ subject: 'Help needed', priority: 'high' })
+   * })
+   *
+   * @example
+   * // Using secure settings placeholders
+   * sdk.request({
+   *   url: 'https://api.example.com/secure-endpoint',
+   *   method: 'GET',
+   *   headers: { 'Authorization': 'Bearer {{setting.api_key}}' }
+   * })
+   */
+  request() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return new Promise((resolve, reject) => {
+      try {
+        // Validate required options
+        if (!options.url) {
+          throw new Error('Request URL is required');
+        }
+        if (!options.method) {
+          throw new Error('Request method is required');
+        }
+
+        // Validate URL format
+        if (!(0,_utils__WEBPACK_IMPORTED_MODULE_0__.isValidUrl)(options.url)) {
+          throw new Error('Invalid URL format: ' + options.url);
+        }
+
+        // Validate method
+        const validMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+        const method = (options.method || 'GET').toUpperCase();
+        if (!validMethods.includes(method)) {
+          throw new Error('Invalid HTTP method: ' + method);
+        }
+
+        // Build request object
+        const requestObj = {
+          url: options.url,
+          method,
+          headers: options.headers || {},
+          timeout: Math.min(options.timeout || 15000, 30000),
+          autoRetry: options.autoRetry !== false,
+          maxRetry: options.maxRetry || 3,
+          retryDelay: options.retryDelay || 1000
+        };
+
+        // Add query parameters if provided
+        if (options.params && (0,_utils__WEBPACK_IMPORTED_MODULE_0__.isObject)(options.params)) {
+          const params = new URLSearchParams(options.params);
+          const separator = options.url.includes('?') ? '&' : '?';
+          requestObj.url += separator + params.toString();
+        }
+
+        // Add body for POST/PUT/PATCH
+        if (['POST', 'PUT', 'PATCH'].includes(method)) {
+          if (options.body) {
+            requestObj.body = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.isObject)(options.body) ? JSON.stringify(options.body) : options.body;
+          }
+        }
+
+        // Send request through BoldDesk proxy
+        this._client.postMessage('request.send', requestObj, response => {
+          if (response.error) {
+            reject(new Error(response.error));
+          } else {
+            resolve(response);
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Make a GET request
+   * @param {string} url - URL endpoint
+   * @param {Object} options - Additional options
+   * @returns {Promise}
+   */
+  get(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return this.request({
+      ...options,
+      url,
+      method: 'GET'
+    });
+  }
+
+  /**
+   * Make a POST request
+   * @param {string} url - URL endpoint
+   * @param {*} body - Request body
+   * @param {Object} options - Additional options
+   * @returns {Promise}
+   */
+  post(url, body) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    return this.request({
+      ...options,
+      url,
+      method: 'POST',
+      body
+    });
+  }
+
+  /**
+   * Make a PUT request
+   * @param {string} url - URL endpoint
+   * @param {*} body - Request body
+   * @param {Object} options - Additional options
+   * @returns {Promise}
+   */
+  put(url, body) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    return this.request({
+      ...options,
+      url,
+      method: 'PUT',
+      body
+    });
+  }
+
+  /**
+   * Make a PATCH request
+   * @param {string} url - URL endpoint
+   * @param {*} body - Request body
+   * @param {Object} options - Additional options
+   * @returns {Promise}
+   */
+  patch(url, body) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    return this.request({
+      ...options,
+      url,
+      method: 'PATCH',
+      body
+    });
+  }
+
+  /**
+   * Make a DELETE request
+   * @param {string} url - URL endpoint
+   * @param {Object} options - Additional options
+   * @returns {Promise}
+   */
+  delete(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return this.request({
+      ...options,
+      url,
+      method: 'DELETE'
+    });
+  }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (RequestAPI);
+
+/***/ },
+
+/***/ "./lib/client.js"
+/*!***********************!*\
+  !*** ./lib/client.js ***!
+  \***********************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils */ "./lib/utils.js");
+/* harmony import */ var _apis_context__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./apis/context */ "./lib/apis/context.js");
+/* harmony import */ var _apis_metadata__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./apis/metadata */ "./lib/apis/metadata.js");
+/* harmony import */ var _apis_instance__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./apis/instance */ "./lib/apis/instance.js");
+/* harmony import */ var _apis_request__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./apis/request */ "./lib/apis/request.js");
+/* harmony import */ var native_promise_only__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! native-promise-only */ "./node_modules/native-promise-only/lib/npo.src.js");
+/* harmony import */ var native_promise_only__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(native_promise_only__WEBPACK_IMPORTED_MODULE_5__);
+/**
+ * BoldDesk App Framework - Client SDK
+ * Core client for cross-frame communication and data access
+ */
+
+
+
+
+
+
+
+const Promise = window.Promise || (native_promise_only__WEBPACK_IMPORTED_MODULE_5___default());
+
+// Constants
+const IFRAME_SESSION_TIMEOUT = 5 * 60 * 1000;
+const PROMISE_TIMEOUT = 10000;
+const PROMISE_TIMEOUT_LONG = 5 * 60 * 1000;
+class Client {
+  constructor() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    this.origin = options.origin;
+    this.appGuid = options.appGuid;
+
+    // Initialize state
+    this._isReady = false;
+    this._messageQueue = [];
+    this._pendingRequests = {};
+    this._eventListeners = {};
+    this._requestId = 0;
+    this._currentInstanceId = null;
+
+    // Initialize APIs
+    this.context = new _apis_context__WEBPACK_IMPORTED_MODULE_1__["default"]();
+    this.metadata = new _apis_metadata__WEBPACK_IMPORTED_MODULE_2__["default"]();
+    this.instance = new _apis_instance__WEBPACK_IMPORTED_MODULE_3__.InstanceAPI(this);
+    this.request = new _apis_request__WEBPACK_IMPORTED_MODULE_4__["default"](this);
+
+    // Bind message handler
+    this._handleMessage = this._handleMessage.bind(this);
+    window.addEventListener('message', this._handleMessage);
+
+    // Register with host
+    this._registerWithHost();
+  }
+
+  /**
+   * Register app with BoldDesk host
+   * @private
+   */
+  _registerWithHost() {
+    this.postMessage('app.register', {
+      appGuid: this.appGuid,
+      version: '1.0.0'
+    });
+  }
+
+  /**
+   * Post message to host frame
+   * @param {string} action - Action name
+   * @param {*} data - Data payload
+   * @param {Function} callback - Optional callback
+   * @private
+   */
+  postMessage(action, data, callback) {
+    const requestId = ++this._requestId;
+    if (callback && (0,_utils__WEBPACK_IMPORTED_MODULE_0__.isFunction)(callback)) {
+      this._pendingRequests[requestId] = callback;
+    }
+    const message = {
+      type: 'baf.request',
+      action,
+      data,
+      requestId,
+      appGuid: this.appGuid,
+      timestamp: Date.now()
+    };
+    if (this._isReady) {
+      window.parent.postMessage(message, this.origin);
+    } else {
+      this._messageQueue.push(message);
+    }
+  }
+
+  /**
+   * Handle incoming messages from host
+   * @private
+   */
+  _handleMessage(event) {
+    if (event.origin !== this.origin) return;
+    const message = event.data;
+    if (!message || message.type !== 'baf.response') return;
+
+    // Handle app registration
+    if (message.action === 'app.registered') {
+      this._isReady = true;
+      this._processMessageQueue();
+      this._handleAppRegistered(message.data);
+      return;
+    }
+
+    // Handle pending request responses
+    if (message.requestId && this._pendingRequests[message.requestId]) {
+      const callback = this._pendingRequests[message.requestId];
+      delete this._pendingRequests[message.requestId];
+      callback(message.data);
+      return;
+    }
+
+    // Handle events
+    if (message.action === 'event') {
+      this._handleEvent(message.eventName, message.data);
+      return;
+    }
+
+    // Handle instance messages
+    if (message.action === 'instance.message') {
+      this.instance._triggerMessage(message.channel, message.payload);
+      return;
+    }
+
+    // Handle instance registration
+    if (message.action === 'instance.registered') {
+      this.instance._registerInstance(message.data);
+      return;
+    }
+  }
+
+  /**
+   * Handle app registration from host
+   * @private
+   */
+  _handleAppRegistered(data) {
+    if (data.context) {
+      this.context._updateData(data.context);
+    }
+    if (data.metadata) {
+      this.metadata._updateData(data.metadata);
+    }
+    if (data.instanceId) {
+      this._currentInstanceId = data.instanceId;
+    }
+
+    // Emit app.registered event
+    this._emitEvent('app.registered', {
+      context: this.context.getAll(),
+      metadata: this.metadata.getAll()
+    });
+  }
+
+  /**
+   * Process queued messages
+   * @private
+   */
+  _processMessageQueue() {
+    while (this._messageQueue.length > 0) {
+      const message = this._messageQueue.shift();
+      window.parent.postMessage(message, this.origin);
+    }
+  }
+
+  /**
+   * Get data from platform context
+   * Retrieves data like ticket info, user info, etc.
+   *
+   * @param {string|Array} path - Data path or array of paths
+   * @returns {Promise} Resolves with requested data
+   *
+   * @example
+   * // Get single value
+   * sdk.get('ticket.subject').then(data => {
+   *   console.log(data['ticket.subject']);
+   * });
+   *
+   * @example
+   * // Get multiple values
+   * sdk.get(['ticket.subject', 'ticket.requester.email']).then(data => {
+   *   console.log(data['ticket.subject']);
+   *   console.log(data['ticket.requester.email']);
+   * });
+   */
+  get(path) {
+    return new Promise((resolve, reject) => {
+      if (!path) {
+        return reject(new Error('Path is required for get() method'));
+      }
+      try {
+        const paths = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.isArray)(path) ? path : [path];
+        this.postMessage('data.get', {
+          paths
+        }, response => {
+          if (response.error) {
+            reject(new Error(response.error));
+          } else {
+            resolve(response.data || {});
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Set data in platform context
+   * Updates or stores data like ticket properties, custom fields, etc.
+   *
+   * @param {string} path - Data path to update
+   * @param {*} value - Value to set
+   * @returns {Promise} Resolves when data is set
+   *
+   * @example
+   * sdk.set('ticket.subject', 'Issue Resolved').then(() => {
+   *   console.log('Subject updated');
+   * });
+   */
+  set(path, value) {
+    return new Promise((resolve, reject) => {
+      if (!path) {
+        return reject(new Error('Path is required for set() method'));
+      }
+      try {
+        this.postMessage('data.set', {
+          path,
+          value
+        }, response => {
+          if (response.error) {
+            reject(new Error(response.error));
+          } else {
+            resolve();
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Register event listener
+   * Listen for platform events like data changes, UI events, etc.
+   *
+   * @param {string} eventName - Event name to listen for
+   * @param {Function} callback - Handler function
+   * @returns {void}
+   *
+   * @example
+   * sdk.on('ticket.updated', (ticket) => {
+   *   console.log('Ticket updated:', ticket);
+   * });
+   */
+  on(eventName, callback) {
+    if (!(0,_utils__WEBPACK_IMPORTED_MODULE_0__.isString)(eventName) || !(0,_utils__WEBPACK_IMPORTED_MODULE_0__.isFunction)(callback)) {
+      throw new Error('on() requires eventName (string) and callback (function)');
+    }
+    if (!this._eventListeners[eventName]) {
+      this._eventListeners[eventName] = [];
+      this.postMessage('event.register', {
+        eventName
+      });
+    }
+    this._eventListeners[eventName].push(callback);
+  }
+
+  /**
+   * Unregister event listener
+   * Stop listening for platform events
+   *
+   * @param {string} eventName - Event name
+   * @param {Function} callback - Optional specific handler to remove
+   * @returns {void}
+   *
+   * @example
+   * sdk.off('ticket.updated');
+   */
+  off(eventName, callback) {
+    if (!this._eventListeners[eventName]) return;
+    if (callback && (0,_utils__WEBPACK_IMPORTED_MODULE_0__.isFunction)(callback)) {
+      const index = this._eventListeners[eventName].indexOf(callback);
+      if (index > -1) {
+        this._eventListeners[eventName].splice(index, 1);
+      }
+    } else {
+      this._eventListeners[eventName] = [];
+    }
+
+    // Unregister from host if no more listeners
+    if (this._eventListeners[eventName].length === 0) {
+      this.postMessage('event.unregister', {
+        eventName
+      });
+    }
+  }
+
+  /**
+   * Invoke a platform action or method
+   * Execute platform-exposed methods like opening modals, etc.
+   *
+   * @param {string} methodName - Method name to invoke
+   * @param {*} payload - Optional data for the method
+   * @returns {Promise} Resolves with method result
+   *
+   * @example
+   * sdk.invoke('modal.open', {
+   *   title: 'Contact Details',
+   *   content: 'View full contact information'
+   * });
+   */
+  invoke(methodName, payload) {
+    return new Promise((resolve, reject) => {
+      if (!(0,_utils__WEBPACK_IMPORTED_MODULE_0__.isString)(methodName)) {
+        return reject(new Error('Method name is required'));
+      }
+      try {
+        this.postMessage('action.invoke', {
+          methodName,
+          payload
+        }, response => {
+          if (response.error) {
+            reject(new Error(response.error));
+          } else {
+            resolve(response.result);
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Trigger a custom event
+   * Emit custom events to the platform or other app components
+   *
+   * @param {string} eventName - Event name
+   * @param {*} data - Event data
+   * @returns {void}
+   *
+   * @example
+   * sdk.trigger('custom.notification', {
+   *   message: 'Data saved successfully'
+   * });
+   */
+  trigger(eventName, data) {
+    if (!(0,_utils__WEBPACK_IMPORTED_MODULE_0__.isString)(eventName)) {
+      throw new Error('Event name must be a string');
+    }
+    this.postMessage('event.trigger', {
+      eventName,
+      data
+    });
+
+    // Also emit locally
+    this._emitEvent(eventName, data);
+  }
+
+  /**
+   * Check if capability or value exists
+   * Verify availability of features or data paths
+   *
+   * @param {string} name - Capability or value name
+   * @returns {Promise} Resolves with boolean
+   *
+   * @example
+   * sdk.has('ticket.custom_field_123').then(exists => {
+   *   if (exists) {
+   *     console.log('Custom field is available');
+   *   }
+   * });
+   */
+  has(name) {
+    return new Promise((resolve, reject) => {
+      if (!(0,_utils__WEBPACK_IMPORTED_MODULE_0__.isString)(name)) {
+        return reject(new Error('Name must be a string'));
+      }
+      try {
+        this.postMessage('capability.check', {
+          name
+        }, response => {
+          resolve(response.exists === true);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Internal: Emit event to local listeners
+   * @private
+   */
+  _emitEvent(eventName, data) {
+    if (this._eventListeners[eventName]) {
+      this._eventListeners[eventName].forEach(callback => {
+        try {
+          callback(data);
+        } catch (error) {
+          console.error(`Error in event listener for ${eventName}:`, error);
+        }
+      });
+    }
+  }
+
+  /**
+   * Internal: Handle incoming event from host
+   * @private
+   */
+  _handleEvent(eventName, data) {
+    this._emitEvent(eventName, data);
+  }
+
+  /**
+   * Destroy client and clean up
+   * @returns {void}
+   */
+  destroy() {
+    window.removeEventListener('message', this._handleMessage);
+    this._eventListeners = {};
+    this._pendingRequests = {};
+    this._messageQueue = [];
+    this._isReady = false;
+  }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Client);
+
+/***/ },
+
+/***/ "./lib/utils.js"
+/*!**********************!*\
+  !*** ./lib/utils.js ***!
+  \**********************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   debounce: () => (/* binding */ debounce),
+/* harmony export */   deepClone: () => (/* binding */ deepClone),
+/* harmony export */   deepMerge: () => (/* binding */ deepMerge),
+/* harmony export */   formatError: () => (/* binding */ formatError),
+/* harmony export */   generateUUID: () => (/* binding */ generateUUID),
+/* harmony export */   isArray: () => (/* binding */ isArray),
+/* harmony export */   isFunction: () => (/* binding */ isFunction),
+/* harmony export */   isNull: () => (/* binding */ isNull),
+/* harmony export */   isObject: () => (/* binding */ isObject),
+/* harmony export */   isString: () => (/* binding */ isString),
+/* harmony export */   isUndefined: () => (/* binding */ isUndefined),
+/* harmony export */   isValidUrl: () => (/* binding */ isValidUrl),
+/* harmony export */   parseWidgetLocations: () => (/* binding */ parseWidgetLocations),
+/* harmony export */   queryParameters: () => (/* binding */ queryParameters),
+/* harmony export */   throttle: () => (/* binding */ throttle),
+/* harmony export */   validateManifest: () => (/* binding */ validateManifest),
+/* harmony export */   when: () => (/* binding */ when)
+/* harmony export */ });
+/**
+ * BoldDesk App Framework - Utility Functions
+ * Provides helper functions for common operations
+ */
+
+/**
+ * Query string parser
+ * @param {string} queryString - Query string to parse (with or without ?)
+ * @returns {Object} Parsed parameters
+ */
+function queryParameters(queryString) {
+  const params = {};
+  if (!queryString) return params;
+  const cleaned = queryString.replace(/^\?|^#/, '');
+  if (!cleaned) return params;
+  cleaned.split('&').forEach(pair => {
+    const [key, value] = pair.split('=');
+    if (key) {
+      params[decodeURIComponent(key)] = value ? decodeURIComponent(value) : true;
+    }
+  });
+  return params;
+}
+
+/**
+ * Promise utility - when all conditions are met
+ * @param {Array} promises - Array of promises to wait for
+ * @returns {Promise}
+ */
+function when(promises) {
+  return Promise.all(promises);
+}
+
+/**
+ * Type checking utilities
+ */
+const isObject = obj => Object.prototype.toString.call(obj) === '[object Object]';
+const isString = str => typeof str === 'string';
+const isArray = arr => Array.isArray(arr);
+const isFunction = fn => typeof fn === 'function';
+const isUndefined = val => typeof val === 'undefined';
+const isNull = val => val === null;
+
+/**
+ * Debounce function - delays execution
+ * @param {Function} fn - Function to debounce
+ * @param {number} delay - Delay in milliseconds
+ * @returns {Function} Debounced function
+ */
+function debounce(fn, delay) {
+  let timeoutId;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn.apply(this, args), delay);
+  };
+}
+
+/**
+ * Throttle function - rate limits execution
+ * @param {Function} fn - Function to throttle
+ * @param {number} limit - Time limit in milliseconds
+ * @returns {Function} Throttled function
+ */
+function throttle(fn, limit) {
+  let inThrottle;
+  return function () {
+    if (!inThrottle) {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      fn.apply(this, args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, limit);
+    }
+  };
+}
+
+/**
+ * Deep clone an object
+ * @param {*} obj - Object to clone
+ * @returns {*} Cloned object
+ */
+function deepClone(obj) {
+  if (obj === null || typeof obj !== 'object') return obj;
+  if (obj instanceof Date) return new Date(obj.getTime());
+  if (obj instanceof Array) return obj.map(item => deepClone(item));
+  if (obj instanceof Object) {
+    const cloned = {};
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        cloned[key] = deepClone(obj[key]);
+      }
+    }
+    return cloned;
+  }
+}
+
+/**
+ * Merge objects deeply
+ * @param {Object} target - Target object
+ * @param {Object} source - Source object
+ * @returns {Object} Merged object
+ */
+function deepMerge(target, source) {
+  const result = {
+    ...target
+  };
+  for (const key in source) {
+    if (source.hasOwnProperty(key)) {
+      if (isObject(source[key]) && isObject(result[key])) {
+        result[key] = deepMerge(result[key], source[key]);
+      } else {
+        result[key] = deepClone(source[key]);
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * UUID v4 generator
+ * @returns {string} Generated UUID
+ */
+function generateUUID() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === 'x' ? r : r & 0x3 | 0x8;
+    return v.toString(16);
+  });
+}
+
+/**
+ * Validate manifest fields
+ * @param {Object} manifest - Manifest object to validate
+ * @returns {Object} Validation result { valid: boolean, errors: Array }
+ */
+function validateManifest(manifest) {
+  const errors = [];
+  if (!manifest.name) errors.push('Manifest field "name" is required');
+  if (!manifest.version) errors.push('Manifest field "version" is required');
+  if (!manifest.frameworkVersion) errors.push('Manifest field "frameworkVersion" is required');
+  if (!manifest.product) errors.push('Manifest field "product" is required');
+  if (manifest.developer) {
+    const dev = manifest.developer;
+    if (!dev.name) errors.push('Developer field "name" is required');
+    if (!dev.contactEmail) errors.push('Developer field "contactEmail" is required');
+    if (!dev.supportEmail) errors.push('Developer field "supportEmail" is required');
+  } else {
+    errors.push('Manifest field "developer" is required');
+  }
+  if (!Array.isArray(manifest.trustedDomains)) {
+    errors.push('Manifest field "trustedDomains" must be an array');
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Parse widget locations to ensure valid format
+ * @param {Array} locations - Widget locations from manifest
+ * @returns {Array} Parsed locations
+ */
+function parseWidgetLocations(locations) {
+  const validLocations = ['desk.menu.left', 'desk.ticket.view.rightpanel', 'desk.contact.view.rightpanel', 'desk.contactgroup.view.rightpanel', 'desk.chat.view.rightpanel', 'desk.cti.widget'];
+  return locations.filter(loc => validLocations.includes(loc));
+}
+
+/**
+ * Validate URL format
+ * @param {string} url - URL to validate
+ * @returns {boolean} Is valid URL
+ */
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Format error message for logging
+ * @param {string} context - Context of error
+ * @param {Error} error - Error object
+ * @returns {string} Formatted error message
+ */
+function formatError(context, error) {
+  return `[${context}] ${error.message || error}`;
+}
+
+/***/ },
+
+/***/ "./node_modules/native-promise-only/lib/npo.src.js"
+/*!*********************************************************!*\
+  !*** ./node_modules/native-promise-only/lib/npo.src.js ***!
+  \*********************************************************/
+(module, exports, __webpack_require__) {
+
+var __WEBPACK_AMD_DEFINE_RESULT__;/*! Native Promise Only
+    v0.8.1 (c) Kyle Simpson
+    MIT License: http://getify.mit-license.org
+*/
+
+(function UMD(name,context,definition){
+	// special form of UMD for polyfilling across evironments
+	context[name] = context[name] || definition();
+	if ( true && module.exports) { module.exports = context[name]; }
+	else if (true) { !(__WEBPACK_AMD_DEFINE_RESULT__ = (function $AMD$(){ return context[name]; }).call(exports, __webpack_require__, exports, module),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); }
+})("Promise",typeof __webpack_require__.g != "undefined" ? __webpack_require__.g : this,function DEF(){
+	/*jshint validthis:true */
+	"use strict";
+
+	var builtInProp, cycle, scheduling_queue,
+		ToString = Object.prototype.toString,
+		timer = (typeof setImmediate != "undefined") ?
+			function timer(fn) { return setImmediate(fn); } :
+			setTimeout
+	;
+
+	// dammit, IE8.
+	try {
+		Object.defineProperty({},"x",{});
+		builtInProp = function builtInProp(obj,name,val,config) {
+			return Object.defineProperty(obj,name,{
+				value: val,
+				writable: true,
+				configurable: config !== false
+			});
+		};
+	}
+	catch (err) {
+		builtInProp = function builtInProp(obj,name,val) {
+			obj[name] = val;
+			return obj;
+		};
+	}
+
+	// Note: using a queue instead of array for efficiency
+	scheduling_queue = (function Queue() {
+		var first, last, item;
+
+		function Item(fn,self) {
+			this.fn = fn;
+			this.self = self;
+			this.next = void 0;
+		}
+
+		return {
+			add: function add(fn,self) {
+				item = new Item(fn,self);
+				if (last) {
+					last.next = item;
+				}
+				else {
+					first = item;
+				}
+				last = item;
+				item = void 0;
+			},
+			drain: function drain() {
+				var f = first;
+				first = last = cycle = void 0;
+
+				while (f) {
+					f.fn.call(f.self);
+					f = f.next;
+				}
+			}
+		};
+	})();
+
+	function schedule(fn,self) {
+		scheduling_queue.add(fn,self);
+		if (!cycle) {
+			cycle = timer(scheduling_queue.drain);
+		}
+	}
+
+	// promise duck typing
+	function isThenable(o) {
+		var _then, o_type = typeof o;
+
+		if (o != null &&
+			(
+				o_type == "object" || o_type == "function"
+			)
+		) {
+			_then = o.then;
+		}
+		return typeof _then == "function" ? _then : false;
+	}
+
+	function notify() {
+		for (var i=0; i<this.chain.length; i++) {
+			notifyIsolated(
+				this,
+				(this.state === 1) ? this.chain[i].success : this.chain[i].failure,
+				this.chain[i]
+			);
+		}
+		this.chain.length = 0;
+	}
+
+	// NOTE: This is a separate function to isolate
+	// the `try..catch` so that other code can be
+	// optimized better
+	function notifyIsolated(self,cb,chain) {
+		var ret, _then;
+		try {
+			if (cb === false) {
+				chain.reject(self.msg);
+			}
+			else {
+				if (cb === true) {
+					ret = self.msg;
+				}
+				else {
+					ret = cb.call(void 0,self.msg);
+				}
+
+				if (ret === chain.promise) {
+					chain.reject(TypeError("Promise-chain cycle"));
+				}
+				else if (_then = isThenable(ret)) {
+					_then.call(ret,chain.resolve,chain.reject);
+				}
+				else {
+					chain.resolve(ret);
+				}
+			}
+		}
+		catch (err) {
+			chain.reject(err);
+		}
+	}
+
+	function resolve(msg) {
+		var _then, self = this;
+
+		// already triggered?
+		if (self.triggered) { return; }
+
+		self.triggered = true;
+
+		// unwrap
+		if (self.def) {
+			self = self.def;
+		}
+
+		try {
+			if (_then = isThenable(msg)) {
+				schedule(function(){
+					var def_wrapper = new MakeDefWrapper(self);
+					try {
+						_then.call(msg,
+							function $resolve$(){ resolve.apply(def_wrapper,arguments); },
+							function $reject$(){ reject.apply(def_wrapper,arguments); }
+						);
+					}
+					catch (err) {
+						reject.call(def_wrapper,err);
+					}
+				})
+			}
+			else {
+				self.msg = msg;
+				self.state = 1;
+				if (self.chain.length > 0) {
+					schedule(notify,self);
+				}
+			}
+		}
+		catch (err) {
+			reject.call(new MakeDefWrapper(self),err);
+		}
+	}
+
+	function reject(msg) {
+		var self = this;
+
+		// already triggered?
+		if (self.triggered) { return; }
+
+		self.triggered = true;
+
+		// unwrap
+		if (self.def) {
+			self = self.def;
+		}
+
+		self.msg = msg;
+		self.state = 2;
+		if (self.chain.length > 0) {
+			schedule(notify,self);
+		}
+	}
+
+	function iteratePromises(Constructor,arr,resolver,rejecter) {
+		for (var idx=0; idx<arr.length; idx++) {
+			(function IIFE(idx){
+				Constructor.resolve(arr[idx])
+				.then(
+					function $resolver$(msg){
+						resolver(idx,msg);
+					},
+					rejecter
+				);
+			})(idx);
+		}
+	}
+
+	function MakeDefWrapper(self) {
+		this.def = self;
+		this.triggered = false;
+	}
+
+	function MakeDef(self) {
+		this.promise = self;
+		this.state = 0;
+		this.triggered = false;
+		this.chain = [];
+		this.msg = void 0;
+	}
+
+	function Promise(executor) {
+		if (typeof executor != "function") {
+			throw TypeError("Not a function");
+		}
+
+		if (this.__NPO__ !== 0) {
+			throw TypeError("Not a promise");
+		}
+
+		// instance shadowing the inherited "brand"
+		// to signal an already "initialized" promise
+		this.__NPO__ = 1;
+
+		var def = new MakeDef(this);
+
+		this["then"] = function then(success,failure) {
+			var o = {
+				success: typeof success == "function" ? success : true,
+				failure: typeof failure == "function" ? failure : false
+			};
+			// Note: `then(..)` itself can be borrowed to be used against
+			// a different promise constructor for making the chained promise,
+			// by substituting a different `this` binding.
+			o.promise = new this.constructor(function extractChain(resolve,reject) {
+				if (typeof resolve != "function" || typeof reject != "function") {
+					throw TypeError("Not a function");
+				}
+
+				o.resolve = resolve;
+				o.reject = reject;
+			});
+			def.chain.push(o);
+
+			if (def.state !== 0) {
+				schedule(notify,def);
+			}
+
+			return o.promise;
+		};
+		this["catch"] = function $catch$(failure) {
+			return this.then(void 0,failure);
+		};
+
+		try {
+			executor.call(
+				void 0,
+				function publicResolve(msg){
+					resolve.call(def,msg);
+				},
+				function publicReject(msg) {
+					reject.call(def,msg);
+				}
+			);
+		}
+		catch (err) {
+			reject.call(def,err);
+		}
+	}
+
+	var PromisePrototype = builtInProp({},"constructor",Promise,
+		/*configurable=*/false
+	);
+
+	// Note: Android 4 cannot use `Object.defineProperty(..)` here
+	Promise.prototype = PromisePrototype;
+
+	// built-in "brand" to signal an "uninitialized" promise
+	builtInProp(PromisePrototype,"__NPO__",0,
+		/*configurable=*/false
+	);
+
+	builtInProp(Promise,"resolve",function Promise$resolve(msg) {
+		var Constructor = this;
+
+		// spec mandated checks
+		// note: best "isPromise" check that's practical for now
+		if (msg && typeof msg == "object" && msg.__NPO__ === 1) {
+			return msg;
+		}
+
+		return new Constructor(function executor(resolve,reject){
+			if (typeof resolve != "function" || typeof reject != "function") {
+				throw TypeError("Not a function");
+			}
+
+			resolve(msg);
+		});
+	});
+
+	builtInProp(Promise,"reject",function Promise$reject(msg) {
+		return new this(function executor(resolve,reject){
+			if (typeof resolve != "function" || typeof reject != "function") {
+				throw TypeError("Not a function");
+			}
+
+			reject(msg);
+		});
+	});
+
+	builtInProp(Promise,"all",function Promise$all(arr) {
+		var Constructor = this;
+
+		// spec mandated checks
+		if (ToString.call(arr) != "[object Array]") {
+			return Constructor.reject(TypeError("Not an array"));
+		}
+		if (arr.length === 0) {
+			return Constructor.resolve([]);
+		}
+
+		return new Constructor(function executor(resolve,reject){
+			if (typeof resolve != "function" || typeof reject != "function") {
+				throw TypeError("Not a function");
+			}
+
+			var len = arr.length, msgs = Array(len), count = 0;
+
+			iteratePromises(Constructor,arr,function resolver(idx,msg) {
+				msgs[idx] = msg;
+				if (++count === len) {
+					resolve(msgs);
+				}
+			},reject);
+		});
+	});
+
+	builtInProp(Promise,"race",function Promise$race(arr) {
+		var Constructor = this;
+
+		// spec mandated checks
+		if (ToString.call(arr) != "[object Array]") {
+			return Constructor.reject(TypeError("Not an array"));
+		}
+
+		return new Constructor(function executor(resolve,reject){
+			if (typeof resolve != "function" || typeof reject != "function") {
+				throw TypeError("Not a function");
+			}
+
+			iteratePromises(Constructor,arr,function resolver(idx,msg){
+				resolve(msg);
+			},reject);
+		});
+	});
+
+	return Promise;
+});
+
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		if (!(moduleId in __webpack_modules__)) {
+/******/ 			delete __webpack_module_cache__[moduleId];
+/******/ 			var e = new Error("Cannot find module '" + moduleId + "'");
+/******/ 			e.code = 'MODULE_NOT_FOUND';
+/******/ 			throw e;
+/******/ 		}
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/global */
+/******/ 	(() => {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
+(() => {
+"use strict";
+/*!**********************!*\
+  !*** ./lib/index.js ***!
+  \**********************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Client: () => (/* reexport safe */ _client__WEBPACK_IMPORTED_MODULE_0__["default"]),
+/* harmony export */   ContextAPI: () => (/* reexport safe */ _apis_context__WEBPACK_IMPORTED_MODULE_2__["default"]),
+/* harmony export */   InstanceAPI: () => (/* reexport safe */ _apis_instance__WEBPACK_IMPORTED_MODULE_4__.InstanceAPI),
+/* harmony export */   MetadataAPI: () => (/* reexport safe */ _apis_metadata__WEBPACK_IMPORTED_MODULE_3__["default"]),
+/* harmony export */   RequestAPI: () => (/* reexport safe */ _apis_request__WEBPACK_IMPORTED_MODULE_5__["default"]),
+/* harmony export */   debounce: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.debounce),
+/* harmony export */   deepClone: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.deepClone),
+/* harmony export */   deepMerge: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.deepMerge),
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   formatError: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.formatError),
+/* harmony export */   generateUUID: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.generateUUID),
+/* harmony export */   isArray: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.isArray),
+/* harmony export */   isFunction: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.isFunction),
+/* harmony export */   isNull: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.isNull),
+/* harmony export */   isObject: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.isObject),
+/* harmony export */   isString: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.isString),
+/* harmony export */   isUndefined: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.isUndefined),
+/* harmony export */   isValidUrl: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.isValidUrl),
+/* harmony export */   parseWidgetLocations: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.parseWidgetLocations),
+/* harmony export */   queryParameters: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.queryParameters),
+/* harmony export */   throttle: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.throttle),
+/* harmony export */   validateManifest: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.validateManifest),
+/* harmony export */   when: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.when)
+/* harmony export */ });
+/* harmony import */ var _client__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./client */ "./lib/client.js");
+/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils */ "./lib/utils.js");
+/* harmony import */ var _apis_context__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./apis/context */ "./lib/apis/context.js");
+/* harmony import */ var _apis_metadata__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./apis/metadata */ "./lib/apis/metadata.js");
+/* harmony import */ var _apis_instance__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./apis/instance */ "./lib/apis/instance.js");
+/* harmony import */ var _apis_request__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./apis/request */ "./lib/apis/request.js");
+/**
+ * BoldDesk App Framework SDK
+ * Main entry point for the BAF SDK library
+ */
+
+
+
+
+/**
+ * BAFClient - BoldDesk App Framework Client
+ *
+ * Main API for initializing and using the BoldDesk App Framework SDK
+ * in embedded app iframes.
+ *
+ * @example
+ * // Initialize the client
+ * const client = BAFClient.init((context) => {
+ *   console.log('App initialized');
+ *   console.log('Current module:', context.module);
+ *   console.log('User:', context.user.name);
+ * });
+ *
+ * // Use the client APIs
+ * client.get('ticket.subject').then(data => {
+ *   console.log(data['ticket.subject']);
+ * });
+ */
+
+const BAFClient = {
+  /**
+   * Initialize BAFClient and establish connection with BoldDesk host
+   *
+   * Call this function in your app's HTML to initialize the SDK.
+   * The client will automatically detect the app instance and establish
+   * two-way communication with the BoldDesk platform.
+   *
+   * @param {Function} callback - Optional callback function called when app is registered
+   *                             Receives context object with app information
+   * @param {Object} loc - Optional window location object (for testing)
+   * @returns {Client|boolean} Client instance or false if not in iframe
+   *
+   * @example
+   * // Basic usage
+   * const client = BAFClient.init();
+   *
+   * @example
+   * // With callback
+   * const client = BAFClient.init((context) => {
+   *   const currentUser = context.user;
+   *   console.log('Hello ' + currentUser.name);
+   * });
+   */
+  init: function (callback, loc) {
+    loc = loc || window.location;
+
+    // Parse query/hash parameters
+    const queryParams = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.queryParameters)(loc.search);
+    const hashParams = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.queryParameters)(loc.hash);
+
+    // Required parameters for iframe app
+    const origin = queryParams.origin || hashParams.origin;
+    const appGuid = queryParams.app_guid || hashParams.app_guid;
+
+    // Validate required parameters
+    if (!origin || !appGuid) {
+      console.error('BAFClient.init(): Missing required parameters. ' + 'App must be loaded with "origin" and "app_guid" parameters.');
+      return false;
+    }
+
+    // Create client instance
+    const client = new _client__WEBPACK_IMPORTED_MODULE_0__["default"]({
+      origin,
+      appGuid
+    });
+
+    // Register callback for app registration event
+    if (typeof callback === 'function') {
+      client.on('app.registered', function (context) {
+        callback.call(client, context);
+      });
+    }
+    return client;
+  }
+};
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (BAFClient);
+
+// Also export Client for advanced usage
+
+
+// Export utility functions
+
+
+// Export APIs for direct access
+
+
+
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});
+//# sourceMappingURL=baf_sdk.js.map