blockly 12.0.0-beta.5 → 12.0.0-beta.7

package/core/field_textinput.d.ts

@@ -48,15 +48,6 @@ export declare class FieldTextInput extends FieldInput<string> {
      * @internal
      */
     static fromJson(options: FieldTextInputFromJsonConfig): FieldTextInput;
-    /**
-     * Returns this field's class.
-     *
-     * Used by keyboard navigation to look up the rules for navigating from this
-     * field.
-     *
-     * @returns This field's class.
-     */
-    getClass(): typeof FieldTextInput;
 }
 /**
  *  Config options for the text input field.

package/core/field_variable.d.ts

@@ -15,7 +15,6 @@ import { FieldDropdown, FieldDropdownValidator, MenuGenerator, MenuOption } from
 import { IVariableModel, IVariableState } from './interfaces/i_variable_model.js';
 import type { Menu } from './menu.js';
 import type { MenuItem } from './menuitem.js';
-import { Size } from './utils/size.js';
 /**
  * Class for a variable's dropdown field.
  */
@@ -29,7 +28,6 @@ export declare class FieldVariable extends FieldDropdown {
      * dropdown.
      */
     variableTypes: string[] | null;
-    protected size_: Size;
     /** The variable model associated with this field. */
     private variable;
     /**

package/core/flyout_base.d.ts

@@ -15,7 +15,7 @@ import { IAutoHideable } from './interfaces/i_autohideable.js';
 import type { IFlyout } from './interfaces/i_flyout.js';
 import type { IFlyoutInflater } from './interfaces/i_flyout_inflater.js';
 import { IFocusableNode } from './interfaces/i_focusable_node.js';
-import { IFocusableTree } from './interfaces/i_focusable_tree.js';
+import type { IFocusableTree } from './interfaces/i_focusable_tree.js';
 import type { Options } from './options.js';
 import * as blocks from './serialization/blocks.js';
 import { Coordinate } from './utils/coordinate.js';
@@ -409,6 +409,8 @@ export declare abstract class Flyout extends DeleteArea implements IAutoHideable
     onNodeFocus(): void;
     /** See IFocusableNode.onNodeBlur. */
     onNodeBlur(): void;
+    /** See IFocusableNode.canBeFocused. */
+    canBeFocused(): boolean;
     /** See IFocusableTree.getRootFocusableNode. */
     getRootFocusableNode(): IFocusableNode;
     /** See IFocusableTree.getRestoredFocusableNode. */

package/core/flyout_button.d.ts

@@ -3,16 +3,9 @@
  * Copyright 2016 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * Class for a button in the flyout.
- *
- * @class
- */
-import type { IASTNodeLocationSvg } from './blockly.js';
 import type { IBoundedElement } from './interfaces/i_bounded_element.js';
 import type { IFocusableNode } from './interfaces/i_focusable_node.js';
 import type { IFocusableTree } from './interfaces/i_focusable_tree.js';
-import type { INavigable } from './interfaces/i_navigable.js';
 import type { IRenderedElement } from './interfaces/i_rendered_element.js';
 import { Coordinate } from './utils/coordinate.js';
 import { Rect } from './utils/rect.js';
@@ -21,7 +14,7 @@ import type { WorkspaceSvg } from './workspace_svg.js';
 /**
  * Class for a button or label in the flyout.
  */
-export declare class FlyoutButton implements IASTNodeLocationSvg, IBoundedElement, IRenderedElement, IFocusableNode, INavigable<FlyoutButton> {
+export declare class FlyoutButton implements IBoundedElement, IRenderedElement, IFocusableNode {
     private readonly workspace;
     private readonly targetWorkspace;
     private readonly isFlyoutLabel;
@@ -140,21 +133,7 @@ export declare class FlyoutButton implements IASTNodeLocationSvg, IBoundedElemen
     onNodeFocus(): void;
     /** See IFocusableNode.onNodeBlur. */
     onNodeBlur(): void;
-    /**
-     * Returns whether or not this button is accessible through keyboard
-     * navigation.
-     *
-     * @returns True if this button is keyboard accessible, otherwise false.
-     */
-    isNavigable(): boolean;
-    /**
-     * Returns this button's class.
-     *
-     * Used by keyboard navigation to look up the rules for navigating from this
-     * button.
-     *
-     * @returns This button's class.
-     */
-    getClass(): typeof FlyoutButton;
+    /** See IFocusableNode.canBeFocused. */
+    canBeFocused(): boolean;
 }
 //# sourceMappingURL=flyout_button.d.ts.map

package/core/flyout_item.d.ts

@@ -1,5 +1,5 @@
 import type { IBoundedElement } from './interfaces/i_bounded_element.js';
-import type { INavigable } from './interfaces/i_navigable.js';
+import type { IFocusableNode } from './interfaces/i_focusable_node.js';
 /**
  * Representation of an item displayed in a flyout.
  */
@@ -13,11 +13,11 @@ export declare class FlyoutItem {
      * @param type The type of element. Should correspond to the type of the
      *     flyout inflater that created this object.
      */
-    constructor(element: IBoundedElement & INavigable<any>, type: string);
+    constructor(element: IBoundedElement & IFocusableNode, type: string);
     /**
      * Returns the element displayed in the flyout.
      */
-    getElement(): IBoundedElement & INavigable<any>;
+    getElement(): IBoundedElement & IFocusableNode;
     /**
      * Returns the type of flyout element this item represents.
      */

package/core/flyout_navigator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IFlyout } from './interfaces/i_flyout.js';
+import { Navigator } from './navigator.js';
+export declare class FlyoutNavigator extends Navigator {
+    constructor(flyout: IFlyout);
+}
+//# sourceMappingURL=flyout_navigator.d.ts.map

package/core/flyout_separator.d.ts

@@ -4,12 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { IBoundedElement } from './interfaces/i_bounded_element.js';
-import type { INavigable } from './interfaces/i_navigable.js';
+import type { IFocusableNode } from './interfaces/i_focusable_node.js';
+import type { IFocusableTree } from './interfaces/i_focusable_tree.js';
 import { Rect } from './utils/rect.js';
 /**
  * Representation of a gap between elements in a flyout.
  */
-export declare class FlyoutSeparator implements IBoundedElement, INavigable<FlyoutSeparator> {
+export declare class FlyoutSeparator implements IBoundedElement, IFocusableNode {
     private gap;
     private axis;
     private x;
@@ -42,15 +43,16 @@ export declare class FlyoutSeparator implements IBoundedElement, INavigable<Flyo
      * @returns False.
      */
     isNavigable(): boolean;
-    /**
-     * Returns this separator's class.
-     *
-     * Used by keyboard navigation to look up the rules for navigating from this
-     * separator.
-     *
-     * @returns This separator's class.
-     */
-    getClass(): typeof FlyoutSeparator;
+    /** See IFocusableNode.getFocusableElement. */
+    getFocusableElement(): HTMLElement | SVGElement;
+    /** See IFocusableNode.getFocusableTree. */
+    getFocusableTree(): IFocusableTree;
+    /** See IFocusableNode.onNodeFocus. */
+    onNodeFocus(): void;
+    /** See IFocusableNode.onNodeBlur. */
+    onNodeBlur(): void;
+    /** See IFocusableNode.canBeFocused. */
+    canBeFocused(): boolean;
 }
 /**
  * Representation of an axis along which a separator occupies space.

package/core/focus_manager.d.ts

@@ -128,6 +128,10 @@ export declare class FocusManager {
      * Any previously focused node will be updated to be passively highlighted (if
      * it's in a different focusable tree) or blurred (if it's in the same one).
      *
+     * **Important**: If the provided node is not able to be focused (e.g. its
+     * canBeFocused() method returns false), it will be ignored and any existing
+     * focus state will remain unchanged.
+     *
      * @param focusableNode The node that should receive active focus.
      */
     focusNode(focusableNode: IFocusableNode): void;
@@ -171,9 +175,9 @@ export declare class FocusManager {
      */
     private defocusCurrentFocusedNode;
     /**
-     * Marks the specified node as actively focused, also calling related lifecycle
-     * callback methods for both the node and its parent tree. This ensures that
-     * the node is properly styled to indicate its active focus.
+     * Marks the specified node as actively focused, also calling related
+     * lifecycle callback methods for both the node and its parent tree. This
+     * ensures that the node is properly styled to indicate its active focus.
      *
      * This does not change the manager's currently tracked node, nor does it
      * change any other nodes.
@@ -221,8 +225,8 @@ export declare class FocusManager {
     /**
      * Returns the page-global FocusManager.
      *
-     * The returned instance is guaranteed to not change across function calls, but
-     * may change across page loads.
+     * The returned instance is guaranteed to not change across function calls,
+     * but may change across page loads.
      */
     static getFocusManager(): FocusManager;
 }

package/core/icons/comment_icon.d.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { Block } from '../block.js';
+import type { IBubble } from '../interfaces/i_bubble.js';
 import type { IHasBubble } from '../interfaces/i_has_bubble.js';
 import type { ISerializable } from '../interfaces/i_serializable.js';
 import { Coordinate } from '../utils.js';
@@ -92,6 +93,8 @@ export declare class CommentIcon extends Icon implements IHasBubble, ISerializab
     onBubbleLocationChange(): void;
     bubbleIsVisible(): boolean;
     setBubbleVisible(visible: boolean): Promise<void>;
+    /** See IHasBubble.getBubble. */
+    getBubble(): IBubble | null;
     /**
      * Shows the editable text bubble for this comment, and adds change listeners
      * to update the state of this icon in response to changes in the bubble.

package/core/icons/icon.d.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { Block } from '../block.js';
+import type { IFocusableTree } from '../interfaces/i_focusable_tree.js';
 import type { IIcon } from '../interfaces/i_icon.js';
 import * as tooltip from '../tooltip.js';
 import { Coordinate } from '../utils/coordinate.js';
@@ -28,6 +29,8 @@ export declare abstract class Icon implements IIcon {
     protected svgRoot: SVGGElement | null;
     /** The tooltip for this icon. */
     protected tooltip: tooltip.TipInfo;
+    /** The unique ID of this icon. */
+    private id;
     constructor(sourceBlock: Block);
     getType(): IconType<IIcon>;
     initView(pointerdownListener: (e: PointerEvent) => void): void;
@@ -59,5 +62,15 @@ export declare abstract class Icon implements IIcon {
      * @returns Whether the icon should be clickable while the block is in a flyout.
      */
     isClickableInFlyout(autoClosingFlyout: boolean): boolean;
+    /** See IFocusableNode.getFocusableElement. */
+    getFocusableElement(): HTMLElement | SVGElement;
+    /** See IFocusableNode.getFocusableTree. */
+    getFocusableTree(): IFocusableTree;
+    /** See IFocusableNode.onNodeFocus. */
+    onNodeFocus(): void;
+    /** See IFocusableNode.onNodeBlur. */
+    onNodeBlur(): void;
+    /** See IFocusableNode.canBeFocused. */
+    canBeFocused(): boolean;
 }
 //# sourceMappingURL=icon.d.ts.map

package/core/icons/mutator_icon.d.ts

@@ -5,6 +5,7 @@
  */
 import type { BlockSvg } from '../block_svg.js';
 import type { Abstract } from '../events/events_abstract.js';
+import type { IBubble } from '../interfaces/i_bubble.js';
 import type { IHasBubble } from '../interfaces/i_has_bubble.js';
 import { Coordinate } from '../utils/coordinate.js';
 import { Size } from '../utils/size.js';
@@ -54,6 +55,8 @@ export declare class MutatorIcon extends Icon implements IHasBubble {
     isClickableInFlyout(): boolean;
     bubbleIsVisible(): boolean;
     setBubbleVisible(visible: boolean): Promise<void>;
+    /** See IHasBubble.getBubble. */
+    getBubble(): IBubble | null;
     /** @returns the configuration the mini workspace should have. */
     private getMiniWorkspaceConfig;
     /**

package/core/icons/warning_icon.d.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { BlockSvg } from '../block_svg.js';
+import type { IBubble } from '../interfaces/i_bubble.js';
 import type { IHasBubble } from '../interfaces/i_has_bubble.js';
 import { Size } from '../utils.js';
 import { Coordinate } from '../utils/coordinate.js';
@@ -60,6 +61,8 @@ export declare class WarningIcon extends Icon implements IHasBubble {
     isClickableInFlyout(): boolean;
     bubbleIsVisible(): boolean;
     setBubbleVisible(visible: boolean): Promise<void>;
+    /** See IHasBubble.getBubble. */
+    getBubble(): IBubble | null;
     /**
      * @returns the location the bubble should be anchored to.
      *     I.E. the middle of this icon.

package/core/interfaces/i_bubble.d.ts

@@ -6,10 +6,11 @@
 import type { Coordinate } from '../utils/coordinate.js';
 import type { IContextMenu } from './i_contextmenu.js';
 import type { IDraggable } from './i_draggable.js';
+import { IFocusableNode } from './i_focusable_node.js';
 /**
  * A bubble interface.
  */
-export interface IBubble extends IDraggable, IContextMenu {
+export interface IBubble extends IDraggable, IContextMenu, IFocusableNode {
     /**
      * Return the coordinates of the top-left corner of this bubble's body
      * relative to the drawing surface's origin (0,0), in workspace units.

package/core/interfaces/i_focusable_node.d.ts

@@ -17,11 +17,13 @@ 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).
+     * 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
@@ -31,12 +33,17 @@ export interface IFocusableNode {
      * 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;
     /**
@@ -54,6 +61,33 @@ export interface IFocusableNode {
      * 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

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

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { INavigable } from './i_navigable.js';
+import type { IFocusableNode } from './i_focusable_node.js';
 /**
  * A set of rules that specify where keyboard navigation should proceed.
  */
@@ -14,14 +14,14 @@ export interface INavigationPolicy<T> {
      * @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): INavigable<any> | null;
+    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): INavigable<any> | null;
+    getParent(current: T): IFocusableNode | null;
     /**
      * Returns the peer element following the given element, if any.
      *
@@ -29,7 +29,7 @@ export interface INavigationPolicy<T> {
      * @returns The next peer element of the current element, or null if there is
      *     none.
      */
-    getNextSibling(current: T): INavigable<any> | null;
+    getNextSibling(current: T): IFocusableNode | null;
     /**
      * Returns the peer element preceding the given element, if any.
      *
@@ -37,6 +37,27 @@ export interface INavigationPolicy<T> {
      * @returns The previous peer element of the current element, or null if
      *     there is none.
      */
-    getPreviousSibling(current: T): INavigable<any> | null;
+    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/keyboard_nav/block_navigation_policy.d.ts

@@ -3,10 +3,9 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { BlockSvg } from '../block_svg.js';
-import type { INavigable } from '../interfaces/i_navigable.js';
+import { BlockSvg } from '../block_svg.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
 import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
-import type { RenderedConnection } from '../rendered_connection.js';
 /**
  * Set of rules controlling keyboard navigation from a block.
  */
@@ -17,7 +16,7 @@ export declare class BlockNavigationPolicy implements INavigationPolicy<BlockSvg
      * @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): INavigable<unknown> | null;
+    getFirstChild(current: BlockSvg): IFocusableNode | null;
     /**
      * Returns the parent of the given block.
      *
@@ -25,7 +24,7 @@ export declare class BlockNavigationPolicy implements INavigationPolicy<BlockSvg
      * @returns The top block of the given block's stack, or the connection to
      *     which it is attached.
      */
-    getParent(current: BlockSvg): INavigable<unknown> | null;
+    getParent(current: BlockSvg): IFocusableNode | null;
     /**
      * Returns the next peer node of the given block.
      *
@@ -33,7 +32,7 @@ export declare class BlockNavigationPolicy implements INavigationPolicy<BlockSvg
      * @returns The first block of the next stack if the given block is a terminal
      *     block, or its next connection.
      */
-    getNextSibling(current: BlockSvg): INavigable<unknown> | null;
+    getNextSibling(current: BlockSvg): IFocusableNode | null;
     /**
      * Returns the previous peer node of the given block.
      *
@@ -41,16 +40,20 @@ export declare class BlockNavigationPolicy implements INavigationPolicy<BlockSvg
      * @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): INavigable<unknown> | null;
+    getPreviousSibling(current: BlockSvg): 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.
+     * Returns whether or not the given block can be navigated to.
      *
-     * @param block The block to find the parent connection on.
-     * @returns The connection connecting to the parent of the block.
+     * @param current The instance to check for navigability.
+     * @returns True if the given block can be focused.
      */
-    protected getParentConnection(block: BlockSvg): RenderedConnection;
+    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

@@ -4,9 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { BlockSvg } from '../block_svg.js';
-import type { INavigable } from '../interfaces/i_navigable.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
 import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
-import type { RenderedConnection } from '../rendered_connection.js';
+import { RenderedConnection } from '../rendered_connection.js';
 /**
  * Set of rules controlling keyboard navigation from a connection.
  */
@@ -17,28 +17,28 @@ export declare class ConnectionNavigationPolicy implements INavigationPolicy<Ren
      * @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): INavigable<unknown> | null;
+    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): INavigable<unknown> | null;
+    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): INavigable<unknown> | null;
+    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): INavigable<unknown> | null;
+    getPreviousSibling(current: RenderedConnection): IFocusableNode | null;
     /**
      * Gets the parent connection on a block.
      * This is either an output connection, previous connection or undefined.
@@ -49,5 +49,19 @@ export declare class ConnectionNavigationPolicy implements INavigationPolicy<Ren
      * @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