@discourse/types 2026.1.0-c7e9cdd → 2026.3.0-887c5be4

package/declarations/app/instance-initializers/embed-storage-access.d.ts

@@ -0,0 +1,7 @@
+declare namespace _default {
+    let after: string;
+    function initialize(owner: any): void;
+    function showStorageAccessPrompt(owner: any): Promise<void>;
+}
+export default _default;
+//# sourceMappingURL=embed-storage-access.d.ts.map

package/declarations/app/instance-initializers/embed-storage-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed-storage-access.d.ts","sourceRoot":"","sources":["../../../../discourse/app/instance-initializers/embed-storage-access.js"],"names":[],"mappings":";;IAME,sCAkCC;IAED,4DAsBC"}

package/declarations/app/instance-initializers/highlight-users.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"highlight-users.d.ts","sourceRoot":"","sources":["../../../../discourse/app/instance-initializers/highlight-users.js"],"names":[],"mappings":";IAGE,4BAgBC"}
+{"version":3,"file":"highlight-users.d.ts","sourceRoot":"","sources":["../../../../discourse/app/instance-initializers/highlight-users.js"],"names":[],"mappings":";IAGE,4BAcC"}

package/declarations/app/instance-initializers/localization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localization.d.ts","sourceRoot":"","sources":["../../../../discourse/app/instance-initializers/localization.js"],"names":[],"mappings":";;IAKE,oEAWC;IAED,sCAyBC"}
+{"version":3,"file":"localization.d.ts","sourceRoot":"","sources":["../../../../discourse/app/instance-initializers/localization.js"],"names":[],"mappings":";;IAKE,oEAWC;IAED,sCAIC"}

package/declarations/app/instance-initializers/message-bus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message-bus.d.ts","sourceRoot":"","sources":["../../../../discourse/app/instance-initializers/message-bus.js"],"names":[],"mappings":"AAeA,6CAEC;;;IAmDC,sCAoFC"}
+{"version":3,"file":"message-bus.d.ts","sourceRoot":"","sources":["../../../../discourse/app/instance-initializers/message-bus.js"],"names":[],"mappings":"AAgBA,6CAEC;;;IAmDC,sCAoFC"}

package/declarations/app/instance-initializers/narrow-desktop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"narrow-desktop.d.ts","sourceRoot":"","sources":["../../../../discourse/app/instance-initializers/narrow-desktop.js"],"names":[],"mappings":";IAGE,sCA6BC"}
+{"version":3,"file":"narrow-desktop.d.ts","sourceRoot":"","sources":["../../../../discourse/app/instance-initializers/narrow-desktop.js"],"names":[],"mappings":";IAGE,sCAkBC"}

package/declarations/app/lib/ajax-error.d.ts

@@ -1,4 +1,6 @@
-export function extractErrorInfo(error: any, defaultMessage: any): {
+export function extractErrorInfo(error: any, defaultMessage: any, opts?: {
+    skipConsoleError: boolean;
+}): {
     html: boolean;
     message: any;
 };

package/declarations/app/lib/ajax-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ajax-error.d.ts","sourceRoot":"","sources":["../../../../discourse/app/lib/ajax-error.js"],"names":[],"mappings":"AAKA;;;EAiEC;AAED,mEAEC;AAED,yEACmB,UAAK,WAOvB;AAED,kEACU,UAAK,UAGd;AAED,iDASC"}
+{"version":3,"file":"ajax-error.d.ts","sourceRoot":"","sources":["../../../../discourse/app/lib/ajax-error.js"],"names":[],"mappings":"AAMA;;;;;EA2EC;AAED,mEAEC;AAED,yEACmB,UAAK,WAOvB;AAED,kEACU,UAAK,UAGd;AAED,iDASC"}

package/declarations/app/lib/ajax.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ajax.d.ts","sourceRoot":"","sources":["../../../../discourse/app/lib/ajax.js"],"names":[],"mappings":"AAiBA,+DAEC;AAED,6DAEC;AAED,+GASC;AAED,kCAKC;AAED,iDAEC;AAED,6CAIC;AAUD,uCAQC;AAED;;;;GAIG;AAEH,mDAsKC"}
+{"version":3,"file":"ajax.d.ts","sourceRoot":"","sources":["../../../../discourse/app/lib/ajax.js"],"names":[],"mappings":"AAkBA,+DAEC;AAED,6DAEC;AAED,+GASC;AAED,kCAKC;AAED,iDAEC;AAED,6CAIC;AAUD,uCAQC;AAED;;;;GAIG;AAEH,mDAsKC"}

package/declarations/app/lib/array-tools.d.ts

@@ -59,5 +59,17 @@ export function removeValuesFromArray(target: any[], values: any[]): any[];
  * @return {Array|TrackedArray} A new array with only unique elements (TrackedArray if input was TrackedArray)
  */
 export function uniqueItemsFromArray(array: any[], selector?: (string | number | Function)): any[] | TrackedArray;
+/**
+ * Returns a sorted copy of an array using Ember-style sort definitions.
+ *
+ * Each definition is a string `"property"` or `"property:direction"` where
+ * direction is `"asc"` (default) or `"desc"`. Dot-notation paths are supported
+ * (e.g., `"badge.badge_type_id"`).
+ *
+ * @param {Array} array - The array to sort. Returns `[]` if not an array.
+ * @param {string[]} sortDefinitions - Sort definition strings.
+ * @returns {Array} A new sorted array.
+ */
+export function arraySortedByProperties(array: any[], sortDefinitions: string[]): any[];
 import { TrackedArray } from "@ember-compat/tracked-built-ins";
 //# sourceMappingURL=array-tools.d.ts.map

package/declarations/app/lib/array-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array-tools.d.ts","sourceRoot":"","sources":["../../../../discourse/app/lib/array-tools.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,4DAbW,GAAC,8BAuBX;AAED;;;;;;;;;;GAUG;AACH,2FAFY,IAAI,CAaf;AAED;;;;;;GAMG;AACH,2DAHW,GAAC,SAeX;AAED;;;;;;;GAOG;AACH,2EAMC;AA6CD;;;;;;;;;;;;GAYG;AACH,8DAPW,CAAC,MAAM,GAAC,MAAM,WAAS,CAAC,GAKvB,QAAM,YAAY,CAe7B;6BAjK4B,iCAAiC"}
+{"version":3,"file":"array-tools.d.ts","sourceRoot":"","sources":["../../../../discourse/app/lib/array-tools.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,4DAbW,GAAC,8BAuBX;AAED;;;;;;;;;;GAUG;AACH,2FAFY,IAAI,CAaf;AAED;;;;;;GAMG;AACH,2DAHW,GAAC,SAeX;AAED;;;;;;;GAOG;AACH,2EAMC;AA6CD;;;;;;;;;;;;GAYG;AACH,8DAPW,CAAC,MAAM,GAAC,MAAM,WAAS,CAAC,GAKvB,QAAM,YAAY,CAe7B;AAED;;;;;;;;;;GAUG;AACH,uEAHW,MAAM,EAAE,SAiBlB;6BA5L4B,iCAAiC"}

package/declarations/app/lib/avatar-flair.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"avatar-flair.d.ts","sourceRoot":"","sources":["../../../../discourse/app/lib/avatar-flair.js"],"names":[],"mappings":"AASA,yEA+BC;AAED,mCAGC"}
+{"version":3,"file":"avatar-flair.d.ts","sourceRoot":"","sources":["../../../../discourse/app/lib/avatar-flair.js"],"names":[],"mappings":"AASA,yEAgCC;AAED,mCAGC"}

package/declarations/app/lib/blocks/-internals/components/block-layout-wrapper.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @typedef {import("ember-curry-component").CurriedComponent} CurriedComponent
+ */
+/**
+ * @typedef {Object} WrappedBlockLayoutArgs
+ * @property {string} outletName - The outlet name for class generation.
+ * @property {string} name - The block's full registered name.
+ * @property {string|null} namespace - The block's namespace prefix.
+ * @property {boolean} isContainer - Whether this is a container block.
+ * @property {string|null} [id] - Optional block ID for BEM modifiers and targeting.
+ * @property {CurriedComponent} Component - The curried block component to render.
+ * @property {string} [classNames] - Additional CSS classes from layout entry.
+ * @property {string} [decoratorClassNames] - Extra CSS classes from the @block decorator.
+ */
+/**
+ * @typedef {Object} WrappedBlockLayoutSignature
+ * @property {WrappedBlockLayoutArgs} Args
+ */
+/**
+ * Wraps a block in a standard layout wrapper with BEM-style classes.
+ *
+ * @param {Object} blockData - Block rendering data.
+ * @param {string} blockData.outletName - The outlet name for class generation.
+ * @param {string} blockData.name - The block's full registered name.
+ * @param {string} blockData.namespace - The block's namespace prefix.
+ * @param {boolean} blockData.isContainer - Whether this is a container block.
+ * @param {string|null} [blockData.id] - Optional block ID for BEM modifiers.
+ * @param {CurriedComponent} blockData.Component - The curried block component.
+ * @param {string} [blockData.classNames] - Additional CSS classes from layout entry.
+ * @param {string} [blockData.decoratorClassNames] - Extra CSS classes from the @block decorator.
+ * @param {import("@ember/owner").default} owner - The application owner for currying.
+ * @returns {CurriedComponent} The wrapped component.
+ */
+export function wrapBlockLayout(blockData: {
+    outletName: string;
+    name: string;
+    namespace: string;
+    isContainer: boolean;
+    id?: string | null;
+    Component: CurriedComponent;
+    classNames?: string;
+    decoratorClassNames?: string;
+}, owner: import("@ember/owner").default): CurriedComponent;
+export type CurriedComponent = any;
+export type WrappedBlockLayoutArgs = {
+    /**
+     * - The outlet name for class generation.
+     */
+    outletName: string;
+    /**
+     * - The block's full registered name.
+     */
+    name: string;
+    /**
+     * - The block's namespace prefix.
+     */
+    namespace: string | null;
+    /**
+     * - Whether this is a container block.
+     */
+    isContainer: boolean;
+    /**
+     * - Optional block ID for BEM modifiers and targeting.
+     */
+    id?: string | null;
+    /**
+     * - The curried block component to render.
+     */
+    Component: CurriedComponent;
+    /**
+     * - Additional CSS classes from layout entry.
+     */
+    classNames?: string;
+    /**
+     * - Extra CSS classes from the
+     */
+    decoratorClassNames?: string;
+};
+export type WrappedBlockLayoutSignature = {
+    Args: WrappedBlockLayoutArgs;
+};
+//# sourceMappingURL=block-layout-wrapper.d.ts.map

package/declarations/app/lib/blocks/-internals/components/block-layout-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-layout-wrapper.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/components/block-layout-wrapper.gjs"],"names":[],"mappings":"AA2HA;;GAEG;AAEH;;;;;;;;;;GAUG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;;;GAcG;AACH,2CAXG;IAA0B,UAAU,EAA5B,MAAM;IACY,IAAI,EAAtB,MAAM;IACY,SAAS,EAA3B,MAAM;IACa,WAAW,EAA9B,OAAO;IACiB,EAAE,GAA1B,MAAM,GAAC,IAAI;IACiB,SAAS,EAArC,gBAAgB;IACG,UAAU,GAA7B,MAAM;IACa,mBAAmB,GAAtC,MAAM;CAA+D,SACrE,OAAO,cAAc,EAAE,OAAO,GAC5B,gBAAgB,CAI5B;;;;;;gBAhCa,MAAM;;;;UACN,MAAM;;;;eACN,MAAM,GAAC,IAAI;;;;iBACX,OAAO;;;;SACP,MAAM,GAAC,IAAI;;;;eACX,gBAAgB;;;;iBAChB,MAAM;;;;0BACN,MAAM;;;UAKN,sBAAsB"}

package/declarations/app/lib/blocks/-internals/components/block-outlet-inline-error.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Displays an error inline within a block outlet.
+ * Uses FlashMessage to render the error in a consistent format.
+ *
+ * @param {Error|string|Object} error - The error to display. Can be an Error object,
+ *   a string, an HTTP response object with responseJSON/responseText, or a jqXHR object.
+ */
+export default class BlockOutletInlineError extends Component<any> {
+    constructor(owner: import("@ember/-internals/owner").default, args: any);
+    get errorMessage(): any;
+}
+import Component from "@glimmer/component";
+//# sourceMappingURL=block-outlet-inline-error.d.ts.map

package/declarations/app/lib/blocks/-internals/components/block-outlet-inline-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-outlet-inline-error.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/components/block-outlet-inline-error.gjs"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH;;IACE,wBAKC;CAeF;sBAjCqB,oBAAoB"}

package/declarations/app/lib/blocks/-internals/components/block-outlet-root-container.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Internal container component that processes and renders block children.
+ *
+ * This component handles condition evaluation and component creation in a
+ * tracked getter context. By evaluating conditions synchronously in
+ * `processedChildren`, Ember's autotracking establishes dependencies on
+ * services like `router` and `discovery`. Route changes trigger re-evaluation.
+ *
+ * If condition evaluation happened in the async promise chain (as it did
+ * previously), service reads would not be tracked and route navigation
+ * would not trigger re-evaluation.
+ *
+ * The component receives the authorization-dependent function `createChildBlockFn`
+ * as a prop to maintain the authorization model in the main block-outlet module.
+ *
+ * @private
+ */
+export default class BlockOutletRootContainer extends Component<any> {
+    constructor(owner: import("@ember/owner").default, args: any);
+    blocks: any;
+    /**
+     * The CSS-safe version of the outlet name, used as the class for the
+     * outermost wrapper `<div>`.
+     *
+     * @see {@link outletClassName} for the naming convention.
+     * @returns {string} The CSS-safe outlet name (e.g., "hero-blocks").
+     */
+    get safeOutletName(): string;
+    /**
+     * The CSS class name for the container element that establishes the
+     * CSS container query context for child blocks.
+     *
+     * @see {@link outletContainerClassName} for the naming convention.
+     * @returns {string} The container class name (e.g., "hero-blocks__container").
+     */
+    get containerClassName(): string;
+    /**
+     * The CSS class name for the layout element that wraps the rendered
+     * block children.
+     *
+     * @see {@link outletLayoutClassName} for the naming convention.
+     * @returns {string} The layout class name (e.g., "hero-blocks__layout").
+     */
+    get layoutClassName(): string;
+    /**
+     * Processes raw block entries and creates renderable child components.
+     *
+     * This getter is the key to reactive condition evaluation. By accessing
+     * services like `router` and `discovery` during condition evaluation here
+     * (synchronously in a tracked getter), Ember establishes tracking
+     * dependencies. Route changes trigger this getter to re-run.
+     *
+     * @returns {Array<import("discourse/lib/blocks/-internals/entry-processing").ChildBlockResult>}
+     */
+    get processedChildren(): Array<import("discourse/lib/blocks/-internals/entry-processing").ChildBlockResult>;
+    #private;
+}
+import Component from "@glimmer/component";
+//# sourceMappingURL=block-outlet-root-container.d.ts.map

package/declarations/app/lib/blocks/-internals/components/block-outlet-root-container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-outlet-root-container.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/components/block-outlet-root-container.gjs"],"names":[],"mappings":"AAuSA;;;;;;;;;;;;;;;;GAgBG;AACH;;IACE,YAAgB;IAiBhB;;;;;;OAMG;IACH,sBAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,0BAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;;;;;;OASG;IACH,yBAFa,KAAK,CAAC,OAAO,kDAAkD,EAAE,gBAAgB,CAAC,CAgD9F;;CA8JF;sBA5SqB,oBAAoB"}

package/declarations/app/lib/blocks/-internals/css.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Returns the CSS-safe version of an outlet name.
+ *
+ * Converts namespaced outlet names (e.g., "plugin:outlet") to valid CSS
+ * identifiers by replacing colons with hyphens and dasherizing.
+ *
+ * @param {string} outletName - The outlet name (e.g., "hero-blocks", "plugin:sidebar").
+ * @returns {string} The CSS-safe name (e.g., "hero-blocks", "plugin-sidebar").
+ */
+export function outletClassName(outletName: string): string;
+/**
+ * Returns the container CSS class name for a block outlet.
+ *
+ * Follows the BEM-like pattern: `{safe-outlet-name}__container`.
+ * For example, outlet "hero-blocks" produces "hero-blocks__container".
+ *
+ * @param {string} outletName - The outlet name (e.g., "hero-blocks", "plugin:sidebar").
+ * @returns {string} The CSS class name (e.g., "hero-blocks__container").
+ */
+export function outletContainerClassName(outletName: string): string;
+/**
+ * Returns the layout CSS class name for a block outlet.
+ *
+ * Follows the BEM-like pattern: `{safe-outlet-name}__layout`.
+ * For example, outlet "hero-blocks" produces "hero-blocks__layout".
+ *
+ * @param {string} outletName - The outlet name (e.g., "hero-blocks", "plugin:sidebar").
+ * @returns {string} The CSS class name (e.g., "hero-blocks__layout").
+ */
+export function outletLayoutClassName(outletName: string): string;
+/**
+ * Returns the CSS container query rule for a block outlet.
+ *
+ * Generates the CSS that enables `@container` queries inside block outlets
+ * by setting the `container` property on the outlet's container element.
+ *
+ * @param {string} outletName - The outlet name (e.g., "hero-blocks").
+ * @returns {string} The CSS rule (e.g., `.hero-blocks__container { container: hero-blocks / inline-size; }`).
+ */
+export function outletContainerRule(outletName: string): string;
+//# sourceMappingURL=css.d.ts.map

package/declarations/app/lib/blocks/-internals/css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../../../../../discourse/app/lib/blocks/-internals/css.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,4CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;GAQG;AACH,qDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;GAQG;AACH,kDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;GAQG;AACH,gDAHW,MAAM,GACJ,MAAM,CAIlB"}

package/declarations/app/lib/blocks/-internals/debug-hooks.d.ts

@@ -0,0 +1,217 @@
+/**
+ * Handles an optional missing block by logging and optionally creating a ghost.
+ *
+ * When a block reference ends with `?` but the block is not registered, this
+ * function handles the logging and ghost component creation.
+ *
+ * @param {Object} options - Options for handling the missing block.
+ * @param {string} options.blockName - The name of the missing block.
+ * @param {Object} options.entry - The block entry.
+ * @param {string} options.hierarchy - The hierarchy path for logging.
+ * @param {boolean} options.isLoggingEnabled - Whether debug logging is enabled.
+ * @param {boolean} options.showGhosts - Whether to show ghost components.
+ * @param {string} options.key - Stable unique key for this block.
+ * @returns {import("discourse/lib/blocks/-internals/entry-processing").ChildBlockResult|null}
+ *   Ghost component data with key if showGhosts is true, null otherwise.
+ */
+export function handleOptionalMissingBlock({ blockName, entry, hierarchy, isLoggingEnabled, showGhosts, key, }: {
+    blockName: string;
+    entry: any;
+    hierarchy: string;
+    isLoggingEnabled: boolean;
+    showGhosts: boolean;
+    key: string;
+}): import("discourse/lib/blocks/-internals/entry-processing").ChildBlockResult | null;
+/**
+ * Builds a container path for nested containers.
+ *
+ * Maintains a count map to ensure unique indices for containers of the same type.
+ * For example, if there are two "group" containers without ids, they get paths like:
+ * - `baseHierarchy/group[0]`
+ * - `baseHierarchy/group[1]`
+ *
+ * If a block has an id, it replaces the index (since the id is unique):
+ * - `baseHierarchy/group(#my-id)`
+ *
+ * @param {string} blockName - The block name.
+ * @param {string|null} blockId - The block's unique id (if set).
+ * @param {string} baseHierarchy - The base hierarchy path.
+ * @param {Map<string, number>} containerCounts - Map tracking container counts.
+ * @returns {string} The full container path.
+ */
+export function buildContainerPath(blockName: string, blockId: string | null, baseHierarchy: string, containerCounts: Map<string, number>): string;
+/**
+ * Invokes the BLOCK_DEBUG callback to create a ghost component.
+ *
+ * This is the low-level helper that calls the debug callback with block data.
+ * Used by both `createGhostBlock` (entry-processing time) and `asGhost`
+ * (render time) to avoid duplicating the callback invocation logic.
+ *
+ * @param {Object} blockData - Data describing the block to ghost.
+ * @param {string} blockData.name - The block name.
+ * @param {string} [blockData.id] - The block's unique ID (if set).
+ * @param {Object} [blockData.args] - Block arguments.
+ * @param {Object} [blockData.containerArgs] - Container arguments.
+ * @param {Array} [blockData.conditions] - Block conditions.
+ * @param {string} [blockData.failureType] - Type of failure (from FAILURE_TYPE).
+ * @param {string} [blockData.failureReason] - Custom failure reason message.
+ * @param {Array} [blockData.children] - Ghost children for containers.
+ * @param {Object} context - Context for the ghost.
+ * @param {string} context.outletName - The outlet/hierarchy name for display.
+ * @param {Object} [context.outletArgs] - Outlet arguments.
+ * @returns {Object|null} Ghost data with Component property, or null if callback
+ *   not set or didn't return a component.
+ */
+export function createDebugGhost(blockData: {
+    name: string;
+    id?: string;
+    args?: any;
+    containerArgs?: any;
+    conditions?: any[];
+    failureType?: string;
+    failureReason?: string;
+    children?: any[];
+}, context: {
+    outletName: string;
+    outletArgs?: any;
+}): any | null;
+/**
+ * Creates a ghost component for an invisible block.
+ *
+ * Ghost components are shown in debug mode to visualize blocks that failed
+ * their conditions or have no visible children.
+ *
+ * @param {Object} options - Options for creating the ghost.
+ * @param {string} options.blockName - The block name.
+ * @param {Object} options.entry - The block entry.
+ * @param {string} options.hierarchy - The hierarchy path for display.
+ * @param {string|undefined} options.containerPath - Container path for child hierarchies.
+ * @param {boolean} options.isContainer - Whether this block is a container.
+ * @param {import("@ember/owner").default} options.owner - The application owner.
+ * @param {Object} options.outletArgs - Outlet arguments.
+ * @param {boolean} options.isLoggingEnabled - Whether debug logging is enabled.
+ * @param {Function} options.resolveBlockFn - Function to resolve block references.
+ * @param {string} options.key - Stable unique key for this block.
+ * @returns {import("discourse/lib/blocks/-internals/entry-processing").ChildBlockResult|null}
+ *   Ghost component data with key if successful, null otherwise.
+ */
+export function createGhostBlock({ blockName, entry, hierarchy, containerPath, isContainer, owner, outletArgs, isLoggingEnabled, resolveBlockFn, key, }: {
+    blockName: string;
+    entry: any;
+    hierarchy: string;
+    containerPath: string | undefined;
+    isContainer: boolean;
+    owner: import("@ember/owner").default;
+    outletArgs: any;
+    isLoggingEnabled: boolean;
+    resolveBlockFn: Function;
+    key: string;
+}): import("discourse/lib/blocks/-internals/entry-processing").ChildBlockResult | null;
+/**
+ * Executes a function within a debug console group.
+ * Ensures START_GROUP and END_GROUP callbacks are always paired.
+ *
+ * @param {string} blockName - The block name for the group label.
+ * @param {string|null} blockId - The block's unique ID (if set).
+ * @param {string} hierarchy - The hierarchy path for context.
+ * @param {boolean} isLoggingEnabled - Whether debug logging is active.
+ * @param {() => boolean} fn - Function to execute that returns the condition result.
+ * @returns {boolean} The result of the function execution.
+ */
+export function withDebugGroup(blockName: string, blockId: string | null, hierarchy: string, isLoggingEnabled: boolean, fn: () => boolean): boolean;
+/**
+ * Callback key constants for the debug hooks registry.
+ * Use these instead of magic strings when calling debugHooks.getCallback/setCallback.
+ */
+export const DEBUG_CALLBACK: Readonly<{
+    BLOCK_DEBUG: "blockDebug";
+    BLOCK_LOGGING: "blockLogging";
+    VISUAL_OVERLAY: "visualOverlay";
+    GHOST_BLOCKS: "ghostBlocks";
+    OUTLET_INFO_COMPONENT: "outletInfoComponent";
+    CONDITION_LOG: "conditionLog";
+    COMBINATOR_LOG: "combinatorLog";
+    CONDITION_RESULT: "conditionResult";
+    PARAM_GROUP_LOG: "paramGroupLog";
+    ROUTE_STATE_LOG: "routeStateLog";
+    OPTIONAL_MISSING_LOG: "optionalMissingLog";
+    START_GROUP: "startGroup";
+    END_GROUP: "endGroup";
+    LOGGER_INTERFACE: "loggerInterface";
+    GHOST_CHILDREN_CREATOR: "ghostChildrenCreator";
+}>;
+/**
+ * Singleton instance of DebugHooks.
+ * Import this to access debug callbacks with tracked reactivity.
+ */
+export const debugHooks: DebugHooks;
+/**
+ * Singleton class that manages debug callback hooks for the block rendering system.
+ * Uses TrackedMap for reactivity, so components accessing these values will re-render
+ * when callbacks are set or cleared.
+ */
+declare class DebugHooks {
+    /**
+     * Gets a debug callback from the registry.
+     *
+     * @param {string} key - The callback key (use DEBUG_CALLBACK constants).
+     * @returns {Function|null} The callback function, or null if not set.
+     */
+    getCallback(key: string): Function | null;
+    /**
+     * Sets a debug callback in the registry.
+     * Used by dev-tools to register debug hooks.
+     *
+     * @param {string} key - The callback key (use DEBUG_CALLBACK constants).
+     * @param {Function|null} value - The callback function, or null to clear.
+     * @throws {Error} If the key is not a valid callback key.
+     */
+    setCallback(key: string, value: Function | null): void;
+    /**
+     * Returns whether console logging is enabled.
+     * Convenience getter that invokes the blockLogging callback.
+     *
+     * @returns {boolean} True if logging is enabled.
+     */
+    get isBlockLoggingEnabled(): boolean;
+    /**
+     * Returns the outlet info component if outlet boundaries are enabled.
+     * Invokes the OUTLET_INFO_COMPONENT callback which returns the component
+     * when enabled, or null when disabled.
+     *
+     * @returns {typeof import("@glimmer/component").default|null} The outlet info component, or null.
+     */
+    get outletInfoComponent(): typeof import("@glimmer/component").default | null;
+    /**
+     * Returns whether outlet boundaries should be shown.
+     * Derived from whether the outlet info component is available.
+     *
+     * @returns {boolean} True if boundaries should be shown.
+     */
+    get isOutletBoundaryEnabled(): boolean;
+    /**
+     * Returns whether visual overlay is enabled.
+     *
+     * @returns {boolean} True if visual overlay is enabled.
+     */
+    get isVisualOverlayEnabled(): boolean;
+    /**
+     * Returns whether ghost blocks are enabled.
+     *
+     * @returns {boolean} True if ghost blocks are enabled.
+     */
+    get isGhostBlocksEnabled(): boolean;
+    /**
+     * Returns the logger interface for conditions to use.
+     * Convenience getter that invokes the loggerInterface callback.
+     *
+     * The interface has methods: logCondition, updateCombinatorResult,
+     * updateConditionResult, logParamGroup, logRouteState.
+     *
+     * @returns {Object|null} The logger interface, or null if not available.
+     */
+    get loggerInterface(): any | null;
+    #private;
+}
+export {};
+//# sourceMappingURL=debug-hooks.d.ts.map

package/declarations/app/lib/blocks/-internals/debug-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-hooks.d.ts","sourceRoot":"","sources":["../../../../../../discourse/app/lib/blocks/-internals/debug-hooks.js"],"names":[],"mappings":"AAyJA;;;;;;;;;;;;;;;GAeG;AACH,gHATG;IAAwB,SAAS,EAAzB,MAAM;IACU,KAAK;IACL,SAAS,EAAzB,MAAM;IACW,gBAAgB,EAAjC,OAAO;IACU,UAAU,EAA3B,OAAO;IACS,GAAG,EAAnB,MAAM;CACd,GAAU,OAAO,kDAAkD,EAAE,gBAAgB,GAAC,IAAI,CAoC5F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8CANW,MAAM,WACN,MAAM,GAAC,IAAI,iBACX,MAAM,mBACN,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACjB,MAAM,CAelB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CAdG;IAA0B,IAAI,EAAtB,MAAM;IACa,EAAE,GAArB,MAAM;IACa,IAAI;IACJ,aAAa;IACd,UAAU;IACT,WAAW,GAA9B,MAAM;IACa,aAAa,GAAhC,MAAM;IACY,QAAQ;CAClC,WACA;IAAwB,UAAU,EAA1B,MAAM;IACW,UAAU;CACnC,GAAU,MAAO,IAAI,CAcvB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yJAbG;IAAwB,SAAS,EAAzB,MAAM;IACU,KAAK;IACL,SAAS,EAAzB,MAAM;IACoB,aAAa,EAAvC,MAAM,GAAC,SAAS;IACC,WAAW,EAA5B,OAAO;IACiC,KAAK,EAA7C,OAAO,cAAc,EAAE,OAAO;IACd,UAAU;IACT,gBAAgB,EAAjC,OAAO;IACW,cAAc;IAChB,GAAG,EAAnB,MAAM;CACd,GAAU,OAAO,kDAAkD,EAAE,gBAAgB,GAAC,IAAI,CAkD5F;AAED;;;;;;;;;;GAUG;AACH,0CAPW,MAAM,WACN,MAAM,GAAC,IAAI,aACX,MAAM,oBACN,OAAO,MACP,MAAM,OAAO,GACX,OAAO,CAqBnB;AAhWD;;;GAGG;AACH;;;;;;;;;;;;;;;;GAgBG;AA6GH;;;GAGG;AACH,oCAA2C;AA/G3C;;;;GAIG;AACH;IAWE;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,WAAS,IAAI,CAIzB;IAED;;;;;;;OAOG;IACH,iBAJW,MAAM,SACN,WAAS,IAAI,QAWvB;IAED;;;;;OAKG;IACH,6BAFa,OAAO,CAInB;IAED;;;;;;OAMG;IACH,2BAFa,cAAc,oBAAoB,EAAE,OAAO,GAAC,IAAI,CAI5D;IAED;;;;;OAKG;IACH,+BAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,8BAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,4BAFa,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,uBAFa,MAAO,IAAI,CAIvB;;CACF"}