@discourse/types 2026.8.0-fb9247e0 → 2026.9.0-c0ef3a11

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

@@ -1,31 +1,39 @@
+import type { ValidationContext } from "discourse/lib/blocks/-internals/utils";
 /**
  * Parses a condition path string into path segments.
  * Handles both dot notation (`.key`) and bracket notation (`[0]`).
  *
- * @param {string} path - The path string (e.g., "conditions.any[0][1].queryParams").
- * @returns {Array<string|number>} Array of path segments.
+ * @param path - The path string (e.g., "conditions.any[0][1].queryParams").
+ * @returns Array of path segments.
  *
  * @example
+ * ```
  * parseConditionPath("conditions.any[0][1].type")
  * // Returns: ["conditions", "any", 0, 1, "type"]
+ * ```
  */
-export function parseConditionPath(path: string): Array<string | number>;
+export declare function parseConditionPath(path: string): (string | number)[];
+/**
+ * Formatting options accepted by `formatEntryWithErrorPath()` and, in turn,
+ * `PathHighlightRenderer`.
+ */
+export interface FormatEntryOptions {
+    /** Prefix to skip in the path. */
+    prefix?: string;
+    /** Label to show before the entry. */
+    label?: string;
+}
 /**
  * Renders a block entry object with the error path highlighted.
  * Shows the structure with proper indentation and adds a comment marker
  * to indicate where the error occurred.
  *
- * @param {Object|Array} entry - The block entry object to render.
- * @param {string} errorPath - The path to the error (e.g., "conditions.any[0][0].queryParams").
- * @param {Object} [options] - Formatting options.
- * @param {string} [options.prefix] - Optional prefix to skip in the path (e.g., "conditions").
- * @param {string} [options.label] - Label to show before the entry (e.g., "conditions:").
- * @returns {string} Formatted string with the error location highlighted.
+ * @param entry - The block entry object (or array) to render.
+ * @param errorPath - The path to the error (e.g., "conditions.any[0][0].queryParams").
+ * @param options - Formatting options.
+ * @returns Formatted string with the error location highlighted.
  */
-export function formatEntryWithErrorPath(entry: any | any[], errorPath: string, options?: {
-    prefix?: string;
-    label?: string;
-}): string;
+export declare function formatEntryWithErrorPath(entry: unknown, errorPath: string, options?: FormatEntryOptions): string;
 /**
  * Truncates an object for JSON serialization in error messages.
  * Returns actual objects/arrays with truncated content, not strings.
@@ -35,13 +43,13 @@ export function formatEntryWithErrorPath(entry: any | any[], errorPath: string,
  *
  * Handles special cases like block classes, children arrays, and circular references.
  *
- * @param {*} obj - The object to truncate.
- * @param {number} [maxDepth=2] - Maximum nesting depth before truncating.
- * @param {number} [maxKeys=5] - Maximum number of keys to show per object.
- * @param {WeakSet} [_seen=null] - Internal parameter for tracking circular references.
- * @returns {*} Truncated representation of the object.
+ * @param obj - The object to truncate.
+ * @param maxDepth - Maximum nesting depth before truncating.
+ * @param maxKeys - Maximum number of keys to show per object.
+ * @param _seen - Internal parameter for tracking circular references.
+ * @returns Truncated representation of the object.
  */
-export function truncateForDisplay(obj: any, maxDepth?: number, maxKeys?: number, _seen?: WeakSet<any>): any;
+export declare function truncateForDisplay(obj: unknown, maxDepth?: number, maxKeys?: number, _seen?: WeakSet<object> | null): unknown;
 /**
  * Captures the current call site as an Error object, excluding internal frames.
  * Call this at the entry point (e.g., renderBlocks) to capture where
@@ -51,45 +59,23 @@ export function truncateForDisplay(obj: any, maxDepth?: number, maxKeys?: number
  * and everything above it from the stack trace. This means the stack will
  * point directly to the user's code, not to internal block system functions.
  *
- * @param {Function} callerFn - The function to exclude from the stack trace.
+ * @param callerFn - The function to exclude from the stack trace.
  *   Pass the function that calls `captureCallSite` (e.g., `_renderBlocks`).
- * @returns {Error} An Error object with stack trace starting from callerFn's caller.
+ * @returns An Error object with stack trace starting from callerFn's caller.
  */
-export function captureCallSite(callerFn: Function): Error;
+export declare function captureCallSite(callerFn: (...args: any[]) => void): Error;
 /**
- * Raises a block error by throwing a `BlockError`.
- *
- * If context is provided, the error message will include the block
- * entry for debugging.
- *
- * If a `callSiteError` is present in the context, it is reused with the
- * new message. This preserves the original stack trace pointing to where
- * `renderBlocks()` was called, which is more useful than pointing to this
- * function. Source maps are applied automatically by the browser.
- *
- * @param {string} message - The error message.
- * @param {Object} [context] - Optional error context for better error messages.
- * @param {string} [context.outletName] - The outlet name where the block is registered.
- * @param {string} [context.blockName] - The name of the block being validated.
- * @param {string} [context.path] - Path within the layout to the error (e.g., "[2].conditions.params.categoryId").
- *   Used by validation code to indicate where errors occurred. Combined with `errorPath` for display.
- * @param {Object} [context.entry] - The block entry being validated.
- * @param {Object} [context.conditions] - The conditions being validated.
- * @param {string} [context.errorPath] - Full path to the error for display (e.g., "[2].conditions.params.categoryId").
- * @param {Array<Object>} [context.rootLayout] - The root outlet layout for tree display in errors.
- * @param {Error | null} [context.callSiteError] - Error object capturing where renderBlocks() was called.
- * @throws {BlockError} Always throws.
+ * Options accepted by `BlockError`'s constructor.
  */
-export function raiseBlockError(message: string, context?: {
-    outletName?: string;
-    blockName?: string;
+export interface BlockErrorOptions {
+    /** The underlying cause of this error, chained via the standard ES2022 `cause` option. */
+    cause?: Error;
+    /**
+     * Path to the error within the layout (e.g., "[0].conditions.any[0].type"
+     * or "[0].args.showIcon").
+     */
     path?: string;
-    entry?: any;
-    conditions?: any;
-    errorPath?: string;
-    rootLayout?: Array<any>;
-    callSiteError?: Error | null;
-}): void;
+}
 /**
  * Error thrown when block validation fails.
  * Used by block entry and condition validation to report
@@ -100,24 +86,30 @@ export function raiseBlockError(message: string, context?: {
  * `callSiteError` directly (mutating its message and name) rather than
  * passing it as `cause`. This preserves the original stack trace pointing
  * to where `renderBlocks()` was called.
- *
- * @class BlockError
- * @extends Error
  */
-export class BlockError extends Error {
+export declare class BlockError extends Error {
+    path?: string;
     /**
-     * Creates a new BlockError.
-     *
-     * @param {string} message - The error message.
-     * @param {Object} [options] - Error options.
-     * @param {Error} [options.cause] - The underlying cause of this error.
-     * @param {string} [options.path] - Path to the error within the layout
-     *   (e.g., "[0].conditions.any[0].type" or "[0].args.showIcon").
+     * @param message - The error message.
+     * @param options - Error options.
      */
-    constructor(message: string, options?: {
-        cause?: Error;
-        path?: string;
-    });
-    path: string;
+    constructor(message: string, options?: BlockErrorOptions);
 }
+/**
+ * Raises a block error by throwing a `BlockError`.
+ *
+ * If context is provided, the error message will include the block
+ * entry for debugging.
+ *
+ * If a `callSiteError` is present in the context, it is reused with the
+ * new message. This preserves the original stack trace pointing to where
+ * `renderBlocks()` was called, which is more useful than pointing to this
+ * function. Source maps are applied automatically by the browser.
+ *
+ * @param message - The error message.
+ * @param context - Optional error context for better error messages (see
+ *   `ValidationContext`).
+ * @throws Always throws a `BlockError`.
+ */
+export declare function raiseBlockError(message: string, context?: Partial<ValidationContext> | null): never;
 //# sourceMappingURL=error.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../discourse/app/lib/blocks/-internals/error.js"],"names":[],"mappings":"AAoEA;;;;;;;;;;GAUG;AACH,yCAPW,MAAM,GACJ,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAyChC;AAiWD;;;;;;;;;;;GAWG;AACH,gDAPW,WAAY,aACZ,MAAM,YAEd;IAAyB,MAAM,GAAvB,MAAM;IACW,KAAK,GAAtB,MAAM;CACd,GAAU,MAAM,CAIlB;AAED;;;;;;;;;;;;;;GAcG;AACH,wCANW,GAAC,aACD,MAAM,YACN,MAAM,yBAEJ,GAAC,CA0Db;AAID;;;;;;;;;;;;GAYG;AACH,qDAFa,KAAK,CAcjB;AAwMD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,yCAbW,MAAM,YAEd;IAAyB,UAAU,GAA3B,MAAM;IACW,SAAS,GAA1B,MAAM;IACW,IAAI,GAArB,MAAM;IAEW,KAAK;IACL,UAAU;IACV,SAAS,GAA1B,MAAM;IACkB,UAAU,GAAlC,KAAK,KAAQ;IACU,aAAa,GAApC,KAAK,GAAG,IAAI;CACpB,QAuCF;AA5FD;;;;;;;;;;;;;GAaG;AACH;IACE;;;;;;;;OAQG;IACH,qBANW,MAAM,YAEd;QAAwB,KAAK,GAArB,KAAK;QACY,IAAI,GAArB,MAAM;KAEhB,EAKA;IADC,aAAyB;CAE5B"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../discourse/app/lib/blocks/-internals/error.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AA8D/E;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAmCpE;AAID;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,kCAAkC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAgYD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,kBAAuB,GAC/B,MAAM,CAER;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,OAAO,EACZ,QAAQ,SAAI,EACZ,OAAO,SAAI,EACX,KAAK,GAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAW,GACnC,OAAO,CA+DT;AAgBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAE7B,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GACjC,KAAK,CAWP;AAmLD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,0FAA0F;IAC1F,KAAK,CAAC,EAAE,KAAK,CAAC;IACd;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;OAGG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB;CAKzD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAW,GAChD,KAAK,CAoCP"}

package/declarations/app/lib/blocks/-internals/matching/condition-evaluator.d.ts

@@ -1,18 +1,24 @@
+import type { BlockCondition } from "discourse/blocks/conditions";
+/**
+ * Evaluation context passed through `evaluateConditions()` and its
+ * combinator helpers.
+ */
+export interface ConditionEvaluationContext {
+    /** Enable debug logging for this evaluation. */
+    debug?: boolean;
+    /** Internal: nesting depth for logging. */
+    _depth?: number;
+    /** Outlet arguments passed to conditions. */
+    outletArgs?: Record<string, unknown>;
+}
 /**
  * Evaluates condition specs at render time.
  * Recursively evaluates nested conditions with AND/OR/NOT logic.
  *
- * @param {Object|Array<Object>} conditionSpec - Condition spec(s) to evaluate.
- * @param {Map<string, import("discourse/blocks/conditions").BlockCondition>} conditionTypes - Map of registered condition types.
- * @param {Object} [context] - Evaluation context.
- * @param {boolean} [context.debug] - Enable debug logging for this evaluation.
- * @param {number} [context._depth] - Internal: nesting depth for logging.
- * @param {Object} [context.outletArgs] - Outlet arguments passed to conditions.
- * @returns {boolean} True if conditions pass, false otherwise.
+ * @param conditionSpec - Condition spec(s) to evaluate.
+ * @param conditionTypes - Map of registered condition types.
+ * @param context - Evaluation context.
+ * @returns True if conditions pass, false otherwise.
  */
-export function evaluateConditions(conditionSpec: any | Array<any>, conditionTypes: Map<string, import("discourse/blocks/conditions").BlockCondition>, context?: {
-    debug?: boolean;
-    _depth?: number;
-    outletArgs?: any;
-}): boolean;
+export declare function evaluateConditions(conditionSpec: unknown, conditionTypes: Map<string, BlockCondition>, context?: ConditionEvaluationContext): boolean;
 //# sourceMappingURL=condition-evaluator.d.ts.map

package/declarations/app/lib/blocks/-internals/matching/condition-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"condition-evaluator.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/matching/condition-evaluator.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;GAWG;AACH,kDARW,MAAO,KAAK,KAAQ,kBACpB,GAAG,CAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC,YAEzE;IAA0B,KAAK,GAAvB,OAAO;IACU,MAAM,GAAvB,MAAM;IACW,UAAU;CACnC,GAAU,OAAO,CA6EnB"}
+{"version":3,"file":"condition-evaluator.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/matching/condition-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAQlE;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,gDAAgD;IAChD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,OAAO,EACtB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,EAC3C,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAuET"}

package/declarations/app/lib/blocks/-internals/matching/outlet-matcher.d.ts

@@ -1,3 +1,23 @@
+/**
+ * The result of `detectPatternConflicts()`.
+ */
+export type PatternConflictResult = {
+    conflict: false;
+} | {
+    conflict: true;
+    details: {
+        outlet: string;
+        allowed: string;
+        denied: string;
+    };
+};
+/**
+ * The result of `isBlockPermittedInOutlet()`.
+ */
+export interface OutletPermissionResult {
+    permitted: boolean;
+    reason?: string;
+}
 /**
  * Checks if a pattern targets a namespaced outlet.
  *
@@ -6,16 +26,13 @@
  * These patterns bypass known-outlet validation since they reference outlets
  * that may not be in the core `BLOCK_OUTLETS` registry.
  *
- * @param {string} pattern - The pattern to check.
- * @returns {boolean} True if the pattern contains a namespace separator.
- *
  * @example
  * isNamespacedPattern("my-plugin:dashboard");      // true
  * isNamespacedPattern("my-theme:hero-section");    // true
  * isNamespacedPattern("sidebar-blocks");           // false
  * isNamespacedPattern("sidebar-*");                // false
  */
-export function isNamespacedPattern(pattern: string): boolean;
+export declare function isNamespacedPattern(pattern: string): boolean;
 /**
  * Matches an outlet name against a glob pattern using picomatch.
  *
@@ -27,32 +44,42 @@ export function isNamespacedPattern(pattern: string): boolean;
  * - `{a,b}` matches any of the comma-separated patterns
  * - `!(pattern)` negative match (matches anything except pattern)
  *
- * @param {string} outlet - The outlet name to test.
- * @param {string} pattern - The glob pattern to match against.
- * @returns {boolean} True if the outlet matches the pattern.
+ * @param outlet - The outlet name to test.
+ * @param pattern - The glob pattern to match against.
+ * @returns True if the outlet matches the pattern.
  *
  * @example
+ * ```
  * // Exact match
  * matchOutletPattern("sidebar-blocks", "sidebar-blocks");   // true
+ * ```
  *
  * @example
+ * ```
  * // Wildcard matching
  * matchOutletPattern("sidebar-left", "sidebar-*");          // true
  * matchOutletPattern("sidebar-left-top", "sidebar-*");      // true
+ * ```
  *
  * @example
+ * ```
  * // Brace expansion
  * matchOutletPattern("sidebar-blocks", "{sidebar,footer}-*"); // true
+ * ```
  *
  * @example
+ * ```
  * // Character class
  * matchOutletPattern("modal-1", "modal-[0-9]");             // true
+ * ```
  *
  * @example
+ * ```
  * // Negation
  * matchOutletPattern("sidebar-blocks", "!(*-debug)");       // true
+ * ```
  */
-export function matchOutletPattern(outlet: string, pattern: string): boolean;
+export declare function matchOutletPattern(outlet: string, pattern: string): boolean;
 /**
  * Validates that outlet patterns are a valid array of strings with valid picomatch syntax.
  *
@@ -62,15 +89,15 @@ export function matchOutletPattern(outlet: string, pattern: string): boolean;
  * 2. Each pattern in the array is a string
  * 3. Each pattern can be compiled by picomatch
  *
- * @param {*} patterns - The patterns to validate.
- * @param {string} blockName - Block name for error messages.
- * @param {string} propertyName - Property name ("allowedOutlets" or "deniedOutlets").
+ * @param patterns - The patterns to validate.
+ * @param blockName - Block name for error messages.
+ * @param propertyName - Property name ("allowedOutlets" or "deniedOutlets").
  *
  * @example
  * validateOutletPatterns(["sidebar-*", "homepage-blocks"], "my-block", "allowedOutlets");
  * validateOutletPatterns(null, "my-block", "allowedOutlets"); // null means no restrictions
  */
-export function validateOutletPatterns(patterns: any, blockName: string, propertyName: string): void;
+export declare function validateOutletPatterns(patterns: unknown, blockName: string, propertyName: string): void;
 /**
  * Detects if allowed and denied patterns could match the same outlet name.
  *
@@ -84,29 +111,25 @@ export function validateOutletPatterns(patterns: any, blockName: string, propert
  *    in patterns with concrete characters. This catches conflicts for outlets
  *    that don't exist yet (e.g., plugin-defined outlets).
  *
- * @param {string[]|null} allowedPatterns - Patterns for allowed outlets.
- * @param {string[]|null} deniedPatterns - Patterns for denied outlets.
- * @returns {{ conflict: boolean, details?: { outlet: string, allowed: string, denied: string } }}
- *   Returns conflict: true with details if a conflict is detected.
+ * @param allowedPatterns - Patterns for allowed outlets.
+ * @param deniedPatterns - Patterns for denied outlets.
+ * @returns Conflict: true with details if a conflict is detected.
  *
  * @example
+ * ```
  * // No conflict
  * detectPatternConflicts(["sidebar-*"], ["homepage-*"]);
  * // { conflict: false }
+ * ```
  *
  * @example
+ * ```
  * // Conflict detected
  * detectPatternConflicts(["*-blocks"], ["sidebar-*"]);
  * // { conflict: true, details: { outlet: "sidebar-blocks", allowed: "*-blocks", denied: "sidebar-*" } }
+ * ```
  */
-export function detectPatternConflicts(allowedPatterns: string[] | null, deniedPatterns: string[] | null): {
-    conflict: boolean;
-    details?: {
-        outlet: string;
-        allowed: string;
-        denied: string;
-    };
-};
+export declare function detectPatternConflicts(allowedPatterns: string[] | null | undefined, deniedPatterns: string[] | null | undefined): PatternConflictResult;
 /**
  * Checks if a block is permitted to render in a specific outlet.
  *
@@ -118,36 +141,40 @@ export function detectPatternConflicts(allowedPatterns: string[] | null, deniedP
  * Denial takes precedence over allowance. An empty `allowedOutlets` array means
  * "no outlets allowed" (strict whitelist).
  *
- * @param {string} outlet - The outlet name to check.
- * @param {string[]|null} allowedPatterns - Patterns for allowed outlets.
- * @param {string[]|null} deniedPatterns - Patterns for denied outlets.
- * @returns {{ permitted: boolean, reason?: string }}
- *   Returns permitted: true if allowed, or permitted: false with a reason if denied.
+ * @param outlet - The outlet name to check.
+ * @param allowedPatterns - Patterns for allowed outlets.
+ * @param deniedPatterns - Patterns for denied outlets.
+ * @returns Permitted: true if allowed, or permitted: false with a reason if denied.
  *
  * @example
+ * ```
  * // No restrictions
  * isBlockPermittedInOutlet("sidebar-blocks", null, null);
  * // { permitted: true }
+ * ```
  *
  * @example
+ * ```
  * // Allowed by pattern
  * isBlockPermittedInOutlet("sidebar-blocks", ["sidebar-*"], null);
  * // { permitted: true }
+ * ```
  *
  * @example
+ * ```
  * // Denied by pattern
  * isBlockPermittedInOutlet("sidebar-blocks", null, ["sidebar-*"]);
  * // { permitted: false, reason: 'outlet "sidebar-blocks" matches deniedOutlets pattern "sidebar-*"' }
+ * ```
  *
  * @example
+ * ```
  * // Not in allowed list
  * isBlockPermittedInOutlet("homepage-blocks", ["sidebar-*"], null);
  * // { permitted: false, reason: 'outlet "homepage-blocks" does not match any allowedOutlets pattern' }
+ * ```
  */
-export function isBlockPermittedInOutlet(outlet: string, allowedPatterns: string[] | null, deniedPatterns: string[] | null): {
-    permitted: boolean;
-    reason?: string;
-};
+export declare function isBlockPermittedInOutlet(outlet: string, allowedPatterns: string[] | null | undefined, deniedPatterns: string[] | null | undefined): OutletPermissionResult;
 /**
  * Warns if patterns don't match any known outlet (helps catch typos).
  *
@@ -158,14 +185,14 @@ export function isBlockPermittedInOutlet(outlet: string, allowedPatterns: string
  * Warnings are only printed in development builds (when DEBUG is true).
  * This prevents noise in production.
  *
- * @param {string[]|null} patterns - The patterns to check.
- * @param {string} blockName - Block name for warning messages.
- * @param {string} propertyName - Property name ("allowedOutlets" or "deniedOutlets").
+ * @param patterns - The patterns to check.
+ * @param blockName - Block name for warning messages.
+ * @param propertyName - Property name ("allowedOutlets" or "deniedOutlets").
  *
  * @example
  * // Warns about typo
  * warnUnknownOutletPatterns(["sidbar-*"], "my-block", "allowedOutlets");
  * // Console: [Blocks] Block "my-block": allowedOutlets pattern "sidbar-*" does not match any known outlet...
  */
-export function warnUnknownOutletPatterns(patterns: string[] | null, blockName: string, propertyName: string): void;
+export declare function warnUnknownOutletPatterns(patterns: string[] | null | undefined, blockName: string, propertyName: string): void;
 //# sourceMappingURL=outlet-matcher.d.ts.map

package/declarations/app/lib/blocks/-internals/matching/outlet-matcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"outlet-matcher.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/matching/outlet-matcher.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AACH,6CATW,MAAM,GACJ,OAAO,CAUnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,2CAzBW,MAAM,WACN,MAAM,GACJ,OAAO,CA2BnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,iDARW,GAAC,aACD,MAAM,gBACN,MAAM,QAuChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wDAfW,MAAM,EAAE,GAAC,IAAI,kBACb,MAAM,EAAE,GAAC,IAAI,GACX;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAuEhG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,iDA1BW,MAAM,mBACN,MAAM,EAAE,GAAC,IAAI,kBACb,MAAM,EAAE,GAAC,IAAI,GACX;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAmEnD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,oDATW,MAAM,EAAE,GAAC,IAAI,aACb,MAAM,gBACN,MAAM,QAkChB"}
+{"version":3,"file":"outlet-matcher.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/matching/outlet-matcher.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAC7B;IAAE,QAAQ,EAAE,KAAK,CAAA;CAAE,GACnB;IACE,QAAQ,EAAE,IAAI,CAAC;IACf,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9D,CAAC;AAEN;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAI3E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,IAAI,CAiCN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,sBAAsB,CACpC,eAAe,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,EAC5C,cAAc,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,GAC1C,qBAAqB,CA0DvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,EAC5C,cAAc,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,GAC1C,sBAAsB,CAwCxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,EACrC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,IAAI,CA2BN"}