botframework-webchat 4.13.0 → 4.14.2

package/lib/createFullStyleSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFullStyleSet.d.ts","sourceRoot":"","sources":["../src/createFullStyleSet.ts"],"names":[],"mappings":"AAGA,OAAO,sBAAsB,MAAM,gCAAgC,CAAC;AAMpE,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,OAAO,EAAE,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKzE"}

package/lib/createFullStyleSet.js

@@ -13,7 +13,7 @@ var _botframeworkWebchatComponent = require("botframework-webchat-component");
 
 var _createAdaptiveCardsStyleSet = _interopRequireDefault(require("./adaptiveCards/Styles/createAdaptiveCardsStyleSet"));
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
@@ -23,4 +23,4 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 function createFullStyleSet(options) {
   return _objectSpread(_objectSpread({}, (0, _botframeworkWebchatComponent.createStyleSet)(options)), (0, _createAdaptiveCardsStyleSet.default)(options));
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jcmVhdGVGdWxsU3R5bGVTZXQudHMiXSwibmFtZXMiOlsiY3JlYXRlRnVsbFN0eWxlU2V0Iiwib3B0aW9ucyJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFBQTs7QUFHQTs7Ozs7O0FBRUE7QUFDQTtBQUNBO0FBRWUsU0FBU0Esa0JBQVQsQ0FBNEJDLE9BQTVCLEVBQW1EO0FBQ2hFLHlDQUNLLGtEQUFlQSxPQUFmLENBREwsR0FFSywwQ0FBNEJBLE9BQTVCLENBRkw7QUFJRCIsInNvdXJjZVJvb3QiOiJidW5kbGU6Ly8vIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlU3R5bGVTZXQgfSBmcm9tICdib3RmcmFtZXdvcmstd2ViY2hhdC1jb21wb25lbnQnO1xuaW1wb3J0IHsgU3R5bGVPcHRpb25zIH0gZnJvbSAnYm90ZnJhbWV3b3JrLXdlYmNoYXQtYXBpJztcblxuaW1wb3J0IGNyZWF0ZUFkYXB0aXZlQ2FyZHNTdHlsZVNldCBmcm9tICcuL2FkYXB0aXZlQ2FyZHMvU3R5bGVzL2NyZWF0ZUFkYXB0aXZlQ2FyZHNTdHlsZVNldCc7XG5cbi8vIFRPRE86IFtQNF0gV2Ugc2hvdWxkIGFkZCBhIG5vdGljZSBmb3IgcGVvcGxlIHdobyB3YW50IHRvIHVzZSBcInN0eWxlU2V0XCIgaW5zdGVhZCBvZiBcInN0eWxlT3B0aW9uc1wiLlxuLy8gICAgICAgXCJzdHlsZVNldFwiIGlzIGFjdHVhbGx5IENTUyBzdHlsZXNoZWV0IGFuZCBpdCBpcyBiYXNlZCBvbiB0aGUgRE9NIHRyZWUuXG4vLyAgICAgICBET00gdHJlZSBtYXkgY2hhbmdlIGZyb20gdGltZSB0byB0aW1lLCB0aHVzLCBtYWludGFpbmluZyBcInN0eWxlU2V0XCIgYmVjb21lcyBhIGNvbnN0YW50IGVmZm9ydC5cblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gY3JlYXRlRnVsbFN0eWxlU2V0KG9wdGlvbnM6IFN0eWxlT3B0aW9ucykge1xuICByZXR1cm4ge1xuICAgIC4uLmNyZWF0ZVN0eWxlU2V0KG9wdGlvbnMpLFxuICAgIC4uLmNyZWF0ZUFkYXB0aXZlQ2FyZHNTdHlsZVNldChvcHRpb25zKVxuICB9O1xufVxuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jcmVhdGVGdWxsU3R5bGVTZXQudHMiXSwibmFtZXMiOlsiY3JlYXRlRnVsbFN0eWxlU2V0Iiwib3B0aW9ucyJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFBQTs7QUFFQTs7Ozs7O0FBR0E7QUFDQTtBQUNBO0FBRWUsU0FBU0Esa0JBQVQsQ0FBNEJDLE9BQTVCLEVBQTZEO0FBQzFFLHlDQUNLLGtEQUFlQSxPQUFmLENBREwsR0FFSywwQ0FBNEJBLE9BQTVCLENBRkw7QUFJRCIsInNvdXJjZVJvb3QiOiJidW5kbGU6Ly8vIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlU3R5bGVTZXQgfSBmcm9tICdib3RmcmFtZXdvcmstd2ViY2hhdC1jb21wb25lbnQnO1xuXG5pbXBvcnQgY3JlYXRlQWRhcHRpdmVDYXJkc1N0eWxlU2V0IGZyb20gJy4vYWRhcHRpdmVDYXJkcy9TdHlsZXMvY3JlYXRlQWRhcHRpdmVDYXJkc1N0eWxlU2V0JztcbmltcG9ydCBGdWxsQnVuZGxlU3R5bGVPcHRpb25zIGZyb20gJy4vdHlwZXMvRnVsbEJ1bmRsZVN0eWxlT3B0aW9ucyc7XG5cbi8vIFRPRE86IFtQNF0gV2Ugc2hvdWxkIGFkZCBhIG5vdGljZSBmb3IgcGVvcGxlIHdobyB3YW50IHRvIHVzZSBcInN0eWxlU2V0XCIgaW5zdGVhZCBvZiBcInN0eWxlT3B0aW9uc1wiLlxuLy8gICAgICAgXCJzdHlsZVNldFwiIGlzIGFjdHVhbGx5IENTUyBzdHlsZXNoZWV0IGFuZCBpdCBpcyBiYXNlZCBvbiB0aGUgRE9NIHRyZWUuXG4vLyAgICAgICBET00gdHJlZSBtYXkgY2hhbmdlIGZyb20gdGltZSB0byB0aW1lLCB0aHVzLCBtYWludGFpbmluZyBcInN0eWxlU2V0XCIgYmVjb21lcyBhIGNvbnN0YW50IGVmZm9ydC5cblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gY3JlYXRlRnVsbFN0eWxlU2V0KG9wdGlvbnM6IEZ1bGxCdW5kbGVTdHlsZU9wdGlvbnMpIHtcbiAgcmV0dXJuIHtcbiAgICAuLi5jcmVhdGVTdHlsZVNldChvcHRpb25zKSxcbiAgICAuLi5jcmVhdGVBZGFwdGl2ZUNhcmRzU3R5bGVTZXQob3B0aW9ucylcbiAgfTtcbn1cbiJdfQ==

package/lib/fullBundleDefaultStyleOptions.js

@@ -13,12 +13,12 @@ var _botframeworkWebchatApi = require("botframework-webchat-api");
 
 var _defaultStyleOptions = _interopRequireDefault(require("./adaptiveCards/defaultStyleOptions"));
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-var FULL_BUNDLE_DEFAULT_STYLE_OPTIONS = _objectSpread(_objectSpread({}, _botframeworkWebchatApi.defaultStyleOptions), _defaultStyleOptions.default);
+var fullBundleDefaultStyleOptions = _objectSpread(_objectSpread({}, _botframeworkWebchatApi.defaultStyleOptions), _defaultStyleOptions.default);
 
-var _default = FULL_BUNDLE_DEFAULT_STYLE_OPTIONS;
+var _default = fullBundleDefaultStyleOptions;
 exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9mdWxsQnVuZGxlRGVmYXVsdFN0eWxlT3B0aW9ucy50cyJdLCJuYW1lcyI6WyJGVUxMX0JVTkRMRV9ERUZBVUxUX1NUWUxFX09QVElPTlMiLCJkZWZhdWx0U3R5bGVPcHRpb25zIiwiYWRhcHRpdmVDYXJkc0RlZmF1bHRTdHlsZU9wdGlvbnMiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0FBQUE7O0FBQ0E7Ozs7OztBQUlBLElBQU1BLGlDQUFtRSxtQ0FDcEVDLDJDQURvRSxHQUVwRUMsNEJBRm9FLENBQXpFOztlQUtlRixpQyIsInNvdXJjZVJvb3QiOiJidW5kbGU6Ly8vIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZGVmYXVsdFN0eWxlT3B0aW9ucyB9IGZyb20gJ2JvdGZyYW1ld29yay13ZWJjaGF0LWFwaSc7XG5pbXBvcnQgYWRhcHRpdmVDYXJkc0RlZmF1bHRTdHlsZU9wdGlvbnMgZnJvbSAnLi9hZGFwdGl2ZUNhcmRzL2RlZmF1bHRTdHlsZU9wdGlvbnMnO1xuXG5pbXBvcnQgRnVsbEJ1bmRsZVN0eWxlT3B0aW9ucyBmcm9tICcuL0Z1bGxCdW5kbGVTdHlsZU9wdGlvbnMnO1xuXG5jb25zdCBGVUxMX0JVTkRMRV9ERUZBVUxUX1NUWUxFX09QVElPTlM6IFJlcXVpcmVkPEZ1bGxCdW5kbGVTdHlsZU9wdGlvbnM+ID0ge1xuICAuLi5kZWZhdWx0U3R5bGVPcHRpb25zLFxuICAuLi5hZGFwdGl2ZUNhcmRzRGVmYXVsdFN0eWxlT3B0aW9uc1xufTtcblxuZXhwb3J0IGRlZmF1bHQgRlVMTF9CVU5ETEVfREVGQVVMVF9TVFlMRV9PUFRJT05TO1xuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9mdWxsQnVuZGxlRGVmYXVsdFN0eWxlT3B0aW9ucy50cyJdLCJuYW1lcyI6WyJmdWxsQnVuZGxlRGVmYXVsdFN0eWxlT3B0aW9ucyIsImRlZmF1bHRTdHlsZU9wdGlvbnMiLCJhZGFwdGl2ZUNhcmRzRGVmYXVsdFN0eWxlT3B0aW9ucyJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFBQTs7QUFDQTs7Ozs7O0FBSUEsSUFBTUEsNkJBQStELG1DQUNoRUMsMkNBRGdFLEdBRWhFQyw0QkFGZ0UsQ0FBckU7O2VBS2VGLDZCIiwic291cmNlUm9vdCI6ImJ1bmRsZTovLy8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBkZWZhdWx0U3R5bGVPcHRpb25zIH0gZnJvbSAnYm90ZnJhbWV3b3JrLXdlYmNoYXQtYXBpJztcbmltcG9ydCBhZGFwdGl2ZUNhcmRzRGVmYXVsdFN0eWxlT3B0aW9ucyBmcm9tICcuL2FkYXB0aXZlQ2FyZHMvZGVmYXVsdFN0eWxlT3B0aW9ucyc7XG5cbmltcG9ydCBGdWxsQnVuZGxlU3R5bGVPcHRpb25zIGZyb20gJy4vdHlwZXMvRnVsbEJ1bmRsZVN0eWxlT3B0aW9ucyc7XG5cbmNvbnN0IGZ1bGxCdW5kbGVEZWZhdWx0U3R5bGVPcHRpb25zOiBSZXF1aXJlZDxGdWxsQnVuZGxlU3R5bGVPcHRpb25zPiA9IHtcbiAgLi4uZGVmYXVsdFN0eWxlT3B0aW9ucyxcbiAgLi4uYWRhcHRpdmVDYXJkc0RlZmF1bHRTdHlsZU9wdGlvbnNcbn07XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bGxCdW5kbGVEZWZhdWx0U3R5bGVPcHRpb25zO1xuIl19

package/lib/hooks/useStyleOptions.d.ts

@@ -0,0 +1,3 @@
+import { StrictFullBundleStyleOptions } from '../types/FullBundleStyleOptions';
+export default function useStyleOptions(): [StrictFullBundleStyleOptions];
+//# sourceMappingURL=useStyleOptions.d.ts.map

package/lib/hooks/useStyleOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStyleOptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useStyleOptions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,4BAA4B,EAAE,MAAM,iCAAiC,CAAC;AAE/E,MAAM,CAAC,OAAO,UAAU,eAAe,IAAI,CAAC,4BAA4B,CAAC,CAIxE"}

package/lib/hooks/useStyleOptions.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useStyleOptions;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _botframeworkWebchatComponent = require("botframework-webchat-component");
+
+function useStyleOptions() {
+  var _hooks$useStyleOption = _botframeworkWebchatComponent.hooks.useStyleOptions(),
+      _hooks$useStyleOption2 = (0, _slicedToArray2.default)(_hooks$useStyleOption, 1),
+      styleOptions = _hooks$useStyleOption2[0];
+
+  return [styleOptions];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ob29rcy91c2VTdHlsZU9wdGlvbnMudHMiXSwibmFtZXMiOlsidXNlU3R5bGVPcHRpb25zIiwiaG9va3MiLCJzdHlsZU9wdGlvbnMiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0FBQUE7O0FBSWUsU0FBU0EsZUFBVCxHQUEyRDtBQUN4RSw4QkFBdUJDLG9DQUFNRCxlQUFOLEVBQXZCO0FBQUE7QUFBQSxNQUFPRSxZQUFQOztBQUVBLFNBQU8sQ0FBQ0EsWUFBRCxDQUFQO0FBQ0QiLCJzb3VyY2VSb290IjoiYnVuZGxlOi8vLyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGhvb2tzIH0gZnJvbSAnYm90ZnJhbWV3b3JrLXdlYmNoYXQtY29tcG9uZW50JztcblxuaW1wb3J0IHsgU3RyaWN0RnVsbEJ1bmRsZVN0eWxlT3B0aW9ucyB9IGZyb20gJy4uL3R5cGVzL0Z1bGxCdW5kbGVTdHlsZU9wdGlvbnMnO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiB1c2VTdHlsZU9wdGlvbnMoKTogW1N0cmljdEZ1bGxCdW5kbGVTdHlsZU9wdGlvbnNdIHtcbiAgY29uc3QgW3N0eWxlT3B0aW9uc10gPSBob29rcy51c2VTdHlsZU9wdGlvbnMoKTtcblxuICByZXR1cm4gW3N0eWxlT3B0aW9ucyBhcyBTdHJpY3RGdWxsQnVuZGxlU3R5bGVPcHRpb25zXTtcbn1cbiJdfQ==

package/lib/index-es5.d.ts

@@ -1,21 +1,25 @@
-import { FC } from 'react';
-import { Components as ComponentsFromComponent, ComposerProps, ReactWebChatProps } from 'botframework-webchat-component';
-import StyleOptions from './FullBundleStyleOptions';
-declare type Replace<T1, T2> = Omit<T1, keyof T2> & T2;
-/** Creates a set of styles with support of Adaptive Cards */
-declare function createStyleSet(styleOptions: StyleOptions): any;
-declare const Components: Omit<typeof ComponentsFromComponent, 'Composer'> & {
-    Composer: FC<Replace<ComposerProps, {
-        /** Style options with support of Adaptive Cards */
-        styleOptions?: StyleOptions;
-    }>>;
-};
-/** React-based Web Chat with support of Adaptive Cards */
-declare const ReactWebChat: FC<Replace<ReactWebChatProps, {
-    /** Style options with support of Adaptive Cards */
-    styleOptions?: StyleOptions;
-}>>;
-export default ReactWebChat;
-export { Components, createStyleSet };
-export type { StyleOptions };
+import 'core-js/features/array/find-index';
+import 'core-js/features/array/find';
+import 'core-js/features/array/from';
+import 'core-js/features/array/includes';
+import 'core-js/features/array/iterator';
+import 'core-js/features/dom-collections';
+import 'core-js/features/math/sign';
+import 'core-js/features/number/is-finite';
+import 'core-js/features/object/assign';
+import 'core-js/features/object/entries';
+import 'core-js/features/object/from-entries';
+import 'core-js/features/object/is';
+import 'core-js/features/object/values';
+import 'core-js/features/promise';
+import 'core-js/features/promise/finally';
+import 'core-js/features/set';
+import 'core-js/features/string/ends-with';
+import 'core-js/features/string/starts-with';
+import 'core-js/features/symbol';
+import 'url-search-params-polyfill';
+import 'whatwg-fetch';
+export * from './index';
+export declare const createDirectLine: (options: any) => import("botframework-directlinejs").DirectLine;
+export declare const createDirectLineAppServiceExtension: (options: any) => Promise<any>;
 //# sourceMappingURL=index-es5.d.ts.map

package/lib/index-es5.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index-es5.d.ts","sourceRoot":"","sources":["../src/index-es5.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AAC3B,OAAO,EACL,UAAU,IAAI,uBAAuB,EACrC,aAAa,EACb,iBAAiB,EAClB,MAAM,gCAAgC,CAAC;AAExC,OAAO,YAAY,MAAM,0BAA0B,CAAC;AAEpD,aAAK,OAAO,CAAC,EAAE,EAAE,EAAE,IAAI,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC;AAE/C,6DAA6D;AAC7D,OAAO,UAAU,cAAc,CAAC,YAAY,EAAE,YAAY,GAAG,GAAG,CAAC;AAEjE,OAAO,CAAC,MAAM,UAAU,EAAE,IAAI,CAAC,OAAO,uBAAuB,EAAE,UAAU,CAAC,GAAG;IAC3E,QAAQ,EAAE,EAAE,CACV,OAAO,CACL,aAAa,EACb;QACE,mDAAmD;QACnD,YAAY,CAAC,EAAE,YAAY,CAAC;KAC7B,CACF,CACF,CAAC;CACH,CAAC;AAEF,0DAA0D;AAC1D,OAAO,CAAC,MAAM,YAAY,EAAE,EAAE,CAC5B,OAAO,CACL,iBAAiB,EACjB;IACE,mDAAmD;IACnD,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CACF,CACF,CAAC;AAEF,eAAe,YAAY,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;AACtC,YAAY,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"index-es5.d.ts","sourceRoot":"","sources":["../src/index-es5.ts"],"names":[],"mappings":"AAOA,OAAO,mCAAmC,CAAC;AAC3C,OAAO,6BAA6B,CAAC;AACrC,OAAO,6BAA6B,CAAC;AACrC,OAAO,iCAAiC,CAAC;AACzC,OAAO,iCAAiC,CAAC;AACzC,OAAO,kCAAkC,CAAC;AAC1C,OAAO,4BAA4B,CAAC;AACpC,OAAO,mCAAmC,CAAC;AAC3C,OAAO,gCAAgC,CAAC;AACxC,OAAO,iCAAiC,CAAC;AACzC,OAAO,sCAAsC,CAAC;AAC9C,OAAO,4BAA4B,CAAC;AACpC,OAAO,gCAAgC,CAAC;AACxC,OAAO,0BAA0B,CAAC;AAClC,OAAO,kCAAkC,CAAC;AAC1C,OAAO,sBAAsB,CAAC;AAC9B,OAAO,mCAAmC,CAAC;AAC3C,OAAO,qCAAqC,CAAC;AAC7C,OAAO,yBAAyB,CAAC;AAEjC,OAAO,4BAA4B,CAAC;AACpC,OAAO,cAAc,CAAC;AAMtB,cAAc,SAAS,CAAC;AAExB,eAAO,MAAM,gBAAgB,kEAO5B,CAAC;AAEF,eAAO,MAAM,mCAAmC,gCAO/C,CAAC"}

package/lib/index-es5.js

@@ -77,7 +77,7 @@ Object.keys(_index).forEach(function (key) {
   });
 });
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
@@ -103,4 +103,4 @@ window['WebChat'] = _objectSpread(_objectSpread({}, window['WebChat']), {}, {
   createDirectLineAppServiceExtension: createDirectLineAppServiceExtension
 });
 (0, _addVersion.default)('full-es5');
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/index-minimal.d.ts

@@ -1,8 +1,11 @@
-import { StyleOptions } from 'botframework-webchat-api';
-import ReactWebChat, { Components } from 'botframework-webchat-component';
-/** Creates a set of styles */
-declare function createStyleSet(styleOptions: StyleOptions): any;
+import { Constants, createStore, createStoreWithDevTools, version } from 'botframework-webchat-core';
+import { StrictStyleOptions, StyleOptions } from 'botframework-webchat-api';
+import ReactWebChat, { Components, concatMiddleware, connectToWebChat, createStyleSet, hooks } from 'botframework-webchat-component';
+import createBrowserWebSpeechPonyfillFactory from './createBrowserWebSpeechPonyfillFactory';
+declare const renderWebChat: any;
+export declare const createDirectLine: (options: any) => import("botframework-directlinejs").DirectLine;
+export declare const createDirectLineAppServiceExtension: (options: any) => Promise<any>;
 export default ReactWebChat;
-export { Components, createStyleSet };
-export type { StyleOptions };
+export { Components, concatMiddleware, connectToWebChat, Constants, createBrowserWebSpeechPonyfillFactory, createStore, createStoreWithDevTools, createStyleSet, hooks, renderWebChat, version };
+export type { StyleOptions, StrictStyleOptions };
 //# sourceMappingURL=index-minimal.d.ts.map

package/lib/index-minimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index-minimal.d.ts","sourceRoot":"","sources":["../src/index-minimal.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,YAAY,EAAE,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAE1E,8BAA8B;AAC9B,OAAO,UAAU,cAAc,CAAC,YAAY,EAAE,YAAY,GAAG,GAAG,CAAC;AAEjE,eAAe,YAAY,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;AACtC,YAAY,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"index-minimal.d.ts","sourceRoot":"","sources":["../src/index-minimal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACrG,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE5E,OAAO,YAAY,EAAE,EACnB,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,KAAK,EACN,MAAM,gCAAgC,CAAC;AAIxC,OAAO,qCAAqC,MAAM,yCAAyC,CAAC;AAI5F,QAAA,MAAM,aAAa,KAA6C,CAAC;AAEjE,eAAO,MAAM,gBAAgB,kEAO5B,CAAC;AAEF,eAAO,MAAM,mCAAmC,gCAO/C,CAAC;AAEF,eAAe,YAAY,CAAC;AAE5B,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,qCAAqC,EACrC,WAAW,EACX,uBAAuB,EACvB,cAAc,EACd,KAAK,EACL,aAAa,EACb,OAAO,EACR,CAAC;AAEF,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/lib/index-minimal.js

@@ -1,9 +1,9 @@
 "use strict";
 
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
-
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
+var _typeof = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -85,7 +85,11 @@ var _createDirectLine = _interopRequireDefault(require("./createDirectLine"));
 
 var _createDirectLineAppServiceExtension = _interopRequireDefault(require("./createDirectLineAppServiceExtension"));
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
@@ -127,4 +131,4 @@ window['WebChat'] = _objectSpread(_objectSpread({}, window['WebChat']), {}, {
   renderWebChat: renderWebChat
 });
 (0, _addVersion.default)('minimal');
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/index.d.ts

@@ -1,21 +1,157 @@
-import { FC } from 'react';
-import { ComposerProps, ReactWebChatProps } from 'botframework-webchat-component';
-import StyleOptions from './FullBundleStyleOptions';
-declare type Replace<T1, T2> = Omit<T1, keyof T2> & T2;
-/** Creates a set of styles with support of Adaptive Cards */
-declare function createStyleSet(styleOptions: StyleOptions): any;
-declare const Components: {
-    Composer: FC<Replace<ComposerProps, {
-        /** Style options with support of Adaptive Cards */
-        styleOptions?: StyleOptions;
-    }>>;
+export * from './index-minimal';
+import { Components as MinimalComponents } from './index-minimal';
+import createAdaptiveCardsAttachmentMiddleware from './adaptiveCards/createAdaptiveCardsAttachmentMiddleware';
+import createAdaptiveCardsAttachmentForScreenReaderMiddleware from './adaptiveCards/createAdaptiveCardsAttachmentForScreenReaderMiddleware';
+import createCognitiveServicesSpeechServicesPonyfillFactory from './createCognitiveServicesSpeechServicesPonyfillFactory';
+import createDirectLineSpeechAdapters from './createDirectLineSpeechAdapters';
+import createStyleSet from './createFullStyleSet';
+import defaultCreateDirectLine from './createDirectLine';
+import defaultCreateDirectLineAppServiceExtension from './createDirectLineAppServiceExtension';
+import FullBundleStyleOptions, { StrictFullBundleStyleOptions } from './types/FullBundleStyleOptions';
+import ReactWebChat from './FullReactWebChat';
+import renderMarkdown from './renderMarkdown';
+import useAdaptiveCardsHostConfig from './adaptiveCards/hooks/useAdaptiveCardsHostConfig';
+import useAdaptiveCardsPackage from './adaptiveCards/hooks/useAdaptiveCardsPackage';
+import useStyleOptions from './hooks/useStyleOptions';
+declare const renderWebChat: any;
+export declare const createDirectLine: (options: Omit<Parameters<typeof defaultCreateDirectLine>[0], 'botAgent'>) => import("botframework-directlinejs").DirectLine;
+export declare const createDirectLineAppServiceExtension: (options: Omit<Parameters<typeof defaultCreateDirectLineAppServiceExtension>[0], 'botAgent'>) => Promise<any>;
+declare const patchedHooks: {
+    useAdaptiveCardsHostConfig: typeof useAdaptiveCardsHostConfig;
+    useAdaptiveCardsPackage: typeof useAdaptiveCardsPackage;
+    useStyleOptions: typeof useStyleOptions;
+    useDictateAbortable: typeof import("botframework-webchat-component/lib/hooks").useDictateAbortable;
+    useFocus: typeof import("botframework-webchat-component/lib/hooks").useFocus;
+    useFocusSendBox: typeof import("botframework-webchat-component/lib/hooks").useFocusSendBox;
+    useMicrophoneButtonClick: typeof import("botframework-webchat-component/lib/SendBox/MicrophoneButton").useMicrophoneButtonClick;
+    useMicrophoneButtonDisabled: typeof import("botframework-webchat-component/lib/SendBox/MicrophoneButton").useMicrophoneButtonDisabled;
+    useObserveScrollPosition: typeof import("botframework-webchat-component/lib/hooks").useObserveScrollPosition;
+    useObserveTranscriptFocus: typeof import("botframework-webchat-component/lib/hooks").useObserveTranscriptFocus;
+    useRenderMarkdownAsHTML: typeof import("botframework-webchat-component/lib/hooks").useRenderMarkdownAsHTML;
+    useScrollDown: typeof import("botframework-webchat-component/lib/hooks").useScrollDown;
+    useScrollTo: typeof import("botframework-webchat-component/lib/hooks").useScrollTo;
+    useScrollToEnd: typeof import("botframework-webchat-component/lib/hooks").useScrollToEnd;
+    useScrollUp: typeof import("botframework-webchat-component/lib/hooks").useScrollUp;
+    useSendBoxSpeechInterimsVisible: typeof import("botframework-webchat-component/lib/BasicSendBox").useSendBoxSpeechInterimsVisible;
+    useSendFiles: typeof import("botframework-webchat-component/lib/hooks").useSendFiles;
+    useStyleSet: typeof import("botframework-webchat-component/lib/hooks").useStyleSet;
+    useTextBoxSubmit: typeof import("botframework-webchat-component/lib/SendBox/TextBox").useTextBoxSubmit;
+    useTextBoxValue: typeof import("botframework-webchat-component/lib/SendBox/TextBox").useTextBoxValue;
+    useTypingIndicatorVisible: typeof import("botframework-webchat-component/lib/BasicTypingIndicator").useTypingIndicatorVisible;
+    useWebSpeechPonyfill: typeof import("botframework-webchat-component/lib/hooks").useWebSpeechPonyfill;
+    useActiveTyping: typeof import("botframework-webchat-api/lib/hooks/useActiveTyping").default;
+    useActivities: typeof import("botframework-webchat-api/lib/hooks").useActivities;
+    useAvatarForBot: typeof import("botframework-webchat-api/lib/hooks").useAvatarForBot;
+    useAvatarForUser: typeof import("botframework-webchat-api/lib/hooks").useAvatarForUser;
+    useByteFormatter: typeof import("botframework-webchat-api/lib/hooks").useByteFormatter;
+    useConnectivityStatus: typeof import("botframework-webchat-api/lib/hooks").useConnectivityStatus;
+    useCreateActivityRenderer: typeof import("botframework-webchat-api/lib/hooks").useCreateActivityRenderer;
+    useCreateActivityStatusRenderer: typeof import("botframework-webchat-api/lib/hooks").useCreateActivityStatusRenderer;
+    useCreateAttachmentForScreenReaderRenderer: any;
+    useCreateAvatarRenderer: typeof import("botframework-webchat-api/lib/hooks").useCreateAvatarRenderer;
+    useCreateScrollToEndButtonRenderer: typeof import("botframework-webchat-api/lib/hooks").useCreateScrollToEndButtonRenderer;
+    useDateFormatter: typeof import("botframework-webchat-api/lib/hooks").useDateFormatter;
+    useDebouncedNotifications: typeof import("botframework-webchat-api/lib/hooks/useDebouncedNotifications").default;
+    useDictateInterims: typeof import("botframework-webchat-api/lib/hooks").useDictateInterims;
+    useDictateState: typeof import("botframework-webchat-api/lib/hooks").useDictateState;
+    useDirection: typeof import("botframework-webchat-api/lib/hooks").useDirection;
+    useDisabled: typeof import("botframework-webchat-api/lib/hooks").useDisabled;
+    useDismissNotification: typeof import("botframework-webchat-api/lib/hooks").useDismissNotification;
+    useEmitTypingIndicator: typeof import("botframework-webchat-api/lib/hooks").useEmitTypingIndicator;
+    useGetSendTimeoutForActivity: typeof import("botframework-webchat-api/lib/hooks").useGetSendTimeoutForActivity;
+    useGrammars: typeof import("botframework-webchat-api/lib/hooks").useGrammars;
+    useGroupActivities: typeof import("botframework-webchat-api/lib/hooks").useGroupActivities;
+    useGroupTimestamp: typeof import("botframework-webchat-api/lib/hooks").useGroupTimestamp;
+    useLanguage: typeof import("botframework-webchat-api/lib/hooks").useLanguage;
+    useLastTypingAt: typeof import("botframework-webchat-api/lib/hooks").useLastTypingAt;
+    useLocalize: typeof import("botframework-webchat-api/lib/hooks").useLocalize;
+    useLocalizeDate: typeof import("botframework-webchat-api/lib/hooks").useLocalizeDate;
+    useLocalizer: typeof import("botframework-webchat-api/lib/hooks").useLocalizer;
+    useMarkActivityAsSpoken: typeof import("botframework-webchat-api/lib/hooks").useMarkActivityAsSpoken;
+    usePerformCardAction: typeof import("botframework-webchat-api/lib/hooks").usePerformCardAction;
+    usePostActivity: typeof import("botframework-webchat-api/lib/hooks").usePostActivity;
+    useReferenceGrammarID: typeof import("botframework-webchat-api/lib/hooks").useReferenceGrammarID;
+    useRelativeTimeFormatter: typeof import("botframework-webchat-api/lib/hooks").useRelativeTimeFormatter;
+    useRenderActivity: any;
+    useRenderActivityStatus: any;
+    useRenderAttachment: any;
+    useRenderAvatar: any;
+    useRenderToast: typeof import("botframework-webchat-api/lib/hooks").useRenderToast;
+    useRenderTypingIndicator: typeof import("botframework-webchat-api/lib/hooks").useRenderTypingIndicator;
+    useSendBoxValue: typeof import("botframework-webchat-api/lib/hooks").useSendBoxValue;
+    useSendEvent: typeof import("botframework-webchat-api/lib/hooks").useSendEvent;
+    useSendMessage: typeof import("botframework-webchat-api/lib/hooks").useSendMessage;
+    useSendMessageBack: typeof import("botframework-webchat-api/lib/hooks").useSendMessageBack;
+    useSendPostBack: typeof import("botframework-webchat-api/lib/hooks").useSendPostBack;
+    useSendTimeoutForActivity: typeof import("botframework-webchat-api/lib/hooks").useSendTimeoutForActivity;
+    useSendTypingIndicator: typeof import("botframework-webchat-api/lib/hooks").useSendTypingIndicator;
+    useSetNotification: typeof import("botframework-webchat-api/lib/hooks").useSetNotification;
+    useShouldSpeakIncomingActivity: typeof import("botframework-webchat-api/lib/hooks").useShouldSpeakIncomingActivity;
+    useStartDictate: typeof import("botframework-webchat-api/lib/hooks").useStartDictate;
+    useStopDictate: typeof import("botframework-webchat-api/lib/hooks").useStopDictate;
+    useSubmitSendBox: typeof import("botframework-webchat-api/lib/hooks").useSubmitSendBox;
+    useSuggestedActions: typeof import("botframework-webchat-api/lib/hooks").useSuggestedActions;
+    useTimeoutForSend: typeof import("botframework-webchat-api/lib/hooks").useTimeoutForSend;
+    useTrackDimension: typeof import("botframework-webchat-api/lib/hooks").useTrackDimension;
+    useTrackEvent: typeof import("botframework-webchat-api/lib/hooks").useTrackEvent;
+    useTrackException: typeof import("botframework-webchat-api/lib/hooks").useTrackException;
+    useTrackTiming: typeof import("botframework-webchat-api/lib/hooks").useTrackTiming;
+    useUserID: typeof import("botframework-webchat-api/lib/hooks").useUserID;
+    useUsername: typeof import("botframework-webchat-api/lib/hooks").useUsername;
+    useVoiceSelector: typeof import("botframework-webchat-api/lib/hooks").useVoiceSelector;
 };
-/** React-based Web Chat with support of Adaptive Cards */
-declare const ReactWebChat: FC<Replace<ReactWebChatProps, {
-    /** Style options with support of Adaptive Cards */
-    styleOptions?: StyleOptions;
-}>>;
+declare const AdditionalComponents: {
+    AdaptiveCardContent: import("react").FC<{
+        actionPerformedClassName?: string;
+        content: any;
+        disabled?: boolean;
+    }>;
+    AnimationCardContent: import("react").FC<{
+        actionPerformedClassName?: string;
+        content: any;
+        disabled?: boolean;
+    }>;
+    AudioCardContent: import("react").FC<{
+        actionPerformedClassName?: string;
+        content: any;
+        disabled?: boolean;
+    }>;
+    Composer: import("react").FC<import("./FullComposer").FullComposerProps>;
+    HeroCardContent: import("react").FC<{
+        actionPerformedClassName?: string;
+        content: any;
+        disabled?: boolean;
+    }>;
+    OAuthCardContent: import("react").FC<{
+        actionPerformedClassName?: string;
+        content: any;
+        disabled?: boolean;
+    }>;
+    ReceiptCardContent: import("react").FC<{
+        actionPerformedClassName?: string;
+        content: any;
+        disabled?: boolean;
+    }>;
+    SignInCardContent: import("react").FC<{
+        actionPerformedClassName?: string;
+        content: any;
+        disabled?: boolean;
+    }>;
+    ThumbnailCardContent: import("react").FC<{
+        actionPerformedClassName?: string;
+        content: any;
+        disabled?: boolean;
+    }>;
+    VideoCardContent: import("react").FC<{
+        actionPerformedClassName?: string;
+        content: any;
+        disabled?: boolean;
+    }>;
+};
+declare const Components: typeof MinimalComponents & typeof AdditionalComponents;
+declare type StyleOptions = FullBundleStyleOptions;
+declare type StrictStyleOptions = StrictFullBundleStyleOptions;
 export default ReactWebChat;
-export { Components, createStyleSet };
-export type { StyleOptions };
+export { Components, createAdaptiveCardsAttachmentMiddleware, createAdaptiveCardsAttachmentForScreenReaderMiddleware, createCognitiveServicesSpeechServicesPonyfillFactory, createDirectLineSpeechAdapters, createStyleSet, patchedHooks as hooks, renderMarkdown, renderWebChat };
+export type { StyleOptions, StrictStyleOptions };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AAC3B,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAElF,OAAO,YAAY,MAAM,0BAA0B,CAAC;AAEpD,aAAK,OAAO,CAAC,EAAE,EAAE,EAAE,IAAI,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC;AAE/C,6DAA6D;AAC7D,OAAO,UAAU,cAAc,CAAC,YAAY,EAAE,YAAY,GAAG,GAAG,CAAC;AAEjE,OAAO,CAAC,MAAM,UAAU,EAAE;IACxB,QAAQ,EAAE,EAAE,CACV,OAAO,CACL,aAAa,EACb;QACE,mDAAmD;QACnD,YAAY,CAAC,EAAE,YAAY,CAAC;KAC7B,CACF,CACF,CAAC;CACH,CAAC;AAEF,0DAA0D;AAC1D,OAAO,CAAC,MAAM,YAAY,EAAE,EAAE,CAC5B,OAAO,CACL,iBAAiB,EACjB;IACE,mDAAmD;IACnD,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CACF,CACF,CAAC;AAEF,eAAe,YAAY,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;AACtC,YAAY,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAAE,UAAU,IAAI,iBAAiB,EAAkB,MAAM,iBAAiB,CAAC;AAMlF,OAAO,uCAAuC,MAAM,yDAAyD,CAAC;AAC9G,OAAO,sDAAsD,MAAM,wEAAwE,CAAC;AAC5I,OAAO,oDAAoD,MAAM,wDAAwD,CAAC;AAC1H,OAAO,8BAA8B,MAAM,kCAAkC,CAAC;AAC9E,OAAO,cAAc,MAAM,sBAAsB,CAAC;AAClD,OAAO,uBAAuB,MAAM,oBAAoB,CAAC;AACzD,OAAO,0CAA0C,MAAM,uCAAuC,CAAC;AAC/F,OAAO,sBAAsB,EAAE,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAItG,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAE9C,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAG9C,OAAO,0BAA0B,MAAM,kDAAkD,CAAC;AAC1F,OAAO,uBAAuB,MAAM,+CAA+C,CAAC;AACpF,OAAO,eAAe,MAAM,yBAAyB,CAAC;AAGtD,QAAA,MAAM,aAAa,KAA6C,CAAC;AAEjE,eAAO,MAAM,gBAAgB,YAAa,KAAK,WAAW,8BAA8B,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,mDAOxG,CAAC;AAEF,eAAO,MAAM,mCAAmC,YACrC,KAAK,WAAW,iDAAiD,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,iBAQ5F,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKjB,CAAC;AAEF,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWzB,CAAC;AAEF,QAAA,MAAM,UAAU,EAAE,OAAO,iBAAiB,GAAG,OAAO,oBAGnD,CAAC;AAEF,aAAK,YAAY,GAAG,sBAAsB,CAAC;AAC3C,aAAK,kBAAkB,GAAG,4BAA4B,CAAC;AAEvD,eAAe,YAAY,CAAC;AAE5B,OAAO,EACL,UAAU,EACV,uCAAuC,EACvC,sDAAsD,EACtD,oDAAoD,EACpD,8BAA8B,EAC9B,cAAc,EACd,YAAY,IAAI,KAAK,EACrB,cAAc,EACd,aAAa,EACd,CAAC;AAEF,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/lib/index.js

@@ -116,9 +116,11 @@ var _useAdaptiveCardsHostConfig = _interopRequireDefault(require("./adaptiveCard
 
 var _useAdaptiveCardsPackage = _interopRequireDefault(require("./adaptiveCards/hooks/useAdaptiveCardsPackage"));
 
+var _useStyleOptions = _interopRequireDefault(require("./hooks/useStyleOptions"));
+
 var _VideoCardContent = _interopRequireDefault(require("./adaptiveCards/Attachment/VideoCardContent"));
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
@@ -146,15 +148,15 @@ exports.createDirectLineAppServiceExtension = createDirectLineAppServiceExtensio
 
 var patchedHooks = _objectSpread(_objectSpread({}, _indexMinimal.hooks), {}, {
   useAdaptiveCardsHostConfig: _useAdaptiveCardsHostConfig.default,
-  useAdaptiveCardsPackage: _useAdaptiveCardsPackage.default
+  useAdaptiveCardsPackage: _useAdaptiveCardsPackage.default,
+  useStyleOptions: _useStyleOptions.default
 });
 
 exports.hooks = patchedHooks;
-
-var Components = _objectSpread(_objectSpread({}, _indexMinimal.Components), {}, {
+var AdditionalComponents = {
   AdaptiveCardContent: _AdaptiveCardContent.default,
-  AudioCardContent: _AudioCardContent.default,
   AnimationCardContent: _AnimationCardContent.default,
+  AudioCardContent: _AudioCardContent.default,
   Composer: _FullComposer.default,
   HeroCardContent: _HeroCardContent.default,
   OAuthCardContent: _OAuthCardContent.default,
@@ -162,7 +164,9 @@ var Components = _objectSpread(_objectSpread({}, _indexMinimal.Components), {},
   SignInCardContent: _SignInCardContent.default,
   ThumbnailCardContent: _ThumbnailCardContent.default,
   VideoCardContent: _VideoCardContent.default
-});
+};
+
+var Components = _objectSpread(_objectSpread({}, _indexMinimal.Components), AdditionalComponents);
 
 exports.Components = Components;
 var _default = _FullReactWebChat.default;
@@ -182,4 +186,4 @@ window['WebChat'] = _objectSpread(_objectSpread({}, window['WebChat']), {}, {
   renderWebChat: renderWebChat
 });
 (0, _addVersion.default)('full');
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.ts"],"names":["renderWebChat","coreRenderWebChat","bind","ReactWebChat","createDirectLine","options","botAgent","console","warn","version","createDirectLineAppServiceExtension","patchedHooks","hooks","useAdaptiveCardsHostConfig","useAdaptiveCardsPackage","Components","MinimalComponents","AdaptiveCardContent","AudioCardContent","AnimationCardContent","Composer","FullComposer","HeroCardContent","OAuthCardContent","ReceiptCardContent","SignInCardContent","ThumbnailCardContent","VideoCardContent","window","createAdaptiveCardsAttachmentMiddleware","createAdaptiveCardsAttachmentForScreenReaderMiddleware","createCognitiveServicesSpeechServicesPonyfillFactory","createDirectLineSpeechAdapters","createStyleSet","renderMarkdown"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;AAEA,IAAMA,aAAa,GAAGC,uBAAkBC,IAAlB,CAAuB,IAAvB,EAA6BC,yBAA7B,CAAtB;;;;AAEO,IAAMC,gBAAgB,GAAG,SAAnBA,gBAAmB,CAAAC,OAAO,EAAI;AACzCA,EAAAA,OAAO,CAACC,QAAR,IACEC,OAAO,CAACC,IAAR,CACE,qJADF,CADF;AAKA,SAAO,+DAA6BH,OAA7B;AAAsCC,IAAAA,QAAQ,oBAAaG,qBAAb;AAA9C,KAAP;AACD,CAPM;;;;AASA,IAAMC,mCAAmC,GAAG,SAAtCA,mCAAsC,CAAAL,OAAO,EAAI;AAC5DA,EAAAA,OAAO,CAACC,QAAR,IACEC,OAAO,CAACC,IAAR,CACE,qJADF,CADF;AAKA,SAAO,kFAAgDH,OAAhD;AAAyDC,IAAAA,QAAQ,oBAAaG,qBAAb;AAAjE,KAAP;AACD,CAPM;;;;AASP,IAAME,YAAY,mCACbC,mBADa;AAEhBC,EAAAA,0BAA0B,EAA1BA,mCAFgB;AAGhBC,EAAAA,uBAAuB,EAAvBA;AAHgB,EAAlB;;;;AAMA,IAAMC,UAAU,mCACXC,wBADW;AAEdC,EAAAA,mBAAmB,EAAnBA,4BAFc;AAGdC,EAAAA,gBAAgB,EAAhBA,yBAHc;AAIdC,EAAAA,oBAAoB,EAApBA,6BAJc;AAKdC,EAAAA,QAAQ,EAAEC,qBALI;AAMdC,EAAAA,eAAe,EAAfA,wBANc;AAOdC,EAAAA,gBAAgB,EAAhBA,yBAPc;AAQdC,EAAAA,kBAAkB,EAAlBA,2BARc;AASdC,EAAAA,iBAAiB,EAAjBA,0BATc;AAUdC,EAAAA,oBAAoB,EAApBA,6BAVc;AAWdC,EAAAA,gBAAgB,EAAhBA;AAXc,EAAhB;;;eAcexB,yB;;AAcfyB,MAAM,CAAC,SAAD,CAAN,mCACKA,MAAM,CAAC,SAAD,CADX;AAEEb,EAAAA,UAAU,EAAVA,UAFF;AAGEc,EAAAA,uCAAuC,EAAvCA,gDAHF;AAIEC,EAAAA,sDAAsD,EAAtDA,+DAJF;AAKEC,EAAAA,oDAAoD,EAApDA,6DALF;AAME3B,EAAAA,gBAAgB,EAAhBA,gBANF;AAOEM,EAAAA,mCAAmC,EAAnCA,mCAPF;AAQEsB,EAAAA,8BAA8B,EAA9BA,uCARF;AASEC,EAAAA,cAAc,EAAdA,2BATF;AAUErB,EAAAA,KAAK,EAAED,YAVT;AAWER,EAAAA,YAAY,EAAZA,yBAXF;AAYE+B,EAAAA,cAAc,EAAdA,uBAZF;AAaElC,EAAAA,aAAa,EAAbA;AAbF;AAgBA,yBAAW,MAAX","sourceRoot":"bundle:///","sourcesContent":["// IMPORTANT: To export anything from this file, add it to index.tsx, which is the .d.ts for this file.\n\n/* eslint dot-notation: [\"error\", { \"allowPattern\": \"^WebChat$\" }] */\n// window['WebChat'] is required for TypeScript\n\nexport * from './index-minimal';\n\nimport { Components as MinimalComponents, hooks, version } from './index-minimal';\nimport AdaptiveCardContent from './adaptiveCards/Attachment/AdaptiveCardContent';\nimport addVersion from './addVersion';\nimport AnimationCardContent from './adaptiveCards/Attachment/AnimationCardContent';\nimport AudioCardContent from './adaptiveCards/Attachment/AudioCardContent';\nimport coreRenderWebChat from './renderWebChat';\nimport createAdaptiveCardsAttachmentMiddleware from './adaptiveCards/createAdaptiveCardsAttachmentMiddleware';\nimport createAdaptiveCardsAttachmentForScreenReaderMiddleware from './adaptiveCards/createAdaptiveCardsAttachmentForScreenReaderMiddleware';\nimport createCognitiveServicesSpeechServicesPonyfillFactory from './createCognitiveServicesSpeechServicesPonyfillFactory';\nimport createDirectLineSpeechAdapters from './createDirectLineSpeechAdapters';\nimport createStyleSet from './createFullStyleSet';\nimport defaultCreateDirectLine from './createDirectLine';\nimport defaultCreateDirectLineAppServiceExtension from './createDirectLineAppServiceExtension';\nimport FullComposer from './FullComposer';\nimport HeroCardContent from './adaptiveCards/Attachment/HeroCardContent';\nimport OAuthCardContent from './adaptiveCards/Attachment/OAuthCardContent';\nimport ReactWebChat from './FullReactWebChat';\nimport ReceiptCardContent from './adaptiveCards/Attachment/ReceiptCardContent';\nimport renderMarkdown from './renderMarkdown';\nimport SignInCardContent from './adaptiveCards/Attachment/SignInCardContent';\nimport ThumbnailCardContent from './adaptiveCards/Attachment/ThumbnailCardContent';\nimport useAdaptiveCardsHostConfig from './adaptiveCards/hooks/useAdaptiveCardsHostConfig';\nimport useAdaptiveCardsPackage from './adaptiveCards/hooks/useAdaptiveCardsPackage';\nimport VideoCardContent from './adaptiveCards/Attachment/VideoCardContent';\n\nconst renderWebChat = coreRenderWebChat.bind(null, ReactWebChat);\n\nexport const createDirectLine = options => {\n  options.botAgent &&\n    console.warn(\n      'Web Chat: Developers are not currently allowed to set botAgent. See https://github.com/microsoft/BotFramework-WebChat/issues/2119 for more details.'\n    );\n\n  return defaultCreateDirectLine({ ...options, botAgent: `WebChat/${version} (Full)` });\n};\n\nexport const createDirectLineAppServiceExtension = options => {\n  options.botAgent &&\n    console.warn(\n      'Web Chat: Developers are not currently allowed to set botAgent. See https://github.com/microsoft/BotFramework-WebChat/issues/2119 for more details.'\n    );\n\n  return defaultCreateDirectLineAppServiceExtension({ ...options, botAgent: `WebChat/${version} (Full)` });\n};\n\nconst patchedHooks = {\n  ...hooks,\n  useAdaptiveCardsHostConfig,\n  useAdaptiveCardsPackage\n};\n\nconst Components = {\n  ...MinimalComponents,\n  AdaptiveCardContent,\n  AudioCardContent,\n  AnimationCardContent,\n  Composer: FullComposer,\n  HeroCardContent,\n  OAuthCardContent,\n  ReceiptCardContent,\n  SignInCardContent,\n  ThumbnailCardContent,\n  VideoCardContent\n};\n\nexport default ReactWebChat;\n\nexport {\n  Components,\n  createAdaptiveCardsAttachmentMiddleware,\n  createAdaptiveCardsAttachmentForScreenReaderMiddleware,\n  createCognitiveServicesSpeechServicesPonyfillFactory,\n  createDirectLineSpeechAdapters,\n  createStyleSet,\n  patchedHooks as hooks,\n  renderMarkdown,\n  renderWebChat\n};\n\nwindow['WebChat'] = {\n  ...window['WebChat'],\n  Components,\n  createAdaptiveCardsAttachmentMiddleware,\n  createAdaptiveCardsAttachmentForScreenReaderMiddleware,\n  createCognitiveServicesSpeechServicesPonyfillFactory,\n  createDirectLine,\n  createDirectLineAppServiceExtension,\n  createDirectLineSpeechAdapters,\n  createStyleSet,\n  hooks: patchedHooks,\n  ReactWebChat,\n  renderMarkdown,\n  renderWebChat\n};\n\naddVersion('full');\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.ts"],"names":["renderWebChat","coreRenderWebChat","bind","ReactWebChat","createDirectLine","options","botAgent","console","warn","version","createDirectLineAppServiceExtension","patchedHooks","hooks","useAdaptiveCardsHostConfig","useAdaptiveCardsPackage","useStyleOptions","AdditionalComponents","AdaptiveCardContent","AnimationCardContent","AudioCardContent","Composer","FullComposer","HeroCardContent","OAuthCardContent","ReceiptCardContent","SignInCardContent","ThumbnailCardContent","VideoCardContent","Components","MinimalComponents","window","createAdaptiveCardsAttachmentMiddleware","createAdaptiveCardsAttachmentForScreenReaderMiddleware","createCognitiveServicesSpeechServicesPonyfillFactory","createDirectLineSpeechAdapters","createStyleSet","renderMarkdown"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;AAEA,IAAMA,aAAa,GAAGC,uBAAkBC,IAAlB,CAAuB,IAAvB,EAA6BC,yBAA7B,CAAtB;;;;AAEO,IAAMC,gBAAgB,GAAG,SAAnBA,gBAAmB,CAACC,OAAD,EAA8E;AAC3GA,EAAAA,OAAD,CAAiBC,QAAjB,IACEC,OAAO,CAACC,IAAR,CACE,qJADF,CADF;AAKA,SAAO,+DAA6BH,OAA7B;AAAsCC,IAAAA,QAAQ,oBAAaG,qBAAb;AAA9C,KAAP;AACD,CAPM;;;;AASA,IAAMC,mCAAmC,GAAG,SAAtCA,mCAAsC,CACjDL,OADiD,EAE9C;AACFA,EAAAA,OAAD,CAAiBC,QAAjB,IACEC,OAAO,CAACC,IAAR,CACE,qJADF,CADF;AAKA,SAAO,kFAAgDH,OAAhD;AAAyDC,IAAAA,QAAQ,oBAAaG,qBAAb;AAAjE,KAAP;AACD,CATM;;;;AAWP,IAAME,YAAY,mCACbC,mBADa;AAEhBC,EAAAA,0BAA0B,EAA1BA,mCAFgB;AAGhBC,EAAAA,uBAAuB,EAAvBA,gCAHgB;AAIhBC,EAAAA,eAAe,EAAfA;AAJgB,EAAlB;;;AAOA,IAAMC,oBAAoB,GAAG;AAC3BC,EAAAA,mBAAmB,EAAnBA,4BAD2B;AAE3BC,EAAAA,oBAAoB,EAApBA,6BAF2B;AAG3BC,EAAAA,gBAAgB,EAAhBA,yBAH2B;AAI3BC,EAAAA,QAAQ,EAAEC,qBAJiB;AAK3BC,EAAAA,eAAe,EAAfA,wBAL2B;AAM3BC,EAAAA,gBAAgB,EAAhBA,yBAN2B;AAO3BC,EAAAA,kBAAkB,EAAlBA,2BAP2B;AAQ3BC,EAAAA,iBAAiB,EAAjBA,0BAR2B;AAS3BC,EAAAA,oBAAoB,EAApBA,6BAT2B;AAU3BC,EAAAA,gBAAgB,EAAhBA;AAV2B,CAA7B;;AAaA,IAAMC,UAAkE,mCACnEC,wBADmE,GAEnEb,oBAFmE,CAAxE;;;eAQeb,yB;;AAgBf2B,MAAM,CAAC,SAAD,CAAN,mCACKA,MAAM,CAAC,SAAD,CADX;AAEEF,EAAAA,UAAU,EAAVA,UAFF;AAGEG,EAAAA,uCAAuC,EAAvCA,gDAHF;AAIEC,EAAAA,sDAAsD,EAAtDA,+DAJF;AAKEC,EAAAA,oDAAoD,EAApDA,6DALF;AAME7B,EAAAA,gBAAgB,EAAhBA,gBANF;AAOEM,EAAAA,mCAAmC,EAAnCA,mCAPF;AAQEwB,EAAAA,8BAA8B,EAA9BA,uCARF;AASEC,EAAAA,cAAc,EAAdA,2BATF;AAUEvB,EAAAA,KAAK,EAAED,YAVT;AAWER,EAAAA,YAAY,EAAZA,yBAXF;AAYEiC,EAAAA,cAAc,EAAdA,uBAZF;AAaEpC,EAAAA,aAAa,EAAbA;AAbF;AAgBA,yBAAW,MAAX","sourceRoot":"bundle:///","sourcesContent":["/* eslint dot-notation: [\"error\", { \"allowPattern\": \"^WebChat$\" }] */\n// window['WebChat'] is required for TypeScript\n\nexport * from './index-minimal';\n\nimport { Components as MinimalComponents, hooks, version } from './index-minimal';\nimport AdaptiveCardContent from './adaptiveCards/Attachment/AdaptiveCardContent';\nimport addVersion from './addVersion';\nimport AnimationCardContent from './adaptiveCards/Attachment/AnimationCardContent';\nimport AudioCardContent from './adaptiveCards/Attachment/AudioCardContent';\nimport coreRenderWebChat from './renderWebChat';\nimport createAdaptiveCardsAttachmentMiddleware from './adaptiveCards/createAdaptiveCardsAttachmentMiddleware';\nimport createAdaptiveCardsAttachmentForScreenReaderMiddleware from './adaptiveCards/createAdaptiveCardsAttachmentForScreenReaderMiddleware';\nimport createCognitiveServicesSpeechServicesPonyfillFactory from './createCognitiveServicesSpeechServicesPonyfillFactory';\nimport createDirectLineSpeechAdapters from './createDirectLineSpeechAdapters';\nimport createStyleSet from './createFullStyleSet';\nimport defaultCreateDirectLine from './createDirectLine';\nimport defaultCreateDirectLineAppServiceExtension from './createDirectLineAppServiceExtension';\nimport FullBundleStyleOptions, { StrictFullBundleStyleOptions } from './types/FullBundleStyleOptions';\nimport FullComposer from './FullComposer';\nimport HeroCardContent from './adaptiveCards/Attachment/HeroCardContent';\nimport OAuthCardContent from './adaptiveCards/Attachment/OAuthCardContent';\nimport ReactWebChat from './FullReactWebChat';\nimport ReceiptCardContent from './adaptiveCards/Attachment/ReceiptCardContent';\nimport renderMarkdown from './renderMarkdown';\nimport SignInCardContent from './adaptiveCards/Attachment/SignInCardContent';\nimport ThumbnailCardContent from './adaptiveCards/Attachment/ThumbnailCardContent';\nimport useAdaptiveCardsHostConfig from './adaptiveCards/hooks/useAdaptiveCardsHostConfig';\nimport useAdaptiveCardsPackage from './adaptiveCards/hooks/useAdaptiveCardsPackage';\nimport useStyleOptions from './hooks/useStyleOptions';\nimport VideoCardContent from './adaptiveCards/Attachment/VideoCardContent';\n\nconst renderWebChat = coreRenderWebChat.bind(null, ReactWebChat);\n\nexport const createDirectLine = (options: Omit<Parameters<typeof defaultCreateDirectLine>[0], 'botAgent'>) => {\n  (options as any).botAgent &&\n    console.warn(\n      'Web Chat: Developers are not currently allowed to set botAgent. See https://github.com/microsoft/BotFramework-WebChat/issues/2119 for more details.'\n    );\n\n  return defaultCreateDirectLine({ ...options, botAgent: `WebChat/${version} (Full)` });\n};\n\nexport const createDirectLineAppServiceExtension = (\n  options: Omit<Parameters<typeof defaultCreateDirectLineAppServiceExtension>[0], 'botAgent'>\n) => {\n  (options as any).botAgent &&\n    console.warn(\n      'Web Chat: Developers are not currently allowed to set botAgent. See https://github.com/microsoft/BotFramework-WebChat/issues/2119 for more details.'\n    );\n\n  return defaultCreateDirectLineAppServiceExtension({ ...options, botAgent: `WebChat/${version} (Full)` });\n};\n\nconst patchedHooks = {\n  ...hooks,\n  useAdaptiveCardsHostConfig,\n  useAdaptiveCardsPackage,\n  useStyleOptions\n};\n\nconst AdditionalComponents = {\n  AdaptiveCardContent,\n  AnimationCardContent,\n  AudioCardContent,\n  Composer: FullComposer,\n  HeroCardContent,\n  OAuthCardContent,\n  ReceiptCardContent,\n  SignInCardContent,\n  ThumbnailCardContent,\n  VideoCardContent\n};\n\nconst Components: typeof MinimalComponents & typeof AdditionalComponents = {\n  ...MinimalComponents,\n  ...AdditionalComponents\n};\n\ntype StyleOptions = FullBundleStyleOptions;\ntype StrictStyleOptions = StrictFullBundleStyleOptions;\n\nexport default ReactWebChat;\n\nexport {\n  Components,\n  createAdaptiveCardsAttachmentMiddleware,\n  createAdaptiveCardsAttachmentForScreenReaderMiddleware,\n  createCognitiveServicesSpeechServicesPonyfillFactory,\n  createDirectLineSpeechAdapters,\n  createStyleSet,\n  patchedHooks as hooks,\n  renderMarkdown,\n  renderWebChat\n};\n\nexport type { StyleOptions, StrictStyleOptions };\n\nwindow['WebChat'] = {\n  ...window['WebChat'],\n  Components,\n  createAdaptiveCardsAttachmentMiddleware,\n  createAdaptiveCardsAttachmentForScreenReaderMiddleware,\n  createCognitiveServicesSpeechServicesPonyfillFactory,\n  createDirectLine,\n  createDirectLineAppServiceExtension,\n  createDirectLineSpeechAdapters,\n  createStyleSet,\n  hooks: patchedHooks,\n  ReactWebChat,\n  renderMarkdown,\n  renderWebChat\n};\n\naddVersion('full');\n"]}

package/lib/renderMarkdown.d.ts

@@ -0,0 +1,6 @@
+export default function render(markdown: string, { markdownRespectCRLF }: {
+    markdownRespectCRLF: boolean;
+}, { externalLinkAlt }?: {
+    externalLinkAlt?: string;
+}): string;
+//# sourceMappingURL=renderMarkdown.d.ts.map

package/lib/renderMarkdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderMarkdown.d.ts","sourceRoot":"","sources":["../src/renderMarkdown.ts"],"names":[],"mappings":"AA2DA,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,QAAQ,EAAE,MAAM,EAChB,EAAE,mBAAmB,EAAE,EAAE;IAAE,mBAAmB,EAAE,OAAO,CAAA;CAAE,EACzD,EAAE,eAAoB,EAAE,GAAE;IAAE,eAAe,CAAC,EAAE,MAAM,CAAA;CAAO,GAC1D,MAAM,CAwCR"}