@itwin/core-bentley 3.6.0-dev.60 → 3.6.0-dev.65

package/CHANGELOG.md

@@ -1,6 +1,21 @@
 # Change Log - @itwin/core-bentley
 
-This log was last generated on Wed, 11 Jan 2023 16:46:30 GMT and should not be manually modified.
+This log was last generated on Thu, 26 Jan 2023 22:53:27 GMT and should not be manually modified.
+
+## 3.5.5
+Thu, 26 Jan 2023 22:53:27 GMT
+
+_Version update only_
+
+## 3.5.4
+Wed, 18 Jan 2023 15:27:15 GMT
+
+_Version update only_
+
+## 3.5.3
+Fri, 13 Jan 2023 17:23:07 GMT
+
+_Version update only_
 
 ## 3.5.2
 Wed, 11 Jan 2023 16:46:30 GMT

package/lib/cjs/AccessToken.d.ts

@@ -1,11 +1,11 @@
-/** @packageDocumentation
- * @module Utils
- */
-/** A string representing a token used to access resources. An empty string represents an invalid/unavailable token.
- * @see [IModelHost.getAccessToken]($backend) and [IModelApp.getAccessToken]($frontend) to obtain an access token.
- * @see [IModelHostOptions.authorizationClient]($backend) and [IModelAppOptions.authorizationClient]($frontend) to configure how access tokens are obtained.
- * @note Access tokens expire periodically and are automatically refreshed when possible; therefore, tokens should always be requested via an [AuthorizationClient]($common), not cached for later reuse.
- * @public
- */
-export declare type AccessToken = string;
+/** @packageDocumentation
+ * @module Utils
+ */
+/** A string representing a token used to access resources. An empty string represents an invalid/unavailable token.
+ * @see [IModelHost.getAccessToken]($backend) and [IModelApp.getAccessToken]($frontend) to obtain an access token.
+ * @see [IModelHostOptions.authorizationClient]($backend) and [IModelAppOptions.authorizationClient]($frontend) to configure how access tokens are obtained.
+ * @note Access tokens expire periodically and are automatically refreshed when possible; therefore, tokens should always be requested via an [AuthorizationClient]($common), not cached for later reuse.
+ * @public
+ */
+export declare type AccessToken = string;
 //# sourceMappingURL=AccessToken.d.ts.map

package/lib/cjs/AccessToken.js

@@ -1,10 +1,10 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Utils
- */
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Utils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=AccessToken.js.map

package/lib/cjs/AccessToken.js.map

@@ -1 +1 @@
-{"version":3,"file":"AccessToken.js","sourceRoot":"","sources":["../../src/AccessToken.ts"],"names":[],"mappings":";AACA;;;+FAG+F;AAC/F;;GAEG","sourcesContent":["\r\n/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Utils\r\n */\r\n\r\n/** A string representing a token used to access resources. An empty string represents an invalid/unavailable token.\r\n * @see [IModelHost.getAccessToken]($backend) and [IModelApp.getAccessToken]($frontend) to obtain an access token.\r\n * @see [IModelHostOptions.authorizationClient]($backend) and [IModelAppOptions.authorizationClient]($frontend) to configure how access tokens are obtained.\r\n * @note Access tokens expire periodically and are automatically refreshed when possible; therefore, tokens should always be requested via an [AuthorizationClient]($common), not cached for later reuse.\r\n * @public\r\n */\r\nexport type AccessToken = string;\r\n"]}
+{"version":3,"file":"AccessToken.js","sourceRoot":"","sources":["../../src/AccessToken.ts"],"names":[],"mappings":";AACA;;;+FAG+F;AAC/F;;GAEG","sourcesContent":["\n/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Utils\n */\n\n/** A string representing a token used to access resources. An empty string represents an invalid/unavailable token.\n * @see [IModelHost.getAccessToken]($backend) and [IModelApp.getAccessToken]($frontend) to obtain an access token.\n * @see [IModelHostOptions.authorizationClient]($backend) and [IModelAppOptions.authorizationClient]($frontend) to configure how access tokens are obtained.\n * @note Access tokens expire periodically and are automatically refreshed when possible; therefore, tokens should always be requested via an [AuthorizationClient]($common), not cached for later reuse.\n * @public\n */\nexport type AccessToken = string;\n"]}

package/lib/cjs/Assert.d.ts

@@ -1,26 +1,26 @@
-/** @packageDocumentation
- * @module Utils
- */
-/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.
- * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.
- *
- * Assertions exist solely to assist programmers during development, in the following ways:
- *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate
- *    a serious flaw in the programmer's logic.
- *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.
- *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.
- *
- * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,
- * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,
- * the programmer has made a serious mistake.
- *
- * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.
- * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.
- *
- * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.
- * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to "Programmer Error".
- * @throws Error containing the specified `message` if `condition` is `false`.
- * @public
- */
-export declare function assert(condition: boolean | (() => boolean), message?: string | (() => string)): asserts condition;
+/** @packageDocumentation
+ * @module Utils
+ */
+/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.
+ * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.
+ *
+ * Assertions exist solely to assist programmers during development, in the following ways:
+ *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate
+ *    a serious flaw in the programmer's logic.
+ *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.
+ *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.
+ *
+ * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,
+ * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,
+ * the programmer has made a serious mistake.
+ *
+ * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.
+ * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.
+ *
+ * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.
+ * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to "Programmer Error".
+ * @throws Error containing the specified `message` if `condition` is `false`.
+ * @public
+ */
+export declare function assert(condition: boolean | (() => boolean), message?: string | (() => string)): asserts condition;
 //# sourceMappingURL=Assert.d.ts.map

package/lib/cjs/Assert.js

@@ -1,46 +1,46 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Utils
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = void 0;
-const assertionsEnabled = process.env.NODE_ENV === "development";
-/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.
- * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.
- *
- * Assertions exist solely to assist programmers during development, in the following ways:
- *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate
- *    a serious flaw in the programmer's logic.
- *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.
- *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.
- *
- * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,
- * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,
- * the programmer has made a serious mistake.
- *
- * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.
- * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.
- *
- * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.
- * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to "Programmer Error".
- * @throws Error containing the specified `message` if `condition` is `false`.
- * @public
- */
-function assert(condition, message) {
-    if (!assertionsEnabled)
-        return;
-    if ("boolean" !== typeof condition)
-        condition = condition();
-    if (condition)
-        return;
-    message = message !== null && message !== void 0 ? message : "Programmer Error";
-    if ("string" !== typeof message)
-        message = message();
-    throw new Error(`Assert: ${message}`);
-}
-exports.assert = assert;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Utils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+const assertionsEnabled = process.env.NODE_ENV === "development";
+/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.
+ * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.
+ *
+ * Assertions exist solely to assist programmers during development, in the following ways:
+ *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate
+ *    a serious flaw in the programmer's logic.
+ *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.
+ *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.
+ *
+ * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,
+ * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,
+ * the programmer has made a serious mistake.
+ *
+ * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.
+ * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.
+ *
+ * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.
+ * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to "Programmer Error".
+ * @throws Error containing the specified `message` if `condition` is `false`.
+ * @public
+ */
+function assert(condition, message) {
+    if (!assertionsEnabled)
+        return;
+    if ("boolean" !== typeof condition)
+        condition = condition();
+    if (condition)
+        return;
+    message = message !== null && message !== void 0 ? message : "Programmer Error";
+    if ("string" !== typeof message)
+        message = message();
+    throw new Error(`Assert: ${message}`);
+}
+exports.assert = assert;
 //# sourceMappingURL=Assert.js.map

package/lib/cjs/Assert.js.map

@@ -1 +1 @@
-{"version":3,"file":"Assert.js","sourceRoot":"","sources":["../../src/Assert.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,aAAa,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,MAAM,CAAC,SAAoC,EAAE,OAAiC;IAC5F,IAAI,CAAC,iBAAiB;QACpB,OAAO;IAET,IAAI,SAAS,KAAK,OAAO,SAAS;QAChC,SAAS,GAAG,SAAS,EAAE,CAAC;IAE1B,IAAI,SAAS;QACX,OAAO;IAET,OAAO,GAAG,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,kBAAkB,CAAC;IACxC,IAAI,QAAQ,KAAK,OAAO,OAAO;QAC7B,OAAO,GAAG,OAAO,EAAE,CAAC;IAEtB,MAAM,IAAI,KAAK,CAAC,WAAW,OAAO,EAAE,CAAC,CAAC;AACxC,CAAC;AAfD,wBAeC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Utils\r\n */\r\n\r\nconst assertionsEnabled = process.env.NODE_ENV === \"development\";\r\n\r\n/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.\r\n * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.\r\n *\r\n * Assertions exist solely to assist programmers during development, in the following ways:\r\n *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate\r\n *    a serious flaw in the programmer's logic.\r\n *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.\r\n *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.\r\n *\r\n * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,\r\n * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,\r\n * the programmer has made a serious mistake.\r\n *\r\n * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.\r\n * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.\r\n *\r\n * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.\r\n * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to \"Programmer Error\".\r\n * @throws Error containing the specified `message` if `condition` is `false`.\r\n * @public\r\n */\r\nexport function assert(condition: boolean | (() => boolean), message?: string | (() => string)): asserts condition {\r\n  if (!assertionsEnabled)\r\n    return;\r\n\r\n  if (\"boolean\" !== typeof condition)\r\n    condition = condition();\r\n\r\n  if (condition)\r\n    return;\r\n\r\n  message = message ?? \"Programmer Error\";\r\n  if (\"string\" !== typeof message)\r\n    message = message();\r\n\r\n  throw new Error(`Assert: ${message}`);\r\n}\r\n"]}
+{"version":3,"file":"Assert.js","sourceRoot":"","sources":["../../src/Assert.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,aAAa,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,MAAM,CAAC,SAAoC,EAAE,OAAiC;IAC5F,IAAI,CAAC,iBAAiB;QACpB,OAAO;IAET,IAAI,SAAS,KAAK,OAAO,SAAS;QAChC,SAAS,GAAG,SAAS,EAAE,CAAC;IAE1B,IAAI,SAAS;QACX,OAAO;IAET,OAAO,GAAG,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,kBAAkB,CAAC;IACxC,IAAI,QAAQ,KAAK,OAAO,OAAO;QAC7B,OAAO,GAAG,OAAO,EAAE,CAAC;IAEtB,MAAM,IAAI,KAAK,CAAC,WAAW,OAAO,EAAE,CAAC,CAAC;AACxC,CAAC;AAfD,wBAeC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Utils\n */\n\nconst assertionsEnabled = process.env.NODE_ENV === \"development\";\n\n/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.\n * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.\n *\n * Assertions exist solely to assist programmers during development, in the following ways:\n *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate\n *    a serious flaw in the programmer's logic.\n *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.\n *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.\n *\n * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,\n * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,\n * the programmer has made a serious mistake.\n *\n * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.\n * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.\n *\n * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.\n * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to \"Programmer Error\".\n * @throws Error containing the specified `message` if `condition` is `false`.\n * @public\n */\nexport function assert(condition: boolean | (() => boolean), message?: string | (() => string)): asserts condition {\n  if (!assertionsEnabled)\n    return;\n\n  if (\"boolean\" !== typeof condition)\n    condition = condition();\n\n  if (condition)\n    return;\n\n  message = message ?? \"Programmer Error\";\n  if (\"string\" !== typeof message)\n    message = message();\n\n  throw new Error(`Assert: ${message}`);\n}\n"]}

package/lib/cjs/BeEvent.d.ts

@@ -1,82 +1,82 @@
-/** @packageDocumentation
- * @module Events
- */
-/** A function invoked when a BeEvent is raised.
- * @public
- */
-export declare type Listener = (...arg: any[]) => void;
-/**
- * Manages a set of *listeners* for a particular event and notifies them when the event is raised.
- * This class is usually instantiated inside of a container class and
- * exposed as a property for others to *subscribe* via [[BeEvent.addListener]].
- * @public
- */
-export declare class BeEvent<T extends Listener> {
-    private _listeners;
-    private _insideRaiseEvent;
-    /** The number of listeners currently subscribed to the event. */
-    get numberOfListeners(): number;
-    /**
-     * Registers a Listener to be executed whenever this event is raised.
-     * @param listener The function to be executed when the event is raised.
-     * @param scope An optional object scope to serve as the 'this' pointer when listener is invoked.
-     * @returns A function that will remove this event listener.
-     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
-     */
-    addListener(listener: T, scope?: any): () => void;
-    /**
-     * Registers a callback function to be executed *only once* when the event is raised.
-     * @param listener The function to be executed once when the event is raised.
-     * @param scope An optional object scope to serve as the `this` pointer in which the listener function will execute.
-     * @returns A function that will remove this event listener.
-     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
-     */
-    addOnce(listener: T, scope?: any): () => void;
-    /**
-     * Un-register a previously registered listener.
-     * @param listener The listener to be unregistered.
-     * @param  scope The scope that was originally passed to addListener.
-     * @returns 'true' if the listener was removed; 'false' if the listener and scope are not registered with the event.
-     * @see [[BeEvent.raiseEvent]], [[BeEvent.addListener]]
-     */
-    removeListener(listener: T, scope?: any): boolean;
-    /**
-     * Raises the event by calling each registered listener with the supplied arguments.
-     * @param args This method takes any number of parameters and passes them through to the listeners.
-     * @see [[BeEvent.removeListener]], [[BeEvent.addListener]]
-     */
-    raiseEvent(...args: Parameters<T>): void;
-    /** Determine whether this BeEvent has a specified listener registered.
-     * @param listener The listener to check.
-     * @param scope optional scope argument to match call to addListener
-     */
-    has(listener: T, scope?: any): boolean;
-    /** Clear all Listeners from this BeEvent. */
-    clear(): void;
-}
-/** Specialization of BeEvent for events that take a single strongly typed argument, primarily used for UI events.
- * @public
- */
-export declare class BeUiEvent<TEventArgs> extends BeEvent<(args: TEventArgs) => void> {
-    /** Raises event with single strongly typed argument. */
-    emit(args: TEventArgs): void;
-}
-/**
- * A list of BeEvent objects, accessible by an event name.
- * This class may be used instead of explicitly declaring each BeEvent as a member of a containing class.
- * @public
- */
-export declare class BeEventList<T extends Listener> {
-    private _events;
-    /**
-     * Gets the event associated with the specified name, creating the event if it does not already exist.
-     * @param name The name of the event.
-     */
-    get(name: string): BeEvent<T>;
-    /**
-     * Removes the event associated with a name.
-     * @param name The name of the event.
-     */
-    remove(name: string): void;
-}
+/** @packageDocumentation
+ * @module Events
+ */
+/** A function invoked when a BeEvent is raised.
+ * @public
+ */
+export declare type Listener = (...arg: any[]) => void;
+/**
+ * Manages a set of *listeners* for a particular event and notifies them when the event is raised.
+ * This class is usually instantiated inside of a container class and
+ * exposed as a property for others to *subscribe* via [[BeEvent.addListener]].
+ * @public
+ */
+export declare class BeEvent<T extends Listener> {
+    private _listeners;
+    private _insideRaiseEvent;
+    /** The number of listeners currently subscribed to the event. */
+    get numberOfListeners(): number;
+    /**
+     * Registers a Listener to be executed whenever this event is raised.
+     * @param listener The function to be executed when the event is raised.
+     * @param scope An optional object scope to serve as the 'this' pointer when listener is invoked.
+     * @returns A function that will remove this event listener.
+     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
+     */
+    addListener(listener: T, scope?: any): () => void;
+    /**
+     * Registers a callback function to be executed *only once* when the event is raised.
+     * @param listener The function to be executed once when the event is raised.
+     * @param scope An optional object scope to serve as the `this` pointer in which the listener function will execute.
+     * @returns A function that will remove this event listener.
+     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
+     */
+    addOnce(listener: T, scope?: any): () => void;
+    /**
+     * Un-register a previously registered listener.
+     * @param listener The listener to be unregistered.
+     * @param  scope The scope that was originally passed to addListener.
+     * @returns 'true' if the listener was removed; 'false' if the listener and scope are not registered with the event.
+     * @see [[BeEvent.raiseEvent]], [[BeEvent.addListener]]
+     */
+    removeListener(listener: T, scope?: any): boolean;
+    /**
+     * Raises the event by calling each registered listener with the supplied arguments.
+     * @param args This method takes any number of parameters and passes them through to the listeners.
+     * @see [[BeEvent.removeListener]], [[BeEvent.addListener]]
+     */
+    raiseEvent(...args: Parameters<T>): void;
+    /** Determine whether this BeEvent has a specified listener registered.
+     * @param listener The listener to check.
+     * @param scope optional scope argument to match call to addListener
+     */
+    has(listener: T, scope?: any): boolean;
+    /** Clear all Listeners from this BeEvent. */
+    clear(): void;
+}
+/** Specialization of BeEvent for events that take a single strongly typed argument, primarily used for UI events.
+ * @public
+ */
+export declare class BeUiEvent<TEventArgs> extends BeEvent<(args: TEventArgs) => void> {
+    /** Raises event with single strongly typed argument. */
+    emit(args: TEventArgs): void;
+}
+/**
+ * A list of BeEvent objects, accessible by an event name.
+ * This class may be used instead of explicitly declaring each BeEvent as a member of a containing class.
+ * @public
+ */
+export declare class BeEventList<T extends Listener> {
+    private _events;
+    /**
+     * Gets the event associated with the specified name, creating the event if it does not already exist.
+     * @param name The name of the event.
+     */
+    get(name: string): BeEvent<T>;
+    /**
+     * Removes the event associated with a name.
+     * @param name The name of the event.
+     */
+    remove(name: string): void;
+}
 //# sourceMappingURL=BeEvent.d.ts.map