blockly 12.0.0-beta.4 → 12.0.0-beta.6

package/core/interfaces/i_focusable_node.d.ts

@@ -17,21 +17,84 @@ export interface IFocusableNode {
      * - blocklyActiveFocus
      * - blocklyPassiveFocus
      *
-     * The returned element must also have a valid ID specified, and unique to the
-     * element relative to its nearest IFocusableTree parent. It must also have a
-     * negative tabindex (since the focus manager itself will manage its tab index
-     * and a tab index must be present in order for the element to be focusable in
-     * the DOM).
-     *
-     * It's expected the return element will not change for the lifetime of the
-     * node.
+     * The returned element must also have a valid ID specified, and unique across
+     * the entire page. Failing to have a properly unique ID could result in
+     * trying to focus one node (such as via a mouse click) leading to another
+     * node with the same ID actually becoming focused by FocusManager. The
+     * returned element must also have a negative tabindex (since the focus
+     * manager itself will manage its tab index and a tab index must be present in
+     * order for the element to be focusable in the DOM).
+     *
+     * The returned element must be visible if the node is ever focused via
+     * FocusManager.focusNode() or FocusManager.focusTree(). It's allowed for an
+     * element to be hidden until onNodeFocus() is called, or become hidden with a
+     * call to onNodeBlur().
+     *
+     * It's expected the actual returned element will not change for the lifetime
+     * of the node (that is, its properties can change but a new element should
+     * never be returned).
+     *
+     * @returns The HTMLElement or SVGElement which can both receive focus and be
+     *     visually represented as actively or passively focused for this node.
      */
     getFocusableElement(): HTMLElement | SVGElement;
     /**
      * Returns the closest parent tree of this node (in cases where a tree has
      * distinct trees underneath it), which represents the tree to which this node
      * belongs.
+     *
+     * @returns The node's IFocusableTree.
      */
     getFocusableTree(): IFocusableTree;
+    /**
+     * Called when this node receives active focus.
+     *
+     * Note that it's fine for implementations to change visibility modifiers, but
+     * they should avoid the following:
+     * - Creating or removing DOM elements (including via the renderer or drawer).
+     * - Affecting focus via DOM focus() calls or the FocusManager.
+     */
+    onNodeFocus(): void;
+    /**
+     * Called when this node loses active focus. It may still have passive focus.
+     *
+     * This has the same implementation restrictions as onNodeFocus().
+     */
+    onNodeBlur(): void;
+    /**
+     * Indicates whether this node allows focus. If this returns false then none
+     * of the other IFocusableNode methods will be called.
+     *
+     * Note that special care must be taken if implementations of this function
+     * dynamically change their return value value over the lifetime of the node
+     * as certain environment conditions could affect the focusability of this
+     * node's DOM element (such as whether the element has a positive or zero
+     * tabindex). Also, changing from a true to a false value while the node holds
+     * focus will not immediately change the current focus of the node nor
+     * FocusManager's internal state, and thus may result in some of the node's
+     * functions being called later on when defocused (since it was previously
+     * considered focusable at the time of being focused).
+     *
+     * Implementations should generally always return true here unless there are
+     * circumstances under which this node should be skipped for focus
+     * considerations. Examples may include being disabled, read-only, a purely
+     * visual decoration, or a node with no visual representation that must
+     * implement this interface (e.g. due to a parent interface extending it).
+     * Keep in mind accessibility best practices when determining whether a node
+     * should be focusable since even disabled and read-only elements are still
+     * often relevant to providing organizational context to users (particularly
+     * when using a screen reader).
+     *
+     * @returns Whether this node can be focused by FocusManager.
+     */
+    canBeFocused(): boolean;
 }
+/**
+ * Determines whether the provided object fulfills the contract of
+ * IFocusableNode.
+ *
+ * @param object The object to test.
+ * @returns Whether the provided object can be used as an IFocusableNode.
+ */
+export declare function isFocusableNode(object: any | null): object is IFocusableNode;
 //# sourceMappingURL=i_focusable_node.d.ts.map

package/core/interfaces/i_focusable_tree.d.ts

@@ -34,6 +34,35 @@ export interface IFocusableTree {
      * currently have a focused node.
      */
     getRootFocusableNode(): IFocusableNode;
+    /**
+     * Returns the IFocusableNode of this tree that should receive active focus
+     * when the tree itself has focus returned to it.
+     *
+     * There are some very important notes to consider about a tree's focus
+     * lifecycle when implementing a version of this method that doesn't return
+     * null:
+     * 1. A null previousNode does not guarantee first-time focus state as nodes
+     *    can be deleted.
+     * 2. This method is only used when the tree itself is focused, either through
+     *    tab navigation or via FocusManager.focusTree(). In many cases, the
+     *    previously focused node will be directly focused instead which will
+     *    bypass this method.
+     * 3. The default behavior (i.e. returning null here) involves either
+     *    restoring the previous node (previousNode) or focusing the tree's root.
+     * 4. The provided node may sometimes no longer be valid, such as in the case
+     *    an attempt is made to focus a node that has been recently removed from
+     *    its parent tree. Implementations can check for the validity of the node
+     *    in order to specialize the node to which focus should fall back.
+     *
+     * This method is largely intended to provide tree implementations with the
+     * means of specifying a better default node than their root.
+     *
+     * @param previousNode The node that previously held passive focus for this
+     *     tree, or null if the tree hasn't yet been focused.
+     * @returns The IFocusableNode that should now receive focus, or null if
+     *     default behavior should be used, instead.
+     */
+    getRestoredFocusableNode(previousNode: IFocusableNode | null): IFocusableNode | null;
     /**
      * Returns all directly nested trees under this tree.
      *
@@ -54,5 +83,43 @@ export interface IFocusableTree {
      * @param id The ID of the node's focusable HTMLElement or SVGElement.
      */
     lookUpFocusableNode(id: string): IFocusableNode | null;
+    /**
+     * Called when a node of this tree has received active focus.
+     *
+     * Note that a null previousTree does not necessarily indicate that this is
+     * the first time Blockly is receiving focus. In fact, few assumptions can be
+     * made about previous focus state as a previous null tree simply indicates
+     * that Blockly did not hold active focus prior to this tree becoming focused
+     * (which can happen due to focus exiting the Blockly injection div, or for
+     * other cases like ephemeral focus).
+     *
+     * See IFocusableNode.onNodeFocus() as implementations have the same
+     * restrictions as with that method.
+     *
+     * @param node The node receiving active focus.
+     * @param previousTree The previous tree that held active focus, or null if
+     *     none.
+     */
+    onTreeFocus(node: IFocusableNode, previousTree: IFocusableTree | null): void;
+    /**
+     * Called when the previously actively focused node of this tree is now
+     * passively focused and there is no other active node of this tree taking its
+     * place.
+     *
+     * This has the same implementation restrictions and considerations as
+     * onTreeFocus().
+     *
+     * @param nextTree The next tree receiving active focus, or null if none (such
+     *     as in the case that Blockly is entirely losing DOM focus).
+     */
+    onTreeBlur(nextTree: IFocusableTree | null): void;
 }
+/**
+ * Determines whether the provided object fulfills the contract of
+ * IFocusableTree.
+ *
+ * @param object The object to test.
+ * @returns Whether the provided object can be used as an IFocusableTree.
+ */
+export declare function isFocusableTree(object: any | null): object is IFocusableTree;
 //# sourceMappingURL=i_focusable_tree.d.ts.map

package/core/interfaces/i_has_bubble.d.ts

@@ -3,11 +3,24 @@
  * Copyright 2023 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import type { IBubble } from './i_bubble';
 export interface IHasBubble {
     /** @returns True if the bubble is currently open, false otherwise. */
     bubbleIsVisible(): boolean;
     /** Sets whether the bubble is open or not. */
     setBubbleVisible(visible: boolean): Promise<void>;
+    /**
+     * Returns the current IBubble that implementations are managing, or null if
+     * there isn't one.
+     *
+     * Note that this cannot be expected to return null if bubbleIsVisible()
+     * returns false, i.e., the nullability of the returned bubble does not
+     * necessarily imply visibility.
+     *
+     * @returns The current IBubble maintained by implementations, or null if
+     *     there is not one.
+     */
+    getBubble(): IBubble | null;
 }
 /** Type guard that checks whether the given object is a IHasBubble. */
 export declare function hasBubble(obj: any): obj is IHasBubble;

package/core/interfaces/i_icon.d.ts

@@ -6,7 +6,8 @@
 import type { IconType } from '../icons/icon_types.js';
 import type { Coordinate } from '../utils/coordinate.js';
 import type { Size } from '../utils/size.js';
-export interface IIcon {
+import { IFocusableNode } from './i_focusable_node.js';
+export interface IIcon extends IFocusableNode {
     /**
      * @returns the IconType representing the type of the icon. This value should
      *     also be used to register the icon via `Blockly.icons.registry.register`.

package/core/interfaces/i_navigation_policy.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IFocusableNode } from './i_focusable_node.js';
+/**
+ * A set of rules that specify where keyboard navigation should proceed.
+ */
+export interface INavigationPolicy<T> {
+    /**
+     * Returns the first child element of the given element, if any.
+     *
+     * @param current The element which the user is navigating into.
+     * @returns The current element's first child, or null if it has none.
+     */
+    getFirstChild(current: T): IFocusableNode | null;
+    /**
+     * Returns the parent element of the given element, if any.
+     *
+     * @param current The element which the user is navigating out of.
+     * @returns The parent element of the current element, or null if it has none.
+     */
+    getParent(current: T): IFocusableNode | null;
+    /**
+     * Returns the peer element following the given element, if any.
+     *
+     * @param current The element which the user is navigating past.
+     * @returns The next peer element of the current element, or null if there is
+     *     none.
+     */
+    getNextSibling(current: T): IFocusableNode | null;
+    /**
+     * Returns the peer element preceding the given element, if any.
+     *
+     * @param current The element which the user is navigating past.
+     * @returns The previous peer element of the current element, or null if
+     *     there is none.
+     */
+    getPreviousSibling(current: T): IFocusableNode | null;
+    /**
+     * Returns whether or not the given instance should be reachable via keyboard
+     * navigation.
+     *
+     * Implementors should generally return true, unless there are circumstances
+     * under which this item should be skipped while using keyboard navigation.
+     * Common examples might include being disabled, invalid, readonly, or purely
+     * a visual decoration. For example, while Fields are navigable, non-editable
+     * fields return false, since they cannot be interacted with when focused.
+     *
+     * @returns True if this element should be included in keyboard navigation.
+     */
+    isNavigable(current: T): boolean;
+    /**
+     * Returns whether or not this navigation policy corresponds to the type of
+     * the given object.
+     *
+     * @param current An instance to check whether this policy applies to.
+     * @returns True if the given object is of a type handled by this policy.
+     */
+    isApplicable(current: any): current is T;
+}
+//# sourceMappingURL=i_navigation_policy.d.ts.map

package/core/interfaces/i_selectable.d.ts

@@ -4,10 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { Workspace } from '../workspace.js';
+import { IFocusableNode } from './i_focusable_node.js';
 /**
  * The interface for an object that is selectable.
+ *
+ * Implementations are generally expected to use their implementations of
+ * onNodeFocus() and onNodeBlur() to call setSelected() with themselves and
+ * null, respectively, in order to ensure that selections are correctly updated
+ * and the selection change event is fired.
  */
-export interface ISelectable {
+export interface ISelectable extends IFocusableNode {
     id: string;
     workspace: Workspace;
     /** Select this.  Highlight it visually. */

package/core/interfaces/i_toolbox.d.ts

@@ -6,12 +6,13 @@
 import type { ToolboxInfo } from '../utils/toolbox.js';
 import type { WorkspaceSvg } from '../workspace_svg.js';
 import type { IFlyout } from './i_flyout.js';
+import type { IFocusableTree } from './i_focusable_tree.js';
 import type { IRegistrable } from './i_registrable.js';
 import type { IToolboxItem } from './i_toolbox_item.js';
 /**
  * Interface for a toolbox.
  */
-export interface IToolbox extends IRegistrable {
+export interface IToolbox extends IRegistrable, IFocusableTree {
     /** Initializes the toolbox. */
     init(): void;
     /**

package/core/interfaces/i_toolbox_item.d.ts

@@ -3,10 +3,11 @@
  * Copyright 2020 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import type { IFocusableNode } from './i_focusable_node.js';
 /**
  * Interface for an item in the toolbox.
  */
-export interface IToolboxItem {
+export interface IToolboxItem extends IFocusableNode {
     /**
      * Initializes the toolbox item.
      * This includes creating the DOM and updating the state of any items based

package/core/keyboard_nav/block_navigation_policy.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BlockSvg } from '../block_svg.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
+/**
+ * Set of rules controlling keyboard navigation from a block.
+ */
+export declare class BlockNavigationPolicy implements INavigationPolicy<BlockSvg> {
+    /**
+     * Returns the first child of the given block.
+     *
+     * @param current The block to return the first child of.
+     * @returns The first field or input of the given block, if any.
+     */
+    getFirstChild(current: BlockSvg): IFocusableNode | null;
+    /**
+     * Returns the parent of the given block.
+     *
+     * @param current The block to return the parent of.
+     * @returns The top block of the given block's stack, or the connection to
+     *     which it is attached.
+     */
+    getParent(current: BlockSvg): IFocusableNode | null;
+    /**
+     * Returns the next peer node of the given block.
+     *
+     * @param current The block to find the following element of.
+     * @returns The first block of the next stack if the given block is a terminal
+     *     block, or its next connection.
+     */
+    getNextSibling(current: BlockSvg): IFocusableNode | null;
+    /**
+     * Returns the previous peer node of the given block.
+     *
+     * @param current The block to find the preceding element of.
+     * @returns The block's previous/output connection, or the last
+     *     connection/block of the previous block stack if it is a root block.
+     */
+    getPreviousSibling(current: BlockSvg): IFocusableNode | null;
+    /**
+     * Returns whether or not the given block can be navigated to.
+     *
+     * @param current The instance to check for navigability.
+     * @returns True if the given block can be focused.
+     */
+    isNavigable(current: BlockSvg): boolean;
+    /**
+     * Returns whether the given object can be navigated from by this policy.
+     *
+     * @param current The object to check if this policy applies to.
+     * @returns True if the object is a BlockSvg.
+     */
+    isApplicable(current: any): current is BlockSvg;
+}
+//# sourceMappingURL=block_navigation_policy.d.ts.map

package/core/keyboard_nav/connection_navigation_policy.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { BlockSvg } from '../block_svg.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
+import { RenderedConnection } from '../rendered_connection.js';
+/**
+ * Set of rules controlling keyboard navigation from a connection.
+ */
+export declare class ConnectionNavigationPolicy implements INavigationPolicy<RenderedConnection> {
+    /**
+     * Returns the first child of the given connection.
+     *
+     * @param current The connection to return the first child of.
+     * @returns The connection's first child element, or null if not none.
+     */
+    getFirstChild(current: RenderedConnection): IFocusableNode | null;
+    /**
+     * Returns the parent of the given connection.
+     *
+     * @param current The connection to return the parent of.
+     * @returns The given connection's parent connection or block.
+     */
+    getParent(current: RenderedConnection): IFocusableNode | null;
+    /**
+     * Returns the next element following the given connection.
+     *
+     * @param current The connection to navigate from.
+     * @returns The field, input connection or block following this connection.
+     */
+    getNextSibling(current: RenderedConnection): IFocusableNode | null;
+    /**
+     * Returns the element preceding the given connection.
+     *
+     * @param current The connection to navigate from.
+     * @returns The field, input connection or block preceding this connection.
+     */
+    getPreviousSibling(current: RenderedConnection): IFocusableNode | null;
+    /**
+     * Gets the parent connection on a block.
+     * This is either an output connection, previous connection or undefined.
+     * If both connections exist return the one that is actually connected
+     * to another block.
+     *
+     * @param block The block to find the parent connection on.
+     * @returns The connection connecting to the parent of the block.
+     */
+    protected getParentConnection(block: BlockSvg): RenderedConnection;
+    /**
+     * Returns whether or not the given connection can be navigated to.
+     *
+     * @param current The instance to check for navigability.
+     * @returns True if the given connection can be focused.
+     */
+    isNavigable(current: RenderedConnection): boolean;
+    /**
+     * Returns whether the given object can be navigated from by this policy.
+     *
+     * @param current The object to check if this policy applies to.
+     * @returns True if the object is a RenderedConnection.
+     */
+    isApplicable(current: any): current is RenderedConnection;
+}
+//# sourceMappingURL=connection_navigation_policy.d.ts.map

package/core/keyboard_nav/field_navigation_policy.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Field } from '../field.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
+/**
+ * Set of rules controlling keyboard navigation from a field.
+ */
+export declare class FieldNavigationPolicy implements INavigationPolicy<Field<any>> {
+    /**
+     * Returns null since fields do not have children.
+     *
+     * @param _current The field to navigate from.
+     * @returns Null.
+     */
+    getFirstChild(_current: Field<any>): IFocusableNode | null;
+    /**
+     * Returns the parent block of the given field.
+     *
+     * @param current The field to navigate from.
+     * @returns The given field's parent block.
+     */
+    getParent(current: Field<any>): IFocusableNode | null;
+    /**
+     * Returns the next field or input following the given field.
+     *
+     * @param current The field to navigate from.
+     * @returns The next field or input in the given field's block.
+     */
+    getNextSibling(current: Field<any>): IFocusableNode | null;
+    /**
+     * Returns the field or input preceding the given field.
+     *
+     * @param current The field to navigate from.
+     * @returns The preceding field or input in the given field's block.
+     */
+    getPreviousSibling(current: Field<any>): IFocusableNode | null;
+    /**
+     * Returns whether or not the given field can be navigated to.
+     *
+     * @param current The instance to check for navigability.
+     * @returns True if the given field can be focused and navigated to.
+     */
+    isNavigable(current: Field<any>): boolean;
+    /**
+     * Returns whether the given object can be navigated from by this policy.
+     *
+     * @param current The object to check if this policy applies to.
+     * @returns True if the object is a Field.
+     */
+    isApplicable(current: any): current is Field;
+}
+//# sourceMappingURL=field_navigation_policy.d.ts.map

package/core/keyboard_nav/flyout_button_navigation_policy.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FlyoutButton } from '../flyout_button.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
+/**
+ * Set of rules controlling keyboard navigation from a flyout button.
+ */
+export declare class FlyoutButtonNavigationPolicy implements INavigationPolicy<FlyoutButton> {
+    /**
+     * Returns null since flyout buttons have no children.
+     *
+     * @param _current The FlyoutButton instance to navigate from.
+     * @returns Null.
+     */
+    getFirstChild(_current: FlyoutButton): IFocusableNode | null;
+    /**
+     * Returns the parent workspace of the given flyout button.
+     *
+     * @param current The FlyoutButton instance to navigate from.
+     * @returns The given flyout button's parent workspace.
+     */
+    getParent(current: FlyoutButton): IFocusableNode | null;
+    /**
+     * Returns null since inter-item navigation is done by FlyoutNavigationPolicy.
+     *
+     * @param _current The FlyoutButton instance to navigate from.
+     * @returns Null.
+     */
+    getNextSibling(_current: FlyoutButton): IFocusableNode | null;
+    /**
+     * Returns null since inter-item navigation is done by FlyoutNavigationPolicy.
+     *
+     * @param _current The FlyoutButton instance to navigate from.
+     * @returns Null.
+     */
+    getPreviousSibling(_current: FlyoutButton): IFocusableNode | null;
+    /**
+     * Returns whether or not the given flyout button can be navigated to.
+     *
+     * @param current The instance to check for navigability.
+     * @returns True if the given flyout button can be focused.
+     */
+    isNavigable(current: FlyoutButton): boolean;
+    /**
+     * Returns whether the given object can be navigated from by this policy.
+     *
+     * @param current The object to check if this policy applies to.
+     * @returns True if the object is a FlyoutButton.
+     */
+    isApplicable(current: any): current is FlyoutButton;
+}
+//# sourceMappingURL=flyout_button_navigation_policy.d.ts.map

package/core/keyboard_nav/flyout_navigation_policy.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IFlyout } from '../interfaces/i_flyout.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
+/**
+ * Generic navigation policy that navigates between items in the flyout.
+ */
+export declare class FlyoutNavigationPolicy<T> implements INavigationPolicy<T> {
+    private policy;
+    private flyout;
+    /**
+     * Creates a new FlyoutNavigationPolicy instance.
+     *
+     * @param policy The policy to defer to for parents/children.
+     * @param flyout The flyout this policy will control navigation in.
+     */
+    constructor(policy: INavigationPolicy<T>, flyout: IFlyout);
+    /**
+     * Returns null to prevent navigating into flyout items.
+     *
+     * @param _current The flyout item to navigate from.
+     * @returns Null to prevent navigating into flyout items.
+     */
+    getFirstChild(_current: T): IFocusableNode | null;
+    /**
+     * Returns the parent of the given flyout item.
+     *
+     * @param current The flyout item to navigate from.
+     * @returns The parent of the given flyout item.
+     */
+    getParent(current: T): IFocusableNode | null;
+    /**
+     * Returns the next item in the flyout relative to the given item.
+     *
+     * @param current The flyout item to navigate from.
+     * @returns The flyout item following the given one.
+     */
+    getNextSibling(current: T): IFocusableNode | null;
+    /**
+     * Returns the previous item in the flyout relative to the given item.
+     *
+     * @param current The flyout item to navigate from.
+     * @returns The flyout item preceding the given one.
+     */
+    getPreviousSibling(current: T): IFocusableNode | null;
+    /**
+     * Returns whether or not the given flyout item can be navigated to.
+     *
+     * @param current The instance to check for navigability.
+     * @returns True if the given flyout item can be focused.
+     */
+    isNavigable(current: T): boolean;
+    /**
+     * Returns whether the given object can be navigated from by this policy.
+     *
+     * @param current The object to check if this policy applies to.
+     * @returns True if the object is a BlockSvg.
+     */
+    isApplicable(current: any): current is T;
+}
+//# sourceMappingURL=flyout_navigation_policy.d.ts.map

package/core/keyboard_nav/flyout_separator_navigation_policy.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FlyoutSeparator } from '../flyout_separator.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
+/**
+ * Set of rules controlling keyboard navigation from a flyout separator.
+ * This is a no-op placeholder, since flyout separators can't be navigated to.
+ */
+export declare class FlyoutSeparatorNavigationPolicy implements INavigationPolicy<FlyoutSeparator> {
+    getFirstChild(_current: FlyoutSeparator): IFocusableNode | null;
+    getParent(_current: FlyoutSeparator): IFocusableNode | null;
+    getNextSibling(_current: FlyoutSeparator): IFocusableNode | null;
+    getPreviousSibling(_current: FlyoutSeparator): IFocusableNode | null;
+    /**
+     * Returns whether or not the given flyout separator can be navigated to.
+     *
+     * @param _current The instance to check for navigability.
+     * @returns False.
+     */
+    isNavigable(_current: FlyoutSeparator): boolean;
+    /**
+     * Returns whether the given object can be navigated from by this policy.
+     *
+     * @param current The object to check if this policy applies to.
+     * @returns True if the object is a FlyoutSeparator.
+     */
+    isApplicable(current: any): current is FlyoutSeparator;
+}
+//# sourceMappingURL=flyout_separator_navigation_policy.d.ts.map