bm-core-ui 2.9.5 → 2.10.0

package/build/@types/index.d.ts

@@ -245,49 +245,55 @@ export class BMHTMLEntity {
 	 * The HTML entity representing the control key.
 	 *  
 	 */
-	static Control: BMHTMLEntity;
+	static Control: string;
 
 	/**
 	 * The HTML entity representing the bowen knot Command symbol.
 	 *  
 	 */
-	static Command: BMHTMLEntity;
+	static Command: string;
 
 	/**
 	 * The HTML entity representing the Option symbol.
 	 *  
 	 */
-	static Option: BMHTMLEntity;
+	static Option: string;
 
 	/**
 	 * The HTML entity representing the Shift symbol.
 	 *  
 	 */
-	static Shift: BMHTMLEntity;
+	static Shift: string;
 
 	/**
 	 * The HTML entity representing the Caps-Lock symbol.
 	 *  
 	 */
-	static CapsLock: BMHTMLEntity;
+	static CapsLock: string;
 
 	/**
 	 * The HTML entity representing the Backspace delete symbol.
 	 *  
 	 */
-	static Delete: BMHTMLEntity;
+	static Delete: string;
 
 	/**
 	 * The HTML entity representing the Return symbol.
 	 *  
 	 */
-	static Return: BMHTMLEntity;
+	static Return: string;
 
 	/**
 	 * The HTML entity representing the Escape symbol.
 	 *  
 	 */
-	static Escape: BMHTMLEntity;
+	static Escape: string;
+
+	/**
+	 * The HTML entity representing the Tab symbol.
+	 *  
+	 */
+	static Tab: string;
 
 	private constructor(); 
 }
@@ -3567,6 +3573,32 @@ export class BMViewLayoutQueue {
 }
 
 
+/**
+ * Constants that describe the color scheme that a view should use when drawing itself.
+ * 
+ */
+export class BMViewColorScheme {
+	/**
+	 * Indicates that the view's color scheme should be based on the system color scheme.
+	 *  
+	 */
+	static Auto: BMViewColorScheme;
+
+	/**
+	 * Indicates that the view should always use a dark color scheme regardless of the system color scheme setting.
+	 *  
+	 */
+	static Dark: BMViewColorScheme;
+
+	/**
+	 * Indicates that the view should always use a light color scheme regardless of the system color scheme setting.
+	 *  
+	 */
+	static Light: BMViewColorScheme;
+
+	private constructor(); 
+}
+
 /**
  * A view is a wrapper around a DOM node enabling various CoreUI-related functionality.
  * Views typically do not duplicate existing DOM capabilities, but instead are used to
@@ -4288,6 +4320,24 @@ export class BMView {
 	hasIsVisibleVariationForSizeClass(sizeClass: BMLayoutSizeClass): boolean;
 
 
+	/**
+	 * The color scheme that this view should use.
+	 *     
+	 */
+	colorScheme: BMViewColorScheme;
+
+	/**
+	 * Invoked by CoreUI whenever the color scheme that the view should use changes.
+	 * 
+	 * Subclasses may use this method to perform any changes needed to support the requested color scheme.
+	 * Subclasses that override this method must invoke the superclass method at some point in their implementation.
+	 * 
+	 * @param scheme         The previous color scheme.
+	 *     
+	 */
+	protected colorSchemeDidChange(scheme: BMViewColorScheme): void;
+
+
 	/**
 	 * Used by CoreUI to determine if this view's intrinsic size should match the intrinsic size reported by its node element.
 	 * When this getter returns `YES`, CoreUI will measure the view's node to determine its intrinsic size.
@@ -8031,6 +8081,19 @@ export class BMMenuItem {
 	 */
 	CSSClass?: string | null | undefined;
 
+	/**
+	 * An optional key sequence that may be used to select this menu item via a keyboard shortcut.
+	 * Updates to this property do not take effect while a menu displaying this menu item is open.
+	 *     
+	 */
+	keySequence?: BMKeySequence | null | undefined;
+
+	/**
+	 * An optional hint HTML text that will be displayed next to the menu item.
+	 *     
+	 */
+	hintHTML?: string | null | undefined;
+
 	/**
 	 * The node that represents this menu item, available while its menu
 	 * is open.
@@ -8038,6 +8101,13 @@ export class BMMenuItem {
 	 */
 	private _node?: DOMNode | null | undefined;
 
+	/**
+	 * Defaults to `YES`. Controls whether this menu item is enabled. If this menu
+	 * item is not enabled, it can not be highlighted or selected.
+	 *     
+	 */
+	enabled: boolean;
+
 	/**
 	 * Constructs and returns a menu item with the given name.
 	 * Optionally, the menu item may have an icon associated with it as well as an
@@ -8048,12 +8118,13 @@ export class BMMenuItem {
 	 * 
 	 * @param action    If specified, this is a function that will be invoked when this menu item is selected.
 	 *                                                  This function will receive the selected menu item as a parameter.
+	 * @param enabled               Defaults to `YES`. Controls whether this item is enabled and can be selected.
 	 * @param submenu                Optional. If specified, this represents a menu that opens from this menu item.
 	 * @param userInfo            Optional. If specified, this represents additional arbitrary data attached to this menu item.
 	 * @return                              This menu item.
 	 *     
 	 */
-	initWithName(name: string, {icon, action, submenu, userInfo}?: {icon?: string | null | undefined, action?: (($0: BMMenuItem) => void) | null | undefined, submenu?: BMMenu | null | undefined, userInfo?: any | null | undefined}): BMMenuItem;
+	initWithName(name: string, {icon, action, enabled, submenu, userInfo}?: {icon?: string | null | undefined, action?: (($0: BMMenuItem) => void) | null | undefined, enabled?: boolean | null | undefined, submenu?: BMMenu | null | undefined, userInfo?: any | null | undefined}): BMMenuItem;
 
 
 	/**
@@ -8066,12 +8137,13 @@ export class BMMenuItem {
 	 * 
 	 * @param action    If specified, this is a function that will be invoked when this menu item is selected.
 	 *                                                  This function will receive the selected menu item as a parameter.
+	 * @param enabled               Defaults to `YES`. Controls whether this item is enabled and can be selected.
 	 * @param submenu                Optional. If specified, this represents a menu that opens from this menu item.
 	 * @param userInfo            Optional. If specified, this represents additional arbitrary data attached to this menu item.
 	 * @return                              A menu item.
 	 * 
 	 */
-	static menuItemWithName (name: string, {icon, action, submenu, userInfo}?: {icon?: string | null | undefined, action?: (($0: BMMenuItem) => void) | null | undefined, submenu?: BMMenu | null | undefined, userInfo?: any | null | undefined}): BMMenuItem;
+	static menuItemWithName (name: string, {icon, action, enabled, submenu, userInfo}?: {icon?: string | null | undefined, action?: (($0: BMMenuItem) => void) | null | undefined, enabled?: boolean | null | undefined, submenu?: BMMenu | null | undefined, userInfo?: any | null | undefined}): BMMenuItem;
 
 
 	/**
@@ -8103,7 +8175,7 @@ export class BMMenu {
 	delegate?: BMMenuDelegate | null | undefined;
 
 	/**
-	 * Defaults to 24. The size to use for this menu's icons.
+	 * Defaults to `24`. The size to use for this menu's icons.
 	 *     
 	 */
 	iconSize: number;
@@ -8243,7 +8315,8 @@ export class BMMenu {
 	private readonly _kind: any;
 
 	/**
-	 * Animatable. Shows this menu from the given DOM node.
+	 * Animatable. Shows this menu from the specified DOM node. The menu will be displayed as a touch menu,
+	 * highlighting the source node and de-emphasizing the rest of the document.
 	 * @param node                     The node from which to show this menu.
 	 * @param animated      Defaults to `NO`. If set to `YES`, this change will be animated.
 	 *                                          If this method is invoked from within an animation context, the value of this parameter is ignored
@@ -8351,6 +8424,15 @@ export class BMMenu {
 	arrowLeftPressedWithEvent(event: KeyboardEvent): void;
 
 
+	/**
+	 * Invoked when the key sequence for a menu item is pressed.
+	 * @param event                          The event that triggered this action.
+	 * @param forKeyboardShortcut      The keyboard shortcut that was triggered.
+	 *     
+	 */
+	private _selectMenuItemWithEvent(event: KeyboardEvent, {forKeyboardShortcut}: {forKeyboardShortcut: BMKeyboardShortcut}): void;
+
+
 	/**
 	 * Invoked when the return or spacebar key is pressed.
 	 * @param event      The event that triggered this action.
@@ -9950,19 +10032,19 @@ export class BMCollectionViewTableLayoutSupplementaryView {
 	 * Indicates that this supplementary view is a footer.
 	 *  
 	 */
-	static Footer: BMCollectionViewTableLayoutSupplementaryView;
+	static Footer: string;
 
 	/**
 	 * Indicates that this supplementary view is a header.
 	 *  
 	 */
-	static Header: BMCollectionViewTableLayoutSupplementaryView;
+	static Header: string;
 
 	/**
 	 * Indicates that this supplementary is an empty content view.
 	 *  
 	 */
-	static Empty: BMCollectionViewTableLayoutSupplementaryView;
+	static Empty: string;
 
 	private constructor(); 
 }
@@ -10594,7 +10676,7 @@ export class BMCollectionViewFlowLayout extends BMCollectionViewLayout {
  * the identifiers used by the table layout are reused in this case.
  * 
  */
-export var BMCollectionViewFlowLayoutSupplementaryView: any;
+export var BMCollectionViewFlowLayoutSupplementaryView: typeof BMCollectionViewTableLayoutSupplementaryView;
 
 
 
@@ -11342,6 +11424,13 @@ export class BMCollectionView<T = any> extends BMView {
 	 */
 	layout: BMCollectionViewLayout;
 
+	/**
+	 * Set to a transition layout while an animated layout update is in progress. Undefined
+	 * in all other cases.
+	 *  
+	 */
+	private _transitionLayout?: BMCollectionViewLayout | null | undefined;
+
 	/**
 	 * Animatable. The collection view's size and its position relative to its parent element.
 	 *  
@@ -11549,7 +11638,24 @@ export class BMCollectionView<T = any> extends BMView {
 
 
 	/**
-	 * Should not be invoked manually. It is invoked by collection view to create the initial layout and cells.
+	 * Initializes this collection view with the specified DOM node and default properties.
+	 * The collection view will use a `BMCollectionViewFlowLayout` layout object.
+	 * A valid object should be assigned to the `dataSet` property to fully initialize and use this collection view.
+	 * @param node 					The container that the collection view will manage. This should be an empty div element,
+	 * 											otherwise the behaviour of the collection view will be undefined.
+	 * @param customScroll  Defaults to `NO`. When set to `YES`, collection view will use custom scrolling in 
+	 * 										place of regular scrolling. Otherwise, it will use native scrolling. This should only be
+	 * 										used with layouts where cell positions depend on the scroll position of collection view.
+	 * 										This property cannot be changed after being set in the intializer.
+	 * @return 				A collection view.
+	 *  
+	 */
+	initWithDOMNode(node: DOMNode, {customScroll}?: {customScroll?: boolean | null | undefined}): BMCollectionView;
+
+
+	/**
+	 * Should not be invoked manually. Invoked by collection view the first time a data set is assigned
+	 * to it to create the initial layout and cells.
 	 *  
 	 */
 	private _init(): void;
@@ -12497,26 +12603,31 @@ export interface BMCollectionViewDataSet<T = any> {
 
 
 	/**
-	 * Returns the complete index path for the object with the given section and row indexes.
+	 * Returns the index path for the object with the specified section and row indexes.
 	 * @param row 						The object's index within the section.
 	 * @param inSectionAtIndex 		The section's index.
-	 * @return 				The complete index path.
+	 * @return 	The index path if these indexes are part of the data set,
+	 * 										`undefined` otherwise. `undefined` may only be returned during
+	 * 										animated data updates while `isUsingOldData` returns `YES`.
 	 *  
 	 */
-	indexPathForObjectAtRow(row: Int, {inSectionAtIndex}: {inSectionAtIndex: Int}): BMIndexPath<T>;
+	indexPathForObjectAtRow(row: Int, {inSectionAtIndex}: {inSectionAtIndex: Int}): BMIndexPath<T> | null | undefined;
 
 
 	/**
-	 * Returns the index path for the given object.
-	 * @param object 	The object.
-	 * @return 	The index path.
+	 * Returns the index path for the specified object.
+	 * @param object 				The object.
+	 * @return 	The index path, if the object is part of the data set,
+	 * 										`undefined` otherwise. `undefined` may only be returned during
+	 * 										animated data updates while `isUsingOldData` returns `YES`.
 	 *  
 	 */
-	indexPathForObject(object: any): BMIndexPath<T>;
+	indexPathForObject(object: any): BMIndexPath<T> | null | undefined;
 
 
 	/**
 	 * @deprecated Deprecated. Consider using custom cell classes instead. Only invoked when using the default cell class.
+	 * ---
 	 * Returns the jQuery element that represents the contents of a cell with the given reuse identifier.
 	 * The collection view will invoke this method whenever a new cell has to be created.
 	 * @param identifier 		The cell's identifier.
@@ -12540,6 +12651,7 @@ export interface BMCollectionViewDataSet<T = any> {
 
 	/**
 	 * @deprecated Deprecated. Consider using custom cell classes instead. Only invoked when using the default cell class.
+	 * ---
 	 * Returns the jQuery element that represents the contents of a supplementary view of the given type.
 	 * The supplementary view's type is defined entirely by the layout object.
 	 * @param identifier 			The supplementary view's type identifier.
@@ -12563,8 +12675,9 @@ export interface BMCollectionViewDataSet<T = any> {
 
 
 	/**
-	 * @deprecated 		Deprecated. This method is optional, but is still invoked by the collection view when implemented. It is recommended to use cell
-	 * 					enumeration and manually update cells as needed during data updates.
+	 * @deprecated 		Deprecated. This method is optional, but is still invoked by the collection view when implemented. Consider using cell
+	 * 					enumeration and manually updating cells as needed during data updates.
+	 * ---
 	 * This method will be invoked by the collection view when it is needed to update the contents of an already rendered cell.
 	 * The data set object should always use the supplied indexPath parameter as the binding to the model object rather than the cell's
 	 * own indexPath property as this method may be invoked during an update when the cell's old indexPath no longer matches the new data set.
@@ -12576,8 +12689,9 @@ export interface BMCollectionViewDataSet<T = any> {
 
 
 	/**
-	 * @deprecated 		Deprecated. This method is optional, but is still invoked by the collection view when implemented. It is recommended to use cell
-	 * 					enumeration and manually update cells as needed during data updates.
+	 * @deprecated 		Deprecated. This method is optional, but is still invoked by the collection view when implemented. Consider using cell
+	 * 					enumeration and manually updating cells as needed during data updates.
+	 * ---
 	 * This method will be invoked by the collection view when it is needed to update the contents of an already rendered supplementary view.
 	 * The data set object should always use the supplied indexPath parameter as the binding to the model object rather than the cell's
 	 * own indexPath property as this method may be invoked during an update when the cell's old indexPath no longer matches the new data set.
@@ -12617,6 +12731,9 @@ export interface BMCollectionViewDataSet<T = any> {
 	 * Data set objects implementing this method are expected to update their internal data structures to match
 	 * the item's new position, then trigger a data update to run on the collection view.
 	 * Optionally, data sets may reject the change and not perform any action.
+	 * ---
+	 * For collection views that support moving items, this method must be implemented by the data sets these collection views
+	 * use. In this case, data sets that don't support moving items may simply return `NO` from this method.
 	 * @param indexPath 			The item's current index path.
 	 * @param toIndexPath 		The index path to which the item should move.
 	 * @return 						`YES` if the data set has performed the requested change, `NO` otherwise.
@@ -13006,9 +13123,10 @@ export interface BMCollectionViewDelegate {
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that is about to be dragged.
 	 * @param atIndexPath 			The cell's index path.
+	 * @return 							`YES` if interaction movement can begin for the specified cell, `NO` otherwise.
 	 *  
 	 */
-	collectionViewCanMoveCell?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {atIndexPath}: {atIndexPath: BMIndexPath}): void;
+	collectionViewCanMoveCell?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {atIndexPath}: {atIndexPath: BMIndexPath}): boolean;
 
 
 	/**
@@ -14149,6 +14267,12 @@ export class BMPopover extends BMWindow {
 	 */
 	private _clipPathOutlinePath?: DOMNode | null | undefined;
 
+	/**
+	 * When `_clipPathSVG` is defined, this represents the box shadow path element.
+	 *     
+	 */
+	private _clipPathBoxShadowPath?: DOMNode | null | undefined;
+
 	/**
 	 * A string that forms part of the HTML IDs that will be assigned to the clip paths
 	 * to be used on browsers.
@@ -14481,37 +14605,112 @@ export class BMConfirmationPopup extends BMAlertPopup {
 export class BMKeyboardShortcutModifier {
 	/**
 	 * Represents the command key on macOS and iOS, windows key on Windows and meta key on Linux.
-	 *  
+	 *     
 	 */
 	static Command: BMKeyboardShortcutModifier;
 
 	/**
 	 * Represents the option key on macOS and alt on other systems.
-	 *  
+	 *     
 	 */
 	static Option: BMKeyboardShortcutModifier;
 
 	/**
 	 * Represents the shit key.
-	 *  
+	 *     
 	 */
 	static Shift: BMKeyboardShortcutModifier;
 
 	/**
 	 * Represents the control key.
-	 *  
+	 *     
 	 */
 	static Control: BMKeyboardShortcutModifier;
 
 	/**
 	 * Represents the command key on macOS and iOS and control key on other systems.
-	 *  
+	 *     
 	 */
 	static System: BMKeyboardShortcutModifier;
 
 	private constructor(); 
 }
 
+/**
+ * A class whose instances describe sequences of keys on a keyboard that must be
+ * pressed for an action to take place.
+ * 
+ */
+export class BMKeySequence {
+
+	/**
+	 * The key that should be pressed for this keyboard shortcut.
+	 *     
+	 */
+	readonly keyCode: string;
+
+	/**
+	 * An array of keyboard modifiers that must be pressed
+	 * together with the key in order to trigger the shortcut.
+	 *     
+	 */
+	readonly modifiers: BMKeyboardShortcutModifier[];
+
+	/**
+	 * Designated initializer. Initializes this key sequence with the specified key and optional modifiers.
+	 * @param key                                               The key that should be pressed for this key sequence.
+	 *                                                                  This maps to the `code` property of keyboard events.
+	 * @param modifiers 		Defaults to an empty array. An optional array of modifiers
+	 *                                                                  that must be pressed together with the target key.
+	 * @return                                           This key sequence.
+	 *     
+	 */
+	initWithKeyCode(key: string, {modifiers}?: {modifiers?: BMKeyboardShortcutModifier[] | null | undefined}): BMKeySequence;
+
+
+	/**
+	 * Initializes this key sequence with the specified keyboard event, using the event's key code
+	 * and any active modifier keys. If the event includes the control or command keys, these may be converted
+	 * into a system key modifier based on the current platform.
+	 * @param event          The keyboard event from which this key sequence should be initialized.
+	 * @return               This key sequence.
+	 *     
+	 */
+	initWithKeyboardEvent(event: KeyboardEvent): BMKeySequence;
+
+
+	/**
+	 * A string description of this key sequence, intended to be displayed to end-users.
+	 * Its format depends on the current platform.
+	 *     
+	 */
+	readonly HTMLDescription: string;
+
+	/**
+	 * Creates and returns a key sequence initialized with the specified key and optional modifiers.
+	 * @param key                                               The key that should be pressed for this key sequence.
+	 *                                                                  This maps to the `code` property of keyboard events.
+	 * @param modifiers 		Defaults to an empty array. An optional array of modifiers
+	 *                                                                  that must be pressed together with the target key.
+	 * @return                                           This key sequence.
+	 * 
+	 */
+	static keySequenceWithKeyCode (key: string, {modifiers}?: {modifiers?: BMKeyboardShortcutModifier[] | null | undefined}): BMKeySequence;
+
+
+	/**
+	 * Creates and returns a key sequence initialized with the specified keyboard event, using the event's key code
+	 * and any active modifier keys. If the event includes the control or command keys, these may be converted
+	 * into a system key modifier based on the current platform.
+	 * @param event          The keyboard event from which this key sequence should be initialized.
+	 * @return               This key sequence.
+	 * 
+	 */
+	static keySequenceWithKeyboardEvent (event: KeyboardEvent): BMKeySequence;
+
+}
+
+
 /**
  * A keyboard shortcut object describes the keys that must be pressed for a keyboard shortcut to trigger as
  * well as what should happen when that shortcut is triggered.
@@ -14519,6 +14718,12 @@ export class BMKeyboardShortcutModifier {
  */
 export class BMKeyboardShortcut {
 
+	/**
+	 * The key sequence that should be pressed to trigger this keyboard shortcut.
+	 *     
+	 */
+	readonly keySequence: BMKeySequence;
+
 	/**
 	 * The key that should be pressed for this keyboard shortcut.
 	 *     
@@ -14526,7 +14731,7 @@ export class BMKeyboardShortcut {
 	readonly keyCode: string;
 
 	/**
-	 * An optional array of keyboard modifiers that must be pressed
+	 * An array of keyboard modifiers that must be pressed
 	 * together with the key in order to trigger the shortcut.
 	 *     
 	 */
@@ -14559,7 +14764,26 @@ export class BMKeyboardShortcut {
 	preventsDefault: boolean;
 
 	/**
-	 * Designated initializer. Initializes this keyboard shortcut with the given key and optional modifiers, as well as
+	 * Designated Initializer. Initializes this keyboard shortcut with the specified key sequence and the action that the
+	 * keyboard shortcut should trigger.
+	 * @param keySequence                The key sequence describing the keyboard buttons that
+	 *                                                  should be pressed to trigger this keyboard shortcut.
+	 * @param target 						The object that will handle this keyboard shortcut action.
+	 * @param action 							The name of a method on the target object that will be invoked when this 
+	 * 													keyboard shortcut is triggered. That method will receive the following arguments:
+	 * 
+	 *  - `event`: {@link KeyboardEvent} The keyboard event that triggered the keyboard shortcut
+	 *  - `{forKeyboardShortcut}`: {@link BMKeyboardShortcut} The associated keyboard shortcut
+	 * @param preventsDefault       Defaults to `NO`. When set to `YES`, the default action of the event that triggers
+	 *                                                  normally as a result of the key sequence will be prevented.
+	 * @return                      This keyboard shortcut.
+	 *     
+	 */
+	initWithKeySequence(keySequence: BMKeySequence, {target, action, preventsDefault}: {target: any, action: string, preventsDefault?: boolean | null | undefined}): BMKeyboardShortcut;
+
+
+	/**
+	 * Initializes this keyboard shortcut with the given key and optional modifiers, as well as
 	 * the target and action that will handle it.
 	 * 
 	 * In order to be triggered, this keyboard shortcut must be registered with an event handler such as a window
@@ -14567,10 +14791,14 @@ export class BMKeyboardShortcut {
 	 * @param key                                               The key that should be pressed for this keyboard shortcut. This maps to the `code` property of keyboard events.
 	 * @param modifiers 		Defaults to an empty array. An optional array of keyboard modifiers that must be active.
 	 * 																	for the keyboard shortcut to fire.
-	 * @param target 										The object that will handle this keyboard shortcut action.
-	 * @param action 											The name of a method on the target object that will be invoked when this 
-	 * 																	keyboard shortcut is triggered. That method will receive the keyboard event as its single parameter.
-	 * @param preventsDefault                       Defaults to `NO`. When set to `YES`, the default action of the event that triggers this keyboard shortcut will be prevented.
+	 * @param target 						                The object that will handle this keyboard shortcut action.
+	 * @param action 							                The name of a method on the target object that will be invoked when this 
+	 * 													                keyboard shortcut is triggered. That method will receive the following arguments:
+	 * 
+	 *  - `event`: {@link KeyboardEvent} The keyboard event that triggered the keyboard shortcut
+	 *  - `{forKeyboardShortcut}`: {@link BMKeyboardShortcut} The associated keyboard shortcut
+	 * @param preventsDefault                       Defaults to `NO`. When set to `YES`, the default action of the event that triggers
+	 *                                                                  normally as a result of the key sequence will be prevented.
 	 * @return                                      This keyboard shortcut.
 	 *     
 	 */
@@ -14580,15 +14808,19 @@ export class BMKeyboardShortcut {
 	/**
 	 * Initializes this keyboard shortcut with the given keyboard event. If the event includes the control or command keys, these may be converted
 	 * into a system key modifier based on the current platform.
-	 * @param event                                      The keyboard event from which this keyboard shortcut should be initialized.
-	 * @param target 										The object that will handle this keyboard shortcut action.
-	 * @param action 											The name of a method on the target object that will be invoked when this 
-	 * 																	keyboard shortcut is triggered. That method will receive the keyboard event as its single parameter.
-	 * @param preventsDefault                       Defaults to `NO`. When set to `YES`, the default action of the event that triggers this keyboard shortcut will be prevented.
-	 * 
+	 * @param event                      The keyboard event from which this keyboard shortcut should be initialized.
+	 * @param target 						The object that will handle this keyboard shortcut action.
+	 * @param action 							The name of a method on the target object that will be invoked when this 
+	 * 													keyboard shortcut is triggered. That method will receive the following arguments:
+	 * 
+	 *  - `event`: {@link KeyboardEvent} The keyboard event that triggered the keyboard shortcut
+	 *  - `{forKeyboardShortcut}`: {@link BMKeyboardShortcut} The associated keyboard shortcut
+	 * @param preventsDefault       Defaults to `NO`. When set to `YES`, the default action of the event that triggers
+	 *                                                  normally as a result of the key sequence will be prevented.
+	 * @return                                      This keyboard shortcut.
 	 *     
 	 */
-	initWithKeyboardEvent(event: KeyboardEvent, {target, action, preventsDefault}: {target: any, action: string, preventsDefault?: boolean | null | undefined}): void;
+	initWithKeyboardEvent(event: KeyboardEvent, {target, action, preventsDefault}: {target: any, action: string, preventsDefault?: boolean | null | undefined}): BMKeyboardShortcut;
 
 
 	/**
@@ -14597,10 +14829,10 @@ export class BMKeyboardShortcut {
 	 * @param shortcut                  A serialized keyboard shortcut.
 	 * @param targetID       A callback that is invoked with the target ID and should return
 	 *                                          the target object which will handle the keyboard shortcut.
-	 * @return                         This keyboard shortcut.
+	 * @return             This keyboard shortcut.
 	 *     
 	 */
-	initWithSerializedKeyboardShortcut(shortcut: any, {targetID}: {targetID: (($0: string) => any)}): any;
+	initWithSerializedKeyboardShortcut(shortcut: any, {targetID}: {targetID: (($0: string) => any)}): BMKeyboardShortcut;
 
 
 	/**
@@ -14614,6 +14846,25 @@ export class BMKeyboardShortcut {
 	serializedKeyboardShortcutWithTargetID(ID: string): any;
 
 
+	/**
+	 * Constructs and returns a keyboard shortcut with the specified key sequence and action that will be triggered
+	 * by the keyboard shortcut.
+	 * @param keySequence                    The key sequence describing the keys that should be pressed to
+	 *                                                      trigger this shortcut.s
+	 * @param target 						    The object that will handle this keyboard shortcut action.
+	 * @param action 							    The name of a method on the target object that will be invoked when this 
+	 * 													    keyboard shortcut is triggered. That method will receive the following arguments:
+	 * 
+	 *  - `event`: {@link KeyboardEvent} The keyboard event that triggered the keyboard shortcut
+	 *  - `{forKeyboardShortcut}`: {@link BMKeyboardShortcut} The associated keyboard shortcut
+	 * @param preventsDefault           Defaults to `NO`. When set to `YES`, the default action of the event that triggers
+	 *                                                      normally as a result of the key sequence will be prevented.
+	 * @return                          A keyboard shortcut.
+	 * 
+	 */
+	static keyboardShortcutWithKeySequence (keySequence: BMKeySequence, {target, action, preventsDefault}: {target: any, action: string, preventsDefault?: boolean | null | undefined}): BMKeyboardShortcut;
+
+
 	/**
 	 * Constructs and returns a keyboard shortcut with the given key and optional modifiers, as well as
 	 * the target and action that will handle it.
@@ -14623,10 +14874,14 @@ export class BMKeyboardShortcut {
 	 * @param key                                               The key that should be pressed for this keyboard shortcut. This maps to the `code` property of keyboard events.
 	 * @param modifiers 		Defaults to an empty array. An optional array of keyboard modifiers that must be active.
 	 * 																	for the keyboard shortcut to fire.
-	 * @param target 										The object that will handle this keyboard shortcut action.
-	 * @param action 											The name of a method on the target object that will be invoked when this 
-	 * 																	keyboard shortcut is triggered. That method will receive the keyboard event as its single parameter.
-	 * @param preventsDefault                       Defaults to `NO`. When set to `YES`, the default action of the event that triggers this keyboard shortcut will be prevented.
+	 * @param target 						                The object that will handle this keyboard shortcut action.
+	 * @param action 							                The name of a method on the target object that will be invoked when this 
+	 * 													                keyboard shortcut is triggered. That method will receive the following arguments:
+	 * 
+	 *  - `event`: {@link KeyboardEvent} The keyboard event that triggered the keyboard shortcut
+	 *  - `{forKeyboardShortcut}`: {@link BMKeyboardShortcut} The associated keyboard shortcut
+	 * @param preventsDefault                       Defaults to `NO`. When set to `YES`, the default action of the event that triggers
+	 *                                                                  normally as a result of the key sequence will be prevented.
 	 * @return                                      A keyboard shortcut.
 	 * 
 	 */
@@ -14636,15 +14891,19 @@ export class BMKeyboardShortcut {
 	/**
 	 * Constructs and returns a keyboard shortcut with the given keyboard event. If the event includes the control or command keys, these may be converted
 	 * into a system key modifier based on the current platform.
-	 * @param event                                      The keyboard event from which this keyboard shortcut should be initialized.
-	 * @param target 										The object that will handle this keyboard shortcut action.
-	 * @param action 											The name of a method on the target object that will be invoked when this 
-	 * 																	keyboard shortcut is triggered. That method will receive the keyboard event as its single parameter.
-	 * @param preventsDefault                       Defaults to `NO`. When set to `YES`, the default action of the event that triggers this keyboard shortcut will be prevented.
+	 * @param event                          The keyboard event from which this keyboard shortcut should be initialized.
+	 * @param target 						    The object that will handle this keyboard shortcut action.
+	 * @param action 							    The name of a method on the target object that will be invoked when this 
+	 * 													    keyboard shortcut is triggered. That method will receive the following arguments:
 	 * 
+	 *  - `event`: {@link KeyboardEvent} The keyboard event that triggered the keyboard shortcut
+	 *  - `{forKeyboardShortcut}`: {@link BMKeyboardShortcut} The associated keyboard shortcut
+	 * @param preventsDefault           Defaults to `NO`. When set to `YES`, the default action of the event that triggers
+	 *                                                      normally as a result of the key sequence will be prevented.
+	 * @return                          A keyboard shortcut.
 	 * 
 	 */
-	static keyboardShortcutWithKeyboardEvent (event: KeyboardEvent, {target, action, preventsDefault}: {target: any, action: string, preventsDefault?: boolean | null | undefined}): void;
+	static keyboardShortcutWithKeyboardEvent (event: KeyboardEvent, {target, action, preventsDefault}: {target: any, action: string, preventsDefault?: boolean | null | undefined}): BMKeyboardShortcut;
 
 
 	/**
@@ -14653,10 +14912,10 @@ export class BMKeyboardShortcut {
 	 * @param shortcut                  A serialized keyboard shortcut.
 	 * @param targetID       A callback that is invoked with the target ID and should return
 	 *                                          the target object which will handle the keyboard shortcut.
-	 * @return                         A keyboard shortcut.
+	 * @return   A keyboard shortcut.
 	 * 
 	 */
-	static keyboardShortcutWithSerializedKeyboardShortcut (shortcut: any, {targetID}: {targetID: (($0: string) => any)}): any;
+	static keyboardShortcutWithSerializedKeyboardShortcut (shortcut: any, {targetID}: {targetID: (($0: string) => any)}): BMKeyboardShortcut | null | undefined;
 
 }