@microsoft/teams-js
Version:
Microsoft Client SDK for building app for Microsoft hosts
1,516 lines (1,358 loc) • 832 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define("microsoftTeams", [], factory);
else if(typeof exports === 'object')
exports["microsoftTeams"] = factory();
else
root["microsoftTeams"] = factory();
})(typeof self !== 'undefined' ? self : this, () => {
return /******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 933:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
exports.byteLength = byteLength
exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray
var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
for (var i = 0, len = code.length; i < len; ++i) {
lookup[i] = code[i]
revLookup[code.charCodeAt(i)] = i
}
// Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
revLookup['-'.charCodeAt(0)] = 62
revLookup['_'.charCodeAt(0)] = 63
function getLens (b64) {
var len = b64.length
if (len % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}
// Trim off extra bytes after placeholder bytes are found
// See: https://github.com/beatgammit/base64-js/issues/42
var validLen = b64.indexOf('=')
if (validLen === -1) validLen = len
var placeHoldersLen = validLen === len
? 0
: 4 - (validLen % 4)
return [validLen, placeHoldersLen]
}
// base64 is 4/3 + up to two characters of the original data
function byteLength (b64) {
var lens = getLens(b64)
var validLen = lens[0]
var placeHoldersLen = lens[1]
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}
function _byteLength (b64, validLen, placeHoldersLen) {
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}
function toByteArray (b64) {
var tmp
var lens = getLens(b64)
var validLen = lens[0]
var placeHoldersLen = lens[1]
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
var curByte = 0
// if there are placeholders, only get up to the last complete 4 chars
var len = placeHoldersLen > 0
? validLen - 4
: validLen
var i
for (i = 0; i < len; i += 4) {
tmp =
(revLookup[b64.charCodeAt(i)] << 18) |
(revLookup[b64.charCodeAt(i + 1)] << 12) |
(revLookup[b64.charCodeAt(i + 2)] << 6) |
revLookup[b64.charCodeAt(i + 3)]
arr[curByte++] = (tmp >> 16) & 0xFF
arr[curByte++] = (tmp >> 8) & 0xFF
arr[curByte++] = tmp & 0xFF
}
if (placeHoldersLen === 2) {
tmp =
(revLookup[b64.charCodeAt(i)] << 2) |
(revLookup[b64.charCodeAt(i + 1)] >> 4)
arr[curByte++] = tmp & 0xFF
}
if (placeHoldersLen === 1) {
tmp =
(revLookup[b64.charCodeAt(i)] << 10) |
(revLookup[b64.charCodeAt(i + 1)] << 4) |
(revLookup[b64.charCodeAt(i + 2)] >> 2)
arr[curByte++] = (tmp >> 8) & 0xFF
arr[curByte++] = tmp & 0xFF
}
return arr
}
function tripletToBase64 (num) {
return lookup[num >> 18 & 0x3F] +
lookup[num >> 12 & 0x3F] +
lookup[num >> 6 & 0x3F] +
lookup[num & 0x3F]
}
function encodeChunk (uint8, start, end) {
var tmp
var output = []
for (var i = start; i < end; i += 3) {
tmp =
((uint8[i] << 16) & 0xFF0000) +
((uint8[i + 1] << 8) & 0xFF00) +
(uint8[i + 2] & 0xFF)
output.push(tripletToBase64(tmp))
}
return output.join('')
}
function fromByteArray (uint8) {
var tmp
var len = uint8.length
var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
var parts = []
var maxChunkLength = 16383 // must be multiple of 3
// go through the array every three bytes, we'll deal with trailing stuff later
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
}
// pad the end with zeros, but make sure to not forget the extra bytes
if (extraBytes === 1) {
tmp = uint8[len - 1]
parts.push(
lookup[tmp >> 2] +
lookup[(tmp << 4) & 0x3F] +
'=='
)
} else if (extraBytes === 2) {
tmp = (uint8[len - 2] << 8) + uint8[len - 1]
parts.push(
lookup[tmp >> 10] +
lookup[(tmp >> 4) & 0x3F] +
lookup[(tmp << 2) & 0x3F] +
'='
)
}
return parts.join('')
}
/***/ }),
/***/ 815:
/***/ ((module, exports, __webpack_require__) => {
/* eslint-env browser */
/**
* This is the web browser implementation of `debug()`.
*/
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.storage = localstorage();
exports.destroy = (() => {
let warned = false;
return () => {
if (!warned) {
warned = true;
console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
}
};
})();
/**
* Colors.
*/
exports.colors = [
'#0000CC',
'#0000FF',
'#0033CC',
'#0033FF',
'#0066CC',
'#0066FF',
'#0099CC',
'#0099FF',
'#00CC00',
'#00CC33',
'#00CC66',
'#00CC99',
'#00CCCC',
'#00CCFF',
'#3300CC',
'#3300FF',
'#3333CC',
'#3333FF',
'#3366CC',
'#3366FF',
'#3399CC',
'#3399FF',
'#33CC00',
'#33CC33',
'#33CC66',
'#33CC99',
'#33CCCC',
'#33CCFF',
'#6600CC',
'#6600FF',
'#6633CC',
'#6633FF',
'#66CC00',
'#66CC33',
'#9900CC',
'#9900FF',
'#9933CC',
'#9933FF',
'#99CC00',
'#99CC33',
'#CC0000',
'#CC0033',
'#CC0066',
'#CC0099',
'#CC00CC',
'#CC00FF',
'#CC3300',
'#CC3333',
'#CC3366',
'#CC3399',
'#CC33CC',
'#CC33FF',
'#CC6600',
'#CC6633',
'#CC9900',
'#CC9933',
'#CCCC00',
'#CCCC33',
'#FF0000',
'#FF0033',
'#FF0066',
'#FF0099',
'#FF00CC',
'#FF00FF',
'#FF3300',
'#FF3333',
'#FF3366',
'#FF3399',
'#FF33CC',
'#FF33FF',
'#FF6600',
'#FF6633',
'#FF9900',
'#FF9933',
'#FFCC00',
'#FFCC33'
];
/**
* Currently only WebKit-based Web Inspectors, Firefox >= v31,
* and the Firebug extension (any Firefox version) are known
* to support "%c" CSS customizations.
*
* TODO: add a `localStorage` variable to explicitly enable/disable colors
*/
// eslint-disable-next-line complexity
function useColors() {
// NB: In an Electron preload script, document will be defined but not fully
// initialized. Since we know we're in Chrome, we'll just detect this case
// explicitly
if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
return true;
}
// Internet Explorer and Edge do not support colors.
if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
return false;
}
// Is webkit? http://stackoverflow.com/a/16459606/376773
// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
// Is firebug? http://stackoverflow.com/a/398120/376773
(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
// Is firefox >= v31?
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
// Double check webkit in userAgent just in case we are in a worker
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
}
/**
* Colorize log arguments if enabled.
*
* @api public
*/
function formatArgs(args) {
args[0] = (this.useColors ? '%c' : '') +
this.namespace +
(this.useColors ? ' %c' : ' ') +
args[0] +
(this.useColors ? '%c ' : ' ') +
'+' + module.exports.humanize(this.diff);
if (!this.useColors) {
return;
}
const c = 'color: ' + this.color;
args.splice(1, 0, c, 'color: inherit');
// The final "%c" is somewhat tricky, because there could be other
// arguments passed either before or after the %c, so we need to
// figure out the correct index to insert the CSS into
let index = 0;
let lastC = 0;
args[0].replace(/%[a-zA-Z%]/g, match => {
if (match === '%%') {
return;
}
index++;
if (match === '%c') {
// We only are interested in the *last* %c
// (the user may have provided their own)
lastC = index;
}
});
args.splice(lastC, 0, c);
}
/**
* Invokes `console.debug()` when available.
* No-op when `console.debug` is not a "function".
* If `console.debug` is not available, falls back
* to `console.log`.
*
* @api public
*/
exports.log = console.debug || console.log || (() => {});
/**
* Save `namespaces`.
*
* @param {String} namespaces
* @api private
*/
function save(namespaces) {
try {
if (namespaces) {
exports.storage.setItem('debug', namespaces);
} else {
exports.storage.removeItem('debug');
}
} catch (error) {
// Swallow
// XXX (@Qix-) should we be logging these?
}
}
/**
* Load `namespaces`.
*
* @return {String} returns the previously persisted debug modes
* @api private
*/
function load() {
let r;
try {
r = exports.storage.getItem('debug');
} catch (error) {
// Swallow
// XXX (@Qix-) should we be logging these?
}
// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
if (!r && typeof process !== 'undefined' && 'env' in process) {
r = process.env.DEBUG;
}
return r;
}
/**
* Localstorage attempts to return the localstorage.
*
* This is necessary because safari throws
* when a user disables cookies/localstorage
* and you attempt to access it.
*
* @return {LocalStorage}
* @api private
*/
function localstorage() {
try {
// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
// The Browser also has localStorage in the global context.
return localStorage;
} catch (error) {
// Swallow
// XXX (@Qix-) should we be logging these?
}
}
module.exports = __webpack_require__(530)(exports);
const {formatters} = module.exports;
/**
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
*/
formatters.j = function (v) {
try {
return JSON.stringify(v);
} catch (error) {
return '[UnexpectedJSONParseError]: ' + error.message;
}
};
/***/ }),
/***/ 530:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
/**
* This is the common logic for both the Node.js and web browser
* implementations of `debug()`.
*/
function setup(env) {
createDebug.debug = createDebug;
createDebug.default = createDebug;
createDebug.coerce = coerce;
createDebug.disable = disable;
createDebug.enable = enable;
createDebug.enabled = enabled;
createDebug.humanize = __webpack_require__(821);
createDebug.destroy = destroy;
Object.keys(env).forEach(key => {
createDebug[key] = env[key];
});
/**
* The currently active debug mode names, and names to skip.
*/
createDebug.names = [];
createDebug.skips = [];
/**
* Map of special "%n" handling functions, for the debug "format" argument.
*
* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
*/
createDebug.formatters = {};
/**
* Selects a color for a debug namespace
* @param {String} namespace The namespace string for the debug instance to be colored
* @return {Number|String} An ANSI color code for the given namespace
* @api private
*/
function selectColor(namespace) {
let hash = 0;
for (let i = 0; i < namespace.length; i++) {
hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
hash |= 0; // Convert to 32bit integer
}
return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
}
createDebug.selectColor = selectColor;
/**
* Create a debugger with the given `namespace`.
*
* @param {String} namespace
* @return {Function}
* @api public
*/
function createDebug(namespace) {
let prevTime;
let enableOverride = null;
let namespacesCache;
let enabledCache;
function debug(...args) {
// Disabled?
if (!debug.enabled) {
return;
}
const self = debug;
// Set `diff` timestamp
const curr = Number(new Date());
const ms = curr - (prevTime || curr);
self.diff = ms;
self.prev = prevTime;
self.curr = curr;
prevTime = curr;
args[0] = createDebug.coerce(args[0]);
if (typeof args[0] !== 'string') {
// Anything else let's inspect with %O
args.unshift('%O');
}
// Apply any `formatters` transformations
let index = 0;
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
// If we encounter an escaped % then don't increase the array index
if (match === '%%') {
return '%';
}
index++;
const formatter = createDebug.formatters[format];
if (typeof formatter === 'function') {
const val = args[index];
match = formatter.call(self, val);
// Now we need to remove `args[index]` since it's inlined in the `format`
args.splice(index, 1);
index--;
}
return match;
});
// Apply env-specific formatting (colors, etc.)
createDebug.formatArgs.call(self, args);
const logFn = self.log || createDebug.log;
logFn.apply(self, args);
}
debug.namespace = namespace;
debug.useColors = createDebug.useColors();
debug.color = createDebug.selectColor(namespace);
debug.extend = extend;
debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
Object.defineProperty(debug, 'enabled', {
enumerable: true,
configurable: false,
get: () => {
if (enableOverride !== null) {
return enableOverride;
}
if (namespacesCache !== createDebug.namespaces) {
namespacesCache = createDebug.namespaces;
enabledCache = createDebug.enabled(namespace);
}
return enabledCache;
},
set: v => {
enableOverride = v;
}
});
// Env-specific initialization logic for debug instances
if (typeof createDebug.init === 'function') {
createDebug.init(debug);
}
return debug;
}
function extend(namespace, delimiter) {
const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
newDebug.log = this.log;
return newDebug;
}
/**
* Enables a debug mode by namespaces. This can include modes
* separated by a colon and wildcards.
*
* @param {String} namespaces
* @api public
*/
function enable(namespaces) {
createDebug.save(namespaces);
createDebug.namespaces = namespaces;
createDebug.names = [];
createDebug.skips = [];
let i;
const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
const len = split.length;
for (i = 0; i < len; i++) {
if (!split[i]) {
// ignore empty strings
continue;
}
namespaces = split[i].replace(/\*/g, '.*?');
if (namespaces[0] === '-') {
createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
} else {
createDebug.names.push(new RegExp('^' + namespaces + '$'));
}
}
}
/**
* Disable debug output.
*
* @return {String} namespaces
* @api public
*/
function disable() {
const namespaces = [
...createDebug.names.map(toNamespace),
...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
].join(',');
createDebug.enable('');
return namespaces;
}
/**
* Returns true if the given mode name is enabled, false otherwise.
*
* @param {String} name
* @return {Boolean}
* @api public
*/
function enabled(name) {
if (name[name.length - 1] === '*') {
return true;
}
let i;
let len;
for (i = 0, len = createDebug.skips.length; i < len; i++) {
if (createDebug.skips[i].test(name)) {
return false;
}
}
for (i = 0, len = createDebug.names.length; i < len; i++) {
if (createDebug.names[i].test(name)) {
return true;
}
}
return false;
}
/**
* Convert regexp to namespace
*
* @param {RegExp} regxep
* @return {String} namespace
* @api private
*/
function toNamespace(regexp) {
return regexp.toString()
.substring(2, regexp.toString().length - 2)
.replace(/\.\*\?$/, '*');
}
/**
* Coerce `val`.
*
* @param {Mixed} val
* @return {Mixed}
* @api private
*/
function coerce(val) {
if (val instanceof Error) {
return val.stack || val.message;
}
return val;
}
/**
* XXX DO NOT USE. This is a temporary stub function.
* XXX It WILL be removed in the next major release.
*/
function destroy() {
console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
}
createDebug.enable(createDebug.load());
return createDebug;
}
module.exports = setup;
/***/ }),
/***/ 821:
/***/ ((module) => {
/**
* Helpers.
*/
var s = 1000;
var m = s * 60;
var h = m * 60;
var d = h * 24;
var w = d * 7;
var y = d * 365.25;
/**
* Parse or format the given `val`.
*
* Options:
*
* - `long` verbose formatting [false]
*
* @param {String|Number} val
* @param {Object} [options]
* @throws {Error} throw an error if val is not a non-empty string or a number
* @return {String|Number}
* @api public
*/
module.exports = function(val, options) {
options = options || {};
var type = typeof val;
if (type === 'string' && val.length > 0) {
return parse(val);
} else if (type === 'number' && isFinite(val)) {
return options.long ? fmtLong(val) : fmtShort(val);
}
throw new Error(
'val is not a non-empty string or a valid number. val=' +
JSON.stringify(val)
);
};
/**
* Parse the given `str` and return milliseconds.
*
* @param {String} str
* @return {Number}
* @api private
*/
function parse(str) {
str = String(str);
if (str.length > 100) {
return;
}
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
str
);
if (!match) {
return;
}
var n = parseFloat(match[1]);
var type = (match[2] || 'ms').toLowerCase();
switch (type) {
case 'years':
case 'year':
case 'yrs':
case 'yr':
case 'y':
return n * y;
case 'weeks':
case 'week':
case 'w':
return n * w;
case 'days':
case 'day':
case 'd':
return n * d;
case 'hours':
case 'hour':
case 'hrs':
case 'hr':
case 'h':
return n * h;
case 'minutes':
case 'minute':
case 'mins':
case 'min':
case 'm':
return n * m;
case 'seconds':
case 'second':
case 'secs':
case 'sec':
case 's':
return n * s;
case 'milliseconds':
case 'millisecond':
case 'msecs':
case 'msec':
case 'ms':
return n;
default:
return undefined;
}
}
/**
* Short format for `ms`.
*
* @param {Number} ms
* @return {String}
* @api private
*/
function fmtShort(ms) {
var msAbs = Math.abs(ms);
if (msAbs >= d) {
return Math.round(ms / d) + 'd';
}
if (msAbs >= h) {
return Math.round(ms / h) + 'h';
}
if (msAbs >= m) {
return Math.round(ms / m) + 'm';
}
if (msAbs >= s) {
return Math.round(ms / s) + 's';
}
return ms + 'ms';
}
/**
* Long format for `ms`.
*
* @param {Number} ms
* @return {String}
* @api private
*/
function fmtLong(ms) {
var msAbs = Math.abs(ms);
if (msAbs >= d) {
return plural(ms, msAbs, d, 'day');
}
if (msAbs >= h) {
return plural(ms, msAbs, h, 'hour');
}
if (msAbs >= m) {
return plural(ms, msAbs, m, 'minute');
}
if (msAbs >= s) {
return plural(ms, msAbs, s, 'second');
}
return ms + ' ms';
}
/**
* Pluralization helper.
*/
function plural(ms, msAbs, n, name) {
var isPlural = msAbs >= n * 1.5;
return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
}
/***/ })
/******/ });
/************************************************************************/
/******/ // 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
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/************************************************************************/
/******/ /* webpack/runtime/create fake namespace object */
/******/ (() => {
/******/ var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);
/******/ var leafPrototypes;
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 16: return value when it's Promise-like
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = this(value);
/******/ if(mode & 8) return value;
/******/ if(typeof value === 'object' && value) {
/******/ if((mode & 4) && value.__esModule) return value;
/******/ if((mode & 16) && typeof value.then === 'function') return value;
/******/ }
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ var def = {};
/******/ leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
/******/ for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {
/******/ Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));
/******/ }
/******/ def['default'] = () => (value);
/******/ __webpack_require__.d(ns, def);
/******/ return ns;
/******/ };
/******/ })();
/******/
/******/ /* 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/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";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
ActionObjectType: () => (/* reexport */ ActionObjectType),
AppId: () => (/* reexport */ AppId),
ChannelType: () => (/* reexport */ ChannelType),
ChildAppWindow: () => (/* reexport */ ChildAppWindow),
DialogDimension: () => (/* reexport */ DialogDimension),
EduType: () => (/* reexport */ EduType),
EmailAddress: () => (/* reexport */ EmailAddress),
ErrorCode: () => (/* reexport */ ErrorCode),
FileOpenPreference: () => (/* reexport */ FileOpenPreference),
FrameContexts: () => (/* reexport */ FrameContexts),
HostClientType: () => (/* reexport */ HostClientType),
HostName: () => (/* reexport */ HostName),
LiveShareHost: () => (/* reexport */ LiveShareHost),
NotificationTypes: () => (/* reexport */ NotificationTypes),
ParentAppWindow: () => (/* reexport */ ParentAppWindow),
RenderingSurfaces: () => (/* reexport */ RenderingSurfaces),
SecondaryM365ContentIdName: () => (/* reexport */ SecondaryM365ContentIdName),
TaskModuleDimension: () => (/* reexport */ DialogDimension),
TeamType: () => (/* reexport */ TeamType),
UUID: () => (/* reexport */ UUID),
UserAuthenticationState: () => (/* reexport */ UserAuthenticationState),
UserSettingTypes: () => (/* reexport */ UserSettingTypes),
UserTeamRole: () => (/* reexport */ UserTeamRole),
ValidatedSafeString: () => (/* reexport */ validatedSafeString_ValidatedSafeString),
ViewerActionTypes: () => (/* reexport */ ViewerActionTypes),
activateChildProxyingCommunication: () => (/* reexport */ activateChildProxyingCommunication),
app: () => (/* reexport */ app_namespaceObject),
appEntity: () => (/* reexport */ appEntity_namespaceObject),
appInitialization: () => (/* reexport */ appInitialization_namespaceObject),
appInstallDialog: () => (/* reexport */ appInstallDialog_namespaceObject),
appPerformanceMetrics: () => (/* reexport */ appPerformanceMetrics_namespaceObject),
authentication: () => (/* reexport */ authentication_namespaceObject),
barCode: () => (/* reexport */ barCode_namespaceObject),
calendar: () => (/* reexport */ calendar_namespaceObject),
call: () => (/* reexport */ call_namespaceObject),
chat: () => (/* reexport */ chat_namespaceObject),
clipboard: () => (/* reexport */ clipboard_namespaceObject),
conversations: () => (/* reexport */ conversations_namespaceObject),
copilot: () => (/* reexport */ copilot_namespaceObject),
dialog: () => (/* reexport */ dialog_namespaceObject),
enablePrintCapability: () => (/* reexport */ publicAPIs_enablePrintCapability),
executeDeepLink: () => (/* reexport */ executeDeepLink),
externalAppAuthentication: () => (/* reexport */ externalAppAuthentication_namespaceObject),
externalAppAuthenticationForCEA: () => (/* reexport */ externalAppAuthenticationForCEA_namespaceObject),
externalAppCardActions: () => (/* reexport */ externalAppCardActions_namespaceObject),
externalAppCardActionsForCEA: () => (/* reexport */ externalAppCardActionsForCEA_namespaceObject),
externalAppCardActionsForDA: () => (/* reexport */ externalAppCardActionsForDA_namespaceObject),
externalAppCommands: () => (/* reexport */ externalAppCommands_namespaceObject),
files: () => (/* reexport */ files_namespaceObject),
geoLocation: () => (/* reexport */ geoLocation_namespaceObject),
getAdaptiveCardSchemaVersion: () => (/* reexport */ getAdaptiveCardSchemaVersion),
getContext: () => (/* reexport */ publicAPIs_getContext),
getCurrentFeatureFlagsState: () => (/* reexport */ getCurrentFeatureFlagsState),
getMruTabInstances: () => (/* reexport */ publicAPIs_getMruTabInstances),
getTabInstances: () => (/* reexport */ publicAPIs_getTabInstances),
hostEntity: () => (/* reexport */ hostEntity_namespaceObject),
initialize: () => (/* reexport */ publicAPIs_initialize),
initializeWithFrameContext: () => (/* reexport */ publicAPIs_initializeWithFrameContext),
liveShare: () => (/* reexport */ liveShareHost_namespaceObject),
location: () => (/* reexport */ location_namespaceObject),
logs: () => (/* reexport */ logs_namespaceObject),
mail: () => (/* reexport */ mail_namespaceObject),
marketplace: () => (/* reexport */ marketplace_namespaceObject),
media: () => (/* reexport */ media_namespaceObject),
meeting: () => (/* reexport */ meeting_namespaceObject),
meetingRoom: () => (/* reexport */ meetingRoom_namespaceObject),
menus: () => (/* reexport */ menus_namespaceObject),
messageChannels: () => (/* reexport */ messageChannels_namespaceObject),
monetization: () => (/* reexport */ monetization_namespaceObject),
navigateBack: () => (/* reexport */ navigation_navigateBack),
navigateCrossDomain: () => (/* reexport */ navigation_navigateCrossDomain),
navigateToTab: () => (/* reexport */ navigation_navigateToTab),
nestedAppAuth: () => (/* reexport */ nestedAppAuth_namespaceObject),
nestedAppAuthBridge: () => (/* reexport */ nestedAppAuthBridge_namespaceObject),
notifications: () => (/* reexport */ notifications_namespaceObject),
openFilePreview: () => (/* reexport */ openFilePreview),
otherAppStateChange: () => (/* reexport */ otherAppStateChange_namespaceObject),
overwriteFeatureFlagsState: () => (/* reexport */ overwriteFeatureFlagsState),
pages: () => (/* reexport */ pages_namespaceObject),
people: () => (/* reexport */ people_namespaceObject),
print: () => (/* reexport */ publicAPIs_print),
profile: () => (/* reexport */ profile_namespaceObject),
registerAppButtonClickHandler: () => (/* reexport */ registerAppButtonClickHandler),
registerAppButtonHoverEnterHandler: () => (/* reexport */ registerAppButtonHoverEnterHandler),
registerAppButtonHoverLeaveHandler: () => (/* reexport */ registerAppButtonHoverLeaveHandler),
registerBackButtonHandler: () => (/* reexport */ publicAPIs_registerBackButtonHandler),
registerBeforeUnloadHandler: () => (/* reexport */ publicAPIs_registerBeforeUnloadHandler),
registerChangeSettingsHandler: () => (/* reexport */ registerChangeSettingsHandler),
registerCustomHandler: () => (/* reexport */ registerCustomHandler),
registerFocusEnterHandler: () => (/* reexport */ publicAPIs_registerFocusEnterHandler),
registerFullScreenHandler: () => (/* reexport */ publicAPIs_registerFullScreenHandler),
registerOnLoadHandler: () => (/* reexport */ publicAPIs_registerOnLoadHandler),
registerOnThemeChangeHandler: () => (/* reexport */ publicAPIs_registerOnThemeChangeHandler),
registerUserSettingsChangeHandler: () => (/* reexport */ registerUserSettingsChangeHandler),
remoteCamera: () => (/* reexport */ remoteCamera_namespaceObject),
returnFocus: () => (/* reexport */ navigation_returnFocus),
search: () => (/* reexport */ search_namespaceObject),
secondaryBrowser: () => (/* reexport */ secondaryBrowser_namespaceObject),
sendCustomEvent: () => (/* reexport */ sendCustomEvent),
sendCustomMessage: () => (/* reexport */ sendCustomMessage),
setFeatureFlagsState: () => (/* reexport */ setFeatureFlagsState),
setFrameContext: () => (/* reexport */ setFrameContext),
settings: () => (/* reexport */ settings_namespaceObject),
shareDeepLink: () => (/* reexport */ publicAPIs_shareDeepLink),
sharing: () => (/* reexport */ sharing_namespaceObject),
shortcutRelay: () => (/* reexport */ shortcutRelay_namespaceObject),
sidePanelInterfaces: () => (/* reexport */ sidePanelInterfaces_namespaceObject),
stageView: () => (/* reexport */ stageView_namespaceObject),
store: () => (/* reexport */ store_namespaceObject),
tasks: () => (/* reexport */ tasks_namespaceObject),
teams: () => (/* reexport */ teams_namespaceObject),
teamsCore: () => (/* reexport */ teamsAPIs_namespaceObject),
thirdPartyCloudStorage: () => (/* reexport */ thirdPartyCloudStorage_namespaceObject),
uploadCustomApp: () => (/* reexport */ uploadCustomApp),
version: () => (/* reexport */ version),
videoEffects: () => (/* reexport */ videoEffects_namespaceObject),
videoEffectsEx: () => (/* reexport */ videoEffectsEx_namespaceObject),
visualMedia: () => (/* reexport */ visualMedia_namespaceObject),
webStorage: () => (/* reexport */ webStorage_namespaceObject),
widgetHosting: () => (/* reexport */ widgetHosting_namespaceObject)
});
// NAMESPACE OBJECT: ./src/private/messageChannels/telemetry.ts
var messageChannels_telemetry_namespaceObject = {};
__webpack_require__.r(messageChannels_telemetry_namespaceObject);
__webpack_require__.d(messageChannels_telemetry_namespaceObject, {
_clearTelemetryPort: () => (_clearTelemetryPort),
getTelemetryPort: () => (getTelemetryPort),
isSupported: () => (isSupported)
});
// NAMESPACE OBJECT: ./src/private/messageChannels/dataLayer.ts
var dataLayer_namespaceObject = {};
__webpack_require__.r(dataLayer_namespaceObject);
__webpack_require__.d(dataLayer_namespaceObject, {
_clearDataLayerPort: () => (_clearDataLayerPort),
getDataLayerPort: () => (getDataLayerPort),
isSupported: () => (dataLayer_isSupported)
});
// NAMESPACE OBJECT: ./src/public/app/lifecycle.ts
var lifecycle_namespaceObject = {};
__webpack_require__.r(lifecycle_namespaceObject);
__webpack_require__.d(lifecycle_namespaceObject, {
registerBeforeSuspendOrTerminateHandler: () => (registerBeforeSuspendOrTerminateHandler),
registerOnResumeHandler: () => (registerOnResumeHandler)
});
// NAMESPACE OBJECT: ./src/public/app/app.ts
var app_namespaceObject = {};
__webpack_require__.r(app_namespaceObject);
__webpack_require__.d(app_namespaceObject, {
ExpectedFailureReason: () => (ExpectedFailureReason),
FailedReason: () => (FailedReason),
Messages: () => (Messages),
_initialize: () => (_initialize),
_uninitialize: () => (_uninitialize),
getContext: () => (getContext),
getFrameContext: () => (getFrameContext),
initialize: () => (initialize),
isInitialized: () => (isInitialized),
lifecycle: () => (lifecycle_namespaceObject),
notifyAppLoaded: () => (notifyAppLoaded),
notifyExpectedFailure: () => (notifyExpectedFailure),
notifyFailure: () => (notifyFailure),
notifySuccess: () => (notifySuccess),
openLink: () => (openLink),
registerHostToAppPerformanceMetricsHandler: () => (registerHostToAppPerformanceMetricsHandler),
registerOnContextChangeHandler: () => (registerOnContextChangeHandler),
registerOnThemeChangeHandler: () => (registerOnThemeChangeHandler)
});
// NAMESPACE OBJECT: ./src/public/dialog/update.ts
var update_namespaceObject = {};
__webpack_require__.r(update_namespaceObject);
__webpack_require__.d(update_namespaceObject, {
isSupported: () => (update_isSupported),
resize: () => (resize)
});
// NAMESPACE OBJECT: ./src/public/dialog/url/bot.ts
var bot_namespaceObject = {};
__webpack_require__.r(bot_namespaceObject);
__webpack_require__.d(bot_namespaceObject, {
isSupported: () => (bot_isSupported),
open: () => (bot_open)
});
// NAMESPACE OBJECT: ./src/public/dialog/url/parentCommunication.ts
var parentCommunication_namespaceObject = {};
__webpack_require__.r(parentCommunication_namespaceObject);
__webpack_require__.d(parentCommunication_namespaceObject, {
isSupported: () => (parentCommunication_isSupported),
registerOnMessageFromParent: () => (registerOnMessageFromParent),
sendMessageToDialog: () => (sendMessageToDialog),
sendMessageToParentFromDialog: () => (sendMessageToParentFromDialog)
});
// NAMESPACE OBJECT: ./src/public/dialog/url/url.ts
var url_namespaceObject = {};
__webpack_require__.r(url_namespaceObject);
__webpack_require__.d(url_namespaceObject, {
bot: () => (bot_namespaceObject),
getDialogInfoFromBotUrlDialogInfo: () => (getDialogInfoFromBotUrlDialogInfo),
getDialogInfoFromUrlDialogInfo: () => (getDialogInfoFromUrlDialogInfo),
isSupported: () => (url_isSupported),
open: () => (url_open),
parentCommunication: () => (parentCommunication_namespaceObject),
submit: () => (url_submit)
});
// NAMESPACE OBJECT: ./src/public/dialog/adaptiveCard/bot.ts
var adaptiveCard_bot_namespaceObject = {};
__webpack_require__.r(adaptiveCard_bot_namespaceObject);
__webpack_require__.d(adaptiveCard_bot_namespaceObject, {
isSupported: () => (adaptiveCard_bot_isSupported),
open: () => (adaptiveCard_bot_open)
});
// NAMESPACE OBJECT: ./src/public/dialog/adaptiveCard/adaptiveCard.ts
var adaptiveCard_namespaceObject = {};
__webpack_require__.r(adaptiveCard_namespaceObject);
__webpack_require__.d(adaptiveCard_namespaceObject, {
bot: () => (adaptiveCard_bot_namespaceObject),
isSupported: () => (adaptiveCard_isSupported),
open: () => (adaptiveCard_open)
});
// NAMESPACE OBJECT: ./src/public/dialog/dialog.ts
var dialog_namespaceObject = {};
__webpack_require__.r(dialog_namespaceObject);
__webpack_require__.d(dialog_namespaceObject, {
adaptiveCard: () => (adaptiveCard_namespaceObject),
initialize: () => (dialog_initialize),
isSupported: () => (dialog_isSupported),
update: () => (update_namespaceObject),
url: () => (url_namespaceObject)
});
// NAMESPACE OBJECT: ./src/public/menus.ts
var menus_namespaceObject = {};
__webpack_require__.r(menus_namespaceObject);
__webpack_require__.d(menus_namespaceObject, {
DisplayMode: () => (DisplayMode),
MenuItem: () => (MenuItem),
MenuListType: () => (MenuListType),
initialize: () => (menus_initialize),
isSupported: () => (menus_isSupported),
setNavBarMenu: () => (setNavBarMenu),
setUpViews: () => (setUpViews),
showActionMenu: () => (showActionMenu)
});
// NAMESPACE OBJECT: ./src/public/pages/config.ts
var config_namespaceObject = {};
__webpack_require__.r(config_namespaceObject);
__webpack_require__.d(config_namespaceObject, {
initialize: () => (config_initialize),
isSupported: () => (config_isSupported),
registerChangeConfigHandler: () => (registerChangeConfigHandler),
registerOnRemoveHandler: () => (registerOnRemoveHandler),
registerOnRemoveHandlerHelper: () => (registerOnRemoveHandlerHelper),
registerOnSaveHandler: () => (registerOnSaveHandler),
registerOnSaveHandlerHelper: () => (registerOnSaveHandlerHelper),
setConfig: () => (setConfig),
setValidityState: () => (setValidityState)
});
// NAMESPACE OBJECT: ./src/public/pages/appButton.ts
var appButton_namespaceObject = {};
__webpack_require__.r(appButton_namespaceObject);
__webpack_require__.d(appButton_namespaceObject, {
isSupported: () => (appButton_isSupported),
onClick: () => (onClick),
onHoverEnter: () => (onHoverEnter),
onHoverLeave: () => (onHoverLeave)
});
// NAMESPACE OBJECT: ./src/public/pages/backStack.ts
var backStack_namespaceObject = {};
__webpack_require__.r(backStack_namespaceObject);
__webpack_require__.d(backStack_namespaceObject, {
_initialize: () => (backStack_initialize),
isSupported: () => (backStack_isSupported),
navigateBack: () => (navigateBack),
registerBackButtonHandler: () => (registerBackButtonHandler),
registerBackButtonHandlerHelper: () => (registerBackButtonHandlerHelper)
});
// NAMESPACE OBJECT: ./src/public/pages/currentApp.ts
var currentApp_namespaceObject = {};
__webpack_require__.r(currentApp_namespaceObject);
__webpack_require__.d(currentApp_namespaceObject, {
isSupported: () => (currentApp_isSupported),
navigateTo: () => (navigateTo),
navigateToDefaultPage: () => (navigateToDefaultPage)
});
// NAMESPACE OBJECT: ./src/public/pages/fullTrust.ts
var fullTrust_namespaceObject = {};
__webpack_require__.r(fullTrust_namespaceObject);
__webpack_require__.d(fullTrust_namespaceObject, {
enterFullscreen: () => (enterFullscreen),
exitFullscreen: () => (exitFullscreen),
isSupported: () => (fullTrust_isSupported)
});
// NAMESPACE OBJECT: ./src/public/pages/tabs.ts
var tabs_namespaceObject = {};
__webpack_require__.r(tabs_namespaceObject);
__webpack_require__.d(tabs_namespaceObject, {
getMruTabInstances: () => (getMruTabInstances),
getTabInstances: () => (getTabInstances),
isSupported: () => (tabs_isSupported),
navigateToTab: () => (navigateToTab)
});
// NAMESPACE OBJECT: ./src/public/pages/pages.ts
var pages_namespaceObject = {};
__webpack_require__.r(pages_namespaceObject);
__webpack_require__.d(pages_namespaceObject, {
EnterFocusType: () => (EnterFocusType),
ReturnFocusType: () => (ReturnFocusType),
appButton: () => (appButton_namespaceObject),
backStack: () => (backStack_namespaceObject),
config: () => (config_namespaceObject),
currentApp: () => (currentApp_namespaceObject),
fullTrust: () => (fullTrust_namespaceObject),
getConfig: () => (getConfig),
initializeWithFrameContext: () => (initializeWithFrameContext),
isSupported: () => (pages_isSupported),
navigateCrossDomain: () => (navigateCrossDomain),
navigateToApp: () => (navigateToApp),
registerFocusEnterHandler: () => (registerFocusEnterHandler),
registerFullScreenHandler: () => (registerFullScreenHandler),
returnFocus: () => (returnFocus),
setCurrentFrame: () => (setCurrentFrame),
shareDeepLink: () => (shareDeepLink),
tabs: () => (tabs_namespaceObject)
});
// NAMESPACE OBJECT: ./src/private/logs.ts
var logs_namespaceObject = {};
__webpack_require__.r(logs_namespaceObject);
__webpack_require__.d(logs_namespaceObject, {
isSupported: () => (logs_isSupported),
registerGetLogHandler: () => (registerGetLogHandler)
});
// NAMESPACE OBJECT: ./src/private/conversations.ts
var conversations_namespaceObject = {};
__webpack_require__.r(conversations_namespaceObject);
__webpack_require__.d(conversations_namespaceObject, {
closeConversation: () => (closeConversation),
getChatMembers: () => (getChatMembers),
isSupported: () => (conversations_isSupported),
openConversation: () => (openConversation)
});
// NAMESPACE OBJECT: ./src/private/copilot/customTelemetry.ts
var customTelemetry_namespaceObject = {};
__webpack_require__.r(customTelemetry_namespaceObject);
__webpack_require__.d(customTelemetry_namespaceObject, {
isSupported: () => (customTelemetry_isSupported),
sendCustomTelemetryData: () => (sendCustomTelemetryData)
});
// NAMESPACE OBJECT: ./src/private/copilot/eligibility.ts
var eligibility_namespaceObject = {};
__webpack_require__.r(eligibility_namespaceObject);
__webpack_require__.d(eligibility_namespaceObject, {
getEligibilityInfo: () => (getEligibilityInfo),
isSupported: () => (eligibility_isSupported)
});
// NAMESPACE OBJECT: ./src/private/copilot/sidePanelInterfaces.ts
var sidePanelInterfaces_namespaceObject = {};
__webpack_require__.r(sidePanelInterfaces_namespaceObject);
__webpack_require__.d(sidePanelInterfaces_namespaceObject, {
ContentItemType: () => (ContentItemType),
CopilotMode: () => (CopilotMode),
MediaSelectionType: () => (MediaSelectionType),
SidePanelErrorCode: () => (SidePanelErrorCode),
SidePanelErrorImpl: () => (SidePanelErrorImpl),
TeamsContextType: () => (TeamsContextType),
TeamsDimensionName: () => (TeamsDimensionName),
TeamsSessionType: () => (TeamsSessionType),
TranscriptState: () => (TranscriptState),
UserConsent: () => (UserConsent)
});
// NAMESPACE OBJECT: ./src/private/copilot/sidePanel.ts
var sidePanel_namespaceObject = {};
__webpack_require__.r(sidePanel_namespaceObject);
__webpack_require__.d(sidePanel_namespaceObject, {
copilotSidePanelNotSupportedOnPlatformError: () => (copilotSidePanelNotSupportedOnPlatformError),
getContent: () => (getContent),
isResponseAReportableError: () => (isResponseAReportableError),
isSupported: () => (sidePanel_isSupported),
preCheckUserConsent: () => (preCheckUserConsent),
registerUserActionContentSelect: () => (registerUserActionContentSelect)
});
// NAMESPACE OBJECT: ./src/private/copilot/view.ts
var view_namespaceObject = {};
__webpack_require__.r(view_namespaceObject);
__webpack_require__.d(view_namespaceObject, {
closeSidePanel: () => (closeSidePanel),
isSupported: () => (view_isSupported)
});
// NAMESPACE OBJECT: ./src/private/copilot/copilot.ts
var copilot_namespaceObject = {};
__webpack_require__.r(copilot_namespaceObject);
__webpack_require__.d(copilot_namespaceObject, {
customTelemetry: () => (customTelemetry_namespaceObject),
eligibility: () => (eligibility_namespaceObject),
sidePanel: () => (sidePanel_namespaceObject),
view: () => (view_namespaceObject)
});
// NAMESPACE OBJECT: ./src/private/externalAppAuthentication.ts
var externalAppAuthentication_namespaceObject = {};
__webpack_require__.r(externalAppAuthentication_namespaceObject);
__webpack_require__.d(externalAppAuthentication_namespaceObject, {
ActionExecuteInvokeRequestType: () => (ActionExecuteInvokeRequestType),
ActionExecuteResponseHandler: () => (ActionExecuteResponseHandler),
InvokeErrorCode: () => (InvokeErrorCode),
InvokeResponseType: () => (InvokeResponseType),
OriginalRequestType: () => (OriginalRequestType),
SerializableActionExecuteInvokeRequest: () => (SerializableActionExecuteInvokeRequest),
SerializableConnectorParameters: () => (SerializableConnectorParameters),
UserAuthenticationState: () => (UserAuthenticationState),
authenticateAndResendRequest: () => (authenticateAndResendRequest),
authenticateWithConnector: () => (authenticateWithConnector),
authenticateWithOauth2: () => (authenticateWithOauth2),
authenticateWithPowerPlatformConnectorPlugins: () => (authenticateWithPowerPlatformConnectorPlugins),
authenticateWithSSO: () => (authenticateWithSSO),
authenticateWithSSOAndResendRequest: () => (authenticateWithSSOAndResendRequest),
disconnectConnector: () => (disconnectConnector),
getUserAuthenticationStateForConnector: () => (getUserAuthenticationStateForConnector),
isActionExecuteResponse: () => (isActionExecuteResponse),
isInvokeError: () => (isInvokeError),
isSupported: () => (externalAppAuthentication_isSupported),
validateActionExecuteInvokeRequest: () => (validateActionExecuteInvokeRequest)
});
// NAMESPACE OBJECT: ./src/private/externalAppAuthenticationForCEA.ts
var externalAppAuthenticationForCEA_namespaceObject = {};
__webpack_require__.r(externalAppAuthenticationForCEA_namespaceObject);
__webpack_require__.d(externalAppAuthenticationForCEA_namespaceObject, {
authenticateAndResendRequest: () => (externalAppAuthenticationForCEA_authenticateAndResendRequest),
authenticateWithOauth: () => (authenticateWithOauth),
authenticateWithSSO: () => (externalAppAuthenticationForCEA_authenticateWithSSO),
authenticateWithSSOAndResendRequest: () => (externalAppAuthenticationForCEA_authenticateWithSSOAndResendRequest),
isSupported: () => (externalAppAuthenticationForCEA_isSupported),
validateInput: () => (validateInput)
});
// NAMESPACE OBJECT: ./src/private/externalAppCardActions.ts
var externalAppCardActions_namespaceObject = {};
__webpack_require__.r(externalAppCardActions_namespaceObject);
__webpack_require__.d(externalAppCardActions_namespaceObject, {
ActionOpenUrlErrorCode: () => (ActionOpenUrlErrorCode),
ActionOpenUrlType: () => (ActionOpenUrlType),
isSupported: () => (externalAppCardActions_isSupported),
processActionOpenUrl: () => (processActionOpenUrl),
processActionSubmit: () => (processActionSubmit)
});
// NAMESPACE OBJECT: ./src/private/externalAppCardActionsForCEA.ts
var externalAppCardActionsForCEA_namespaceObject = {};
__webpack_require__.r(externalAppCardActionsForCEA_namespaceObject);
__webpack_require__.d(externalAppCardActionsForCEA_namespaceObject, {
isSupported: () => (externalAppCardActionsForCEA_isSupported),
processActionOpenUrl: () => (externalAppCardActionsForCEA_processActionOpenUrl),
processActionSubmit: () => (externalAppCardActionsForCEA_processActionSubmit)
});
// NAMESPACE OBJECT: ./src/private/externalAppCardActionsForDA.ts
var externalAppCardActionsForDA_namespaceObject = {};
__webpack_require__.r(externalAppCardActionsForDA_namespaceObject);
__webpack_require__.d(externalAppCardActionsForDA_namespaceObject, {
SerializableActionOpenUrlDialogInfo: () => (SerializableActionOpenUrlDialogInfo),
isSupported: () => (externalAppCardActionsForDA_isSupported),
processActionOpenUrlDialog: () => (processActionOpenUrlDialog)
});
// NAMESPACE OBJECT: ./src/private/externalAppCommands.ts
var externalAppCommands_namespaceObject = {};
__webpack_require__.r(externalAppCommands_namespaceObject);
__webpack_require__.d(externalAppCommands_namespaceObject, {
isSupported: () => (externalAppCommands_isSupported),
processActionCommand: () => (processActionCommand)
});
// NAMESPACE OBJECT: ./src/private/files.ts
var files_namespaceObject = {};
__webpack_require__.r(files_namespaceObject);
__webpack_require__.d(files_namespaceObject, {
CloudStorageProvider: () => (CloudStorageProvider),
CloudStorageProviderFileAction: () => (CloudStorageProviderFileAction),
CloudStorageProviderType: () => (CloudStorageProviderType),
DocumentLibraryAccessType: () => (DocumentLibraryAccessType),
FileDownloadStatus: () => (FileDownloadStatus),
SpecialDocumentLibraryType: () => (SpecialDocumentLibraryType),
addCloudStorageFolder: () => (addCloudStorageFolder),
addCloudStorageProvider: () => (addCloudStorageProvider),
addCloudStorageProviderFile: () => (addCloudStorageProviderFile),
copyMoveFiles: () => (copyMoveFiles),
deleteCloudStorageFolder: () => (deleteCloudStorageFolder),
deleteCloudStorageProviderFile: () => (deleteCloudStorageProviderFile),
downloadCloudStorageProviderFile: () => (downloadCloudStorageProviderFile),
getCloudStorageFolderContents: () => (getCloudStorageFolderContents),
getCloudStorageFolders: () => (getCloudStorageFolders),
getExternalProviders: () => (getExternalProviders),
getFileDownloads: () => (getFileDownloads),
openCloudStorageFile: () => (openCloudStorageFile),
openDownloadFolder: () => (openDownloadFolder),
registerCloudStorageProviderContentChangeHandler: () => (registerCloudStorageProviderContentChangeHandler),
registerCloudStorageProviderListChangeHandler: () => (registerCloudStorageProviderListChangeHandler),
removeCloudStorageProvider: () => (removeCloudStorageProvider),
renameCloudStorageProviderFile: () => (renameCloudStorageProviderFile),
uploadCloudStoragePr