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

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

@@ -0,0 +1,144 @@
+/**
+ * @typedef {Object} ValidationContext
+ * @property {string} outletName - The name of the outlet being validated.
+ * @property {string|null} [blockName=null] - The name of the block, if resolved.
+ * @property {string} path - The hierarchical path to this entry (e.g., "layout[0].children[1]").
+ * @property {Object|null} [entry=null] - The block entry object being validated.
+ * @property {Error|null} [callSiteError=null] - Error captured at the call site for stack traces.
+ * @property {Array|null} [rootLayout=null] - The root layout array for error display.
+ *
+ * The following properties are added by validation code after initial context creation:
+ * @property {string} [errorPath] - Full path to the error (e.g., "layout[0].conditions.params.categoryId").
+ * @property {string} [conditionsPath] - Path within conditions (e.g., "params.categoryId").
+ * @property {Object} [conditions] - The conditions object for error display.
+ */
+/**
+ * Creates a validation context object for error reporting.
+ * Centralizes context creation to ensure consistent structure across
+ * all validation functions.
+ *
+ * @param {Object} params - Context parameters.
+ * @param {string} params.outletName - The name of the outlet being validated.
+ * @param {string|null} [params.blockName=null] - The name of the block, if resolved.
+ * @param {string} params.path - The hierarchical path to this entry.
+ * @param {Object|null} [params.entry=null] - The block entry object being validated.
+ * @param {Error|null} [params.callSiteError=null] - Error captured at the call site.
+ * @param {Array|null} [params.rootLayout=null] - The root layout array for error display.
+ * @returns {ValidationContext} A validation context object.
+ */
+export function createValidationContext({ outletName, blockName, path, entry, callSiteError, rootLayout, }: {
+    outletName: string;
+    blockName?: string | null;
+    path: string;
+    entry?: any | null;
+    callSiteError?: Error | null;
+    rootLayout?: any[] | null;
+}): ValidationContext;
+/**
+ * Builds a hierarchical error path by joining path segments.
+ * Used to construct full paths for error messages (e.g., "layout[0].args.title").
+ *
+ * @param {string} basePath - The base path (e.g., "layout[0]").
+ * @param {string} segment - The segment to append (e.g., "args.title").
+ * @returns {string} Combined path with dot separator, or the non-empty path if one is missing.
+ *
+ * @example
+ * buildErrorPath("layout[0]", "args.title")
+ * // => "layout[0].args.title"
+ *
+ * buildErrorPath("", "args")
+ * // => "args"
+ */
+export function buildErrorPath(basePath: string, segment: string): string;
+/**
+ * Applies default values from block metadata to provided args.
+ *
+ * When a block is configured with args, this function merges the provided
+ * args with default values from the block's metadata schema. Default values
+ * are only applied when the arg is undefined in the provided args.
+ *
+ * @param {import("discourse/lib/blocks/-internals/registry/block").BlockClass} ComponentClass - The block component class.
+ * @param {Object} providedArgs - The args provided in the layout entry.
+ * @returns {Readonly<Object>} A new object with defaults applied for missing args.
+ *
+ * @example
+ * ```javascript
+ * // Block metadata: { args: { title: { default: "Hello" }, count: { default: 0 } } }
+ * applyArgDefaults(MyBlock, { title: "Custom" });
+ * // => { title: "Custom", count: 0 }
+ * ```
+ */
+export function applyArgDefaults(ComponentClass: import("discourse/lib/blocks/-internals/registry/block").BlockClass, providedArgs: any): Readonly<any>;
+/**
+ * Performs a shallow comparison of two args objects.
+ *
+ * Compares top-level values using strict equality (===). Does not perform
+ * deep comparison of nested objects. Used to determine if cached curried
+ * components can be reused.
+ *
+ * @param {Object|null|undefined} a - First args object.
+ * @param {Object|null|undefined} b - Second args object.
+ * @returns {boolean} True if the args are shallowly equal, false otherwise.
+ */
+export function shallowArgsEqual(a: any | null | undefined, b: any | null | undefined): boolean;
+/**
+ * Retrieves a value from a nested object using dot-notation path.
+ *
+ * This utility safely navigates through nested object properties using a
+ * dot-separated path string. It handles null/undefined values gracefully
+ * at any level of the path.
+ *
+ * @param {Object} obj - The object to get the value from.
+ * @param {string} path - Dot-notation path (e.g., "user.trust_level").
+ * @returns {*} The value at the path, or undefined if not found or if any
+ *              intermediate value is null/undefined.
+ *
+ * @example
+ * const user = { profile: { name: "Alice", settings: { theme: "dark" } } };
+ * getByPath(user, "profile.name"); // "Alice"
+ * getByPath(user, "profile.settings.theme"); // "dark"
+ * getByPath(user, "profile.missing"); // undefined
+ * getByPath(user, "profile.settings.missing.deep"); // undefined (safe)
+ */
+export function getByPath(obj: any, path: string): any;
+export type ValidationContext = {
+    /**
+     * - The name of the outlet being validated.
+     */
+    outletName: string;
+    /**
+     * - The name of the block, if resolved.
+     */
+    blockName?: string | null;
+    /**
+     * - The hierarchical path to this entry (e.g., "layout[0].children[1]").
+     */
+    path: string;
+    /**
+     * - The block entry object being validated.
+     */
+    entry?: any | null;
+    /**
+     * - Error captured at the call site for stack traces.
+     */
+    callSiteError?: Error | null;
+    /**
+     * - The root layout array for error display.
+     *
+     * The following properties are added by validation code after initial context creation:
+     */
+    rootLayout?: any[] | null;
+    /**
+     * - Full path to the error (e.g., "layout[0].conditions.params.categoryId").
+     */
+    errorPath?: string;
+    /**
+     * - Path within conditions (e.g., "params.categoryId").
+     */
+    conditionsPath?: string;
+    /**
+     * - The conditions object for error display.
+     */
+    conditions?: any;
+};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../discourse/app/lib/blocks/-internals/utils.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;GAaG;AACH,4GARG;IAAuB,UAAU,EAAzB,MAAM;IACe,SAAS,GAA9B,MAAM,GAAC,IAAI;IACI,IAAI,EAAnB,MAAM;IACe,KAAK,GAA1B,MAAO,IAAI;IACS,aAAa,GAAjC,KAAK,GAAC,IAAI;IACU,UAAU,GAA9B,QAAM,IAAI;CAClB,GAAU,iBAAiB,CAW7B;AAED;;;;;;;;;;;;;;GAcG;AACH,yCAXW,MAAM,WACN,MAAM,GACJ,MAAM,CAiBlB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,iDAXW,OAAO,gDAAgD,EAAE,UAAU,sBAEjE,QAAQ,KAAQ,CAwB5B;AAED;;;;;;;;;;GAUG;AACH,oCAJW,MAAO,IAAI,GAAC,SAAS,KACrB,MAAO,IAAI,GAAC,SAAS,GACnB,OAAO,CAenB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,0CAXW,MAAM,GACJ,GAAC,CA0Bb;;;;;gBA/Ja,MAAM;;;;gBACN,MAAM,GAAC,IAAI;;;;UACX,MAAM;;;;YACN,MAAO,IAAI;;;;oBACX,KAAK,GAAC,IAAI;;;;;;iBACV,QAAM,IAAI;;;;gBAGV,MAAM;;;;qBACN,MAAM"}

package/declarations/app/lib/blocks/-internals/validation/args.d.ts

@@ -0,0 +1,285 @@
+/**
+ * Checks if an argument name is reserved for internal use.
+ * Reserved names include explicit names in RESERVED_ARG_NAMES and
+ * any name starting with underscore (private by convention).
+ *
+ * @param {string} argName - The argument name to check
+ * @returns {boolean} True if the name is reserved
+ */
+export function isReservedArgName(argName: string): boolean;
+/**
+ * Validates a schema property against its rule.
+ *
+ * @param {Object} argDef - The argument definition.
+ * @param {string} argName - The argument name.
+ * @param {string} prop - The property name.
+ * @param {Object} [options] - Optional configuration.
+ * @param {string} [options.entityName] - The entity name for error messages.
+ * @param {string} [options.entityType="Block"] - The entity type for error messages.
+ */
+export function validateSchemaProperty(argDef: any, argName: string, prop: string, options?: {
+    entityName?: string;
+    entityType?: string;
+}): void;
+/**
+ * Validates that at most one of the specified schema properties is defined (mutually exclusive).
+ *
+ * @param {Object} argDef - The argument definition.
+ * @param {string} argName - The argument name for error messages.
+ * @param {string[]} properties - Array of property names that are mutually exclusive.
+ * @param {Object} [options] - Optional configuration.
+ * @param {string} [options.entityName] - The entity name for error messages.
+ * @param {string} [options.entityType="Block"] - The entity type (e.g., "Block", "Condition").
+ * @param {string} [options.argLabel="arg"] - Label for the argument (e.g., "arg", "childArgs arg").
+ * @param {string} [options.reason] - Custom reason message.
+ */
+export function validateMutuallyExclusive(argDef: any, argName: string, properties: string[], options?: {
+    entityName?: string;
+    entityType?: string;
+    argLabel?: string;
+    reason?: string;
+}): void;
+/**
+ * Validates a min/max range pair in the schema.
+ *
+ * @param {Object} argDef - The argument definition.
+ * @param {string} argName - The argument name.
+ * @param {string} minProp - The min property name.
+ * @param {string} maxProp - The max property name.
+ * @param {Object} [options] - Optional configuration.
+ * @param {string} [options.entityName] - The entity name for error messages.
+ * @param {string} [options.entityType="Block"] - The entity type for error messages.
+ */
+export function validateRangePair(argDef: any, argName: string, minProp: string, maxProp: string, options?: {
+    entityName?: string;
+    entityType?: string;
+}): void;
+/**
+ * Validates the common schema properties that are shared between blocks and conditions.
+ * This includes itemType, schema property rules, range pairs, enum, itemEnum, and required.
+ *
+ * Does NOT validate:
+ * - "type is required" - blocks require it, conditions allow empty schemas for "any type"
+ * - "default" validation - blocks validate default values, conditions reject the property entirely
+ * - "required + default contradiction" - only relevant for blocks
+ *
+ * @param {Object} argDef - The argument definition.
+ * @param {string} argName - The argument name.
+ * @param {Object} [options] - Optional configuration.
+ * @param {string} [options.entityName] - The entity name for error messages.
+ * @param {string} [options.entityType="Block"] - The entity type for error messages.
+ */
+export function validateCommonSchemaProperties(argDef: any, argName: string, options?: {
+    entityName?: string;
+    entityType?: string;
+}): void;
+/**
+ * Validates an argument name format.
+ *
+ * @param {string} argName - The argument name to validate.
+ * @param {Object} [options] - Optional configuration.
+ * @param {string} [options.entityName] - The entity name for error messages.
+ * @param {string} [options.entityType="Block"] - The entity type for error messages.
+ * @param {string} [options.argLabel="arg"] - Label for error messages (e.g., "childArgs arg").
+ * @returns {boolean} True if valid, false if invalid (and error raised).
+ */
+export function validateArgName(argName: string, options?: {
+    entityName?: string;
+    entityType?: string;
+    argLabel?: string;
+}): boolean;
+/**
+ * Validates a single arg schema entry (argDef).
+ * Shared logic between block args, childArgs, and condition args validation.
+ *
+ * @param {Object} argDef - The argument definition.
+ * @param {string} argName - The argument name.
+ * @param {Object} options - Configuration options.
+ * @param {string} [options.entityName] - The entity name for error messages.
+ * @param {string} [options.entityType="Block"] - The entity type for error messages.
+ * @param {readonly string[]} options.validProperties - List of valid schema properties.
+ * @param {Object<string, string>} [options.disallowedProperties={}] - Map of property names to their
+ *   specific error messages. Properties in this map trigger a "disallowed" error instead of "unknown".
+ * @param {boolean} [options.allowAnyType=false] - If true, allow type: "any" (for conditions only).
+ * @param {string} [options.argLabel="arg"] - Label for error messages (e.g., "childArgs arg").
+ * @returns {boolean} True if validation should continue with caller-specific logic, false if
+ *   validation should stop (e.g., missing type, type: "any" with allowAnyType).
+ */
+export function validateArgSchemaEntry(argDef: any, argName: string, options: {
+    entityName?: string;
+    entityType?: string;
+    validProperties: readonly string[];
+    disallowedProperties?: {
+        [x: string]: string;
+    };
+    allowAnyType?: boolean;
+    argLabel?: string;
+}): boolean;
+/**
+ * Validates a single argument value against its schema definition.
+ *
+ * @param {*} value - The argument value.
+ * @param {Object} argSchema - The schema definition for this arg.
+ * @param {string} argName - The argument name for error messages.
+ * @param {Object} [options] - Optional configuration.
+ * @param {string|null} [options.contextName] - Optional entity name for context.
+ * @param {string} [options.contextType] - The entity type for error prefix (e.g., "Block", "Condition").
+ * @param {Object} [options.owner] - Ember owner for registry lookups (used for "model:*" instanceOf).
+ * @returns {ValidationError|null} Validation error if validation fails, null otherwise.
+ */
+export function validateArgValue(value: any, argSchema: any, argName: string, options?: {
+    contextName?: string | null;
+    contextType?: string;
+    owner?: any;
+}): ValidationError | null;
+/**
+ * Validates an array item against the specified item type.
+ *
+ * @param {*} item - The array item.
+ * @param {string} itemType - The expected type ("string", "number", "boolean").
+ * @param {string} argName - The argument name for error messages.
+ * @param {number} index - The array index for error messages.
+ * @param {Object} [options] - Optional configuration.
+ * @param {string|null} [options.contextName] - Optional entity name for context.
+ * @param {string} [options.contextType] - The entity type for error prefix (e.g., "Block", "Condition").
+ * @returns {ValidationError|null} Validation error if validation fails, null otherwise.
+ */
+export function validateArrayItemType(item: any, itemType: string, argName: string, index: number, options?: {
+    contextName?: string | null;
+    contextType?: string;
+}): ValidationError | null;
+/**
+ * Validates provided arguments against a schema.
+ * This is the core validation logic used by both block args and container args validation.
+ *
+ * Validation order:
+ * 1. Check for unknown args (catches typos before missing required)
+ * 2. Check required args
+ * 3. Validate type if value is provided
+ *
+ * The unknown args check is done FIRST so that typos like "nam" produce
+ * "unknown arg 'nam' (did you mean 'name'?)" instead of "missing required arg 'name'".
+ *
+ * @param {Object} providedArgs - The arguments to validate.
+ * @param {Object} schema - The schema to validate against.
+ * @param {string} pathPrefix - Prefix for error paths (e.g., "args" or "containerArgs").
+ * @param {Object} [options={}] - Optional configuration.
+ * @param {Object} [options.owner] - Ember owner for registry lookups (used for "model:*" instanceOf).
+ * @throws {BlockError} If validation fails.
+ */
+export function validateArgsAgainstSchema(providedArgs: any, schema: any, pathPrefix: string, options?: {
+    owner?: any;
+}): void;
+/**
+ * A validation error result containing the error message and the path
+ * to the argument that failed validation.
+ *
+ * @typedef {Object} ValidationError
+ * @property {string} message - The formatted error message.
+ * @property {string} path - The path to the invalid argument (e.g., "test.name").
+ */
+/**
+ * Valid arg name pattern: must be a valid JavaScript identifier.
+ * Starts with a letter, followed by letters, numbers, or underscores.
+ * Note: Names starting with underscore are reserved for internal use.
+ */
+export const VALID_ARG_NAME_PATTERN: RegExp;
+/**
+ * Reserved argument names that cannot be used in block/condition arg schemas.
+ * These are used internally by the block system and would conflict with
+ * user-provided args. Names starting with underscore are also reserved.
+ */
+export const RESERVED_ARG_NAMES: readonly string[];
+/**
+ * Valid arg types for schema definitions.
+ */
+export const VALID_ARG_TYPES: readonly string[];
+/**
+ * Valid item types for array args.
+ */
+export const VALID_ITEM_TYPES: readonly string[];
+/**
+ * Valid properties for arg schema definitions.
+ */
+export const VALID_ARG_SCHEMA_PROPERTIES: readonly string[];
+/**
+ * Schema property rules for declarative validation.
+ * Each rule defines:
+ * - allowedTypes: arg types that can use this property
+ * - valueCheck: function to validate the property value
+ * - valueError: error message if value check fails
+ * - typeErrorSuffix: text to append for type restriction errors (e.g., "string or array")
+ */
+export const SCHEMA_PROPERTY_RULES: Readonly<{
+    min: {
+        allowedTypes: string[];
+        valueCheck: (v: any) => v is number;
+        valueError: string;
+        typeErrorSuffix: string;
+    };
+    max: {
+        allowedTypes: string[];
+        valueCheck: (v: any) => v is number;
+        valueError: string;
+        typeErrorSuffix: string;
+    };
+    integer: {
+        allowedTypes: string[];
+        valueCheck: (v: any) => v is boolean;
+        valueError: string;
+        typeErrorSuffix: string;
+    };
+    minLength: {
+        allowedTypes: string[];
+        valueCheck: (v: any) => boolean;
+        valueError: string;
+        typeErrorSuffix: string;
+    };
+    maxLength: {
+        allowedTypes: string[];
+        valueCheck: (v: any) => boolean;
+        valueError: string;
+        typeErrorSuffix: string;
+    };
+    pattern: {
+        allowedTypes: string[];
+        valueCheck: (v: any) => v is RegExp;
+        valueError: string;
+        typeErrorSuffix: string;
+    };
+    itemType: {
+        allowedTypes: string[];
+        typeErrorSuffix: string;
+    };
+    enum: {
+        allowedTypes: string[];
+        typeErrorSuffix: string;
+    };
+    itemEnum: {
+        allowedTypes: string[];
+        typeErrorSuffix: string;
+    };
+    properties: {
+        allowedTypes: string[];
+        typeErrorSuffix: string;
+    };
+    instanceOf: {
+        allowedTypes: string[];
+        typeErrorSuffix: string;
+    };
+}>;
+/**
+ * A validation error result containing the error message and the path
+ * to the argument that failed validation.
+ */
+export type ValidationError = {
+    /**
+     * - The formatted error message.
+     */
+    message: string;
+    /**
+     * - The path to the invalid argument (e.g., "test.name").
+     */
+    path: string;
+};
+//# sourceMappingURL=args.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/validation/args.js"],"names":[],"mappings":"AAuDA;;;;;;;GAOG;AACH,2CAHW,MAAM,GACJ,OAAO,CAInB;AAgHD;;;;;;;;;GASG;AACH,6DANW,MAAM,QACN,MAAM,YAEd;IAAyB,UAAU,GAA3B,MAAM;IACW,UAAU,GAA3B,MAAM;CAChB,QAuBA;AAED;;;;;;;;;;;GAWG;AACH,gEARW,MAAM,cACN,MAAM,EAAE,YAEhB;IAAyB,UAAU,GAA3B,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,QAAQ,GAAzB,MAAM;IACW,MAAM,GAAvB,MAAM;CAChB,QA2BA;AAED;;;;;;;;;;GAUG;AACH,wDAPW,MAAM,WACN,MAAM,WACN,MAAM,YAEd;IAAyB,UAAU,GAA3B,MAAM;IACW,UAAU,GAA3B,MAAM;CAChB,QAmBA;AAwCD;;;;;;;;;;;;;;GAcG;AACH,qEALW,MAAM,YAEd;IAAyB,UAAU,GAA3B,MAAM;IACW,UAAU,GAA3B,MAAM;CAChB,QAuIA;AAID;;;;;;;;;GASG;AACH,yCAPW,MAAM,YAEd;IAAyB,UAAU,GAA3B,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,QAAQ,GAAzB,MAAM;CACd,GAAU,OAAO,CAuBnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,6DAZW,MAAM,WAEd;IAAyB,UAAU,GAA3B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe,EAA1C,SAAS,MAAM,EAAE;IACgB,oBAAoB,GAArD;YAAO,MAAM,GAAE,MAAM;KAAC;IAEJ,YAAY,GAA9B,OAAO;IACU,QAAQ,GAAzB,MAAM;CACd,GAAU,OAAO,CA8EnB;AAyBD;;;;;;;;;;;GAWG;AACH,wCATW,GAAC,2BAED,MAAM,YAEd;IAA8B,WAAW,GAAjC,MAAM,GAAC,IAAI;IACM,WAAW,GAA5B,MAAM;IACW,KAAK;CAC9B,GAAU,eAAe,GAAC,IAAI,CAyRhC;AAED;;;;;;;;;;;GAWG;AACH,4CATW,GAAC,YACD,MAAM,WACN,MAAM,SACN,MAAM,YAEd;IAA8B,WAAW,GAAjC,MAAM,GAAC,IAAI;IACM,WAAW,GAA5B,MAAM;CACd,GAAU,eAAe,GAAC,IAAI,CA4ChC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,sFALW,MAAM,YAEd;IAAyB,KAAK;CAC9B,QAwCF;AAj/BD;;;;;;;GAOG;AAEH;;;;GAIG;AACH,4CAAgE;AAEhE;;;;GAIG;AACH,mDAYG;AAcH;;GAEG;AACH,gDAOG;AAEH;;GAEG;AACH,iDAA+E;AAE/E;;GAEG;AACH,4DAgBG;AAEH;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;;;;;;;;;aAtJW,MAAM;;;;UACN,MAAM"}

package/declarations/app/lib/blocks/-internals/validation/block-args.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Validates the arg schema definition passed to the @block decorator.
+ * Enforces strict schema format - unknown properties are not allowed.
+ *
+ * @param {Object} argsSchema - The args schema object from decorator options.
+ * @param {string} blockName - Block name for error messages.
+ * @throws {Error} If schema is invalid.
+ */
+export function validateArgsSchema(argsSchema: any, blockName: string): void;
+/**
+ * Validates block arguments against the block's metadata arg schema.
+ * Checks for required args and validates types.
+ *
+ * @param {Object} entry - The block entry.
+ * @param {Object} blockClass - The resolved block class (must be a class, not a string reference).
+ * @param {Object} [options={}] - Optional configuration.
+ * @param {Object} [options.owner] - Ember owner for registry lookups (used for "model:*" instanceOf).
+ * @throws {BlockError} If args are invalid.
+ */
+export function validateBlockArgs(entry: any, blockClass: any, options?: {
+    owner?: any;
+}): void;
+/**
+ * Validates the childArgs schema definition passed to the @block decorator.
+ * Similar to validateArgsSchema but supports the additional "unique" property
+ * for enforcing uniqueness across sibling children.
+ *
+ * @param {Object} childArgsSchema - The childArgs schema object from decorator options.
+ * @param {string} blockName - Block name for error messages.
+ * @throws {Error} If schema is invalid.
+ */
+export function validateChildArgsSchema(childArgsSchema: any, blockName: string): void;
+/**
+ * Valid properties for childArgs schema definitions.
+ * Includes all standard arg properties plus "unique" for sibling uniqueness validation.
+ */
+export const VALID_CHILD_ARG_SCHEMA_PROPERTIES: readonly string[];
+//# sourceMappingURL=block-args.d.ts.map

package/declarations/app/lib/blocks/-internals/validation/block-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-args.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/validation/block-args.js"],"names":[],"mappings":"AAyEA;;;;;;;GAOG;AACH,+DAHW,MAAM,QA2BhB;AAED;;;;;;;;;GASG;AACH,yEAHG;IAAyB,KAAK;CAC9B,QAwBF;AAED;;;;;;;;GAQG;AACH,yEAHW,MAAM,QA+ChB;AAxKD;;;GAGG;AACH,kEAGG"}

package/declarations/app/lib/blocks/-internals/validation/block-decorator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Validates the options object passed to the @block decorator.
+ * Checks for unknown keys and provides suggestions for typos.
+ *
+ * @param {string} name - The block name (for error messages).
+ * @param {Object} options - The options object to validate.
+ */
+export function validateBlockOptions(name: string, options: any): void;
+/**
+ * Validates and parses the block name.
+ * Ensures the name follows the required format for core, plugin, or theme blocks.
+ *
+ * @param {string} name - The block name to validate.
+ * @returns {import("discourse/lib/blocks/-internals/patterns").ParsedBlockName} Parsed name components.
+ */
+export function validateAndParseBlockName(name: string): import("discourse/lib/blocks/-internals/patterns").ParsedBlockName;
+/**
+ * Validates outlet restriction patterns (allowedOutlets and deniedOutlets).
+ * Checks for valid picomatch syntax and detects conflicts between patterns.
+ *
+ * @param {string} name - The block name (for error messages).
+ * @param {string[]|null} allowedOutlets - Allowed outlet patterns.
+ * @param {string[]|null} deniedOutlets - Denied outlet patterns.
+ */
+export function validateOutletRestrictions(name: string, allowedOutlets: string[] | null, deniedOutlets: string[] | null): void;
+/**
+ * Valid keys for the @block decorator options (block schema).
+ *
+ * @constant {ReadonlyArray<string>}
+ */
+export const VALID_BLOCK_OPTIONS: readonly string[];
+//# sourceMappingURL=block-decorator.d.ts.map

package/declarations/app/lib/blocks/-internals/validation/block-decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-decorator.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/validation/block-decorator.js"],"names":[],"mappings":"AAmCA;;;;;;GAMG;AACH,2CAHW,MAAM,sBAkBhB;AAED;;;;;;GAMG;AACH,gDAHW,MAAM,GACJ,OAAO,0CAA0C,EAAE,eAAe,CAkB9E;AAED;;;;;;;GAOG;AACH,iDAJW,MAAM,kBACN,MAAM,EAAE,GAAC,IAAI,iBACb,MAAM,EAAE,GAAC,IAAI,QA4BvB;AApGD;;;;GAIG;AACH,oDAUG"}

package/declarations/app/lib/blocks/-internals/validation/condition-args.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Validates the arg schema definition passed to the @blockCondition decorator.
+ * Enforces strict schema format - unknown properties are not allowed.
+ * Called at decoration time to catch schema errors early.
+ *
+ * @param {Object} argsSchema - The args schema object from decorator options.
+ * @param {string} conditionType - Condition type name for error messages.
+ * @throws {Error} If schema is invalid.
+ */
+export function validateConditionArgsSchema(argsSchema: any, conditionType: string): void;
+/**
+ * Validates provided arg values against the condition's schema.
+ * Called at block registration time to catch invalid values early.
+ *
+ * @param {Object} args - The arguments provided to the condition.
+ * @param {Object} argsSchema - The condition's args schema.
+ * @param {string} conditionType - The condition type for error messages.
+ * @param {string} path - The path to this condition in the block tree.
+ * @throws {BlockError} If validation fails.
+ */
+export function validateConditionArgValues(args: any, argsSchema: any, conditionType: string, path: string): void;
+/**
+ * Valid properties for condition arg schemas.
+ * Includes all standard arg properties except those in DISALLOWED_CONDITION_PROPERTIES.
+ */
+export const VALID_CONDITION_ARG_PROPERTIES: readonly string[];
+//# sourceMappingURL=condition-args.d.ts.map

package/declarations/app/lib/blocks/-internals/validation/condition-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition-args.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/validation/condition-args.js"],"names":[],"mappings":"AAyCA;;;;;;;;GAQG;AACH,4EAHW,MAAM,QA2BhB;AAcD;;;;;;;;;GASG;AACH,sFAJW,MAAM,QACN,MAAM,QAsChB;AAtGD;;;GAGG;AACH,+DAIE"}

package/declarations/app/lib/blocks/-internals/validation/conditions.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Validates the `source` parameter based on the condition's `sourceType`.
+ *
+ * - `sourceType: "none"`: Returns error if `source` is provided
+ * - `sourceType: "outletArgs"`: Validates format is `@outletArgs.propertyPath`
+ * - `sourceType: "object"`: Validates `source` is an object if provided
+ *
+ * @param {"none"|"outletArgs"|"object"} sourceType - The condition's source type.
+ * @param {Object} args - The condition arguments from the layout entry.
+ * @returns {{ message: string, path?: string } | null} Error info or null if valid.
+ */
+export function validateConditionSource(sourceType: "none" | "outletArgs" | "object", args: any): {
+    message: string;
+    path?: string;
+} | null;
+/**
+ * Validates that all provided args are recognized by a condition.
+ * Suggests corrections for typos using fuzzy string matching.
+ *
+ * @param {import("discourse/blocks/conditions").BlockCondition} instance - The condition instance.
+ * @param {string} type - The condition type name.
+ * @param {Object} args - The args provided to the condition.
+ * @param {string} path - The path to this condition in the block tree.
+ * @throws {BlockError} If an unrecognized arg key is found.
+ */
+export function validateConditionArgKeys(instance: import("discourse/blocks/conditions").BlockCondition, type: string, args: any, path: string): void;
+/**
+ * Validates condition specs at block registration time.
+ * Recursively validates nested conditions in `any` and `not` combinators.
+ *
+ * Throws BlockError objects with a `path` property indicating where in the
+ * conditions the error occurred. Callers can use this path combined with
+ * their context path to build full error location.
+ *
+ * Note: Paths are constructed via simple string concatenation (e.g.,
+ * `${path}.${key}`, `${path}[${i}]`). Keys are not escaped, so special
+ * characters in user-provided keys may cause confusing path displays.
+ * This is acceptable since condition keys come from theme/plugin layouts
+ * where unusual characters are rare.
+ *
+ * @param {Object|Array<Object>} conditionSpec - Condition spec(s) to validate.
+ * @param {Map<string, import("discourse/blocks/conditions").BlockCondition>} conditionTypes - Map of registered condition types.
+ * @param {string} [path=""] - The path to this condition relative to conditions root
+ *   (e.g., "", "[0]", "any[1]", "params.categoryId").
+ * @throws {BlockError} If validation fails.
+ */
+export function validateConditions(conditionSpec: any | Array<any>, conditionTypes: Map<string, import("discourse/blocks/conditions").BlockCondition>, path?: string): void;
+//# sourceMappingURL=conditions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/validation/conditions.js"],"names":[],"mappings":"AAeA;;;;;;;;;;GAUG;AACH,oDAJW,MAAM,GAAC,YAAY,GAAC,QAAQ,cAE1B;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA0CrD;AAED;;;;;;;;;GASG;AACH,mDANW,OAAO,6BAA6B,EAAE,cAAc,QACpD,MAAM,mBAEN,MAAM,QAmBhB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,kDANW,MAAO,KAAK,KAAQ,kBACpB,GAAG,CAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC,SACjE,MAAM,QA+BhB"}

package/declarations/app/lib/blocks/-internals/validation/constraints.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Validates the constraints schema at decoration time.
+ * Checks for:
+ * - Valid constraint types
+ * - Arg references exist in the args schema
+ * - Constraint arrays have at least 2 elements
+ * - Incompatible constraints (exactlyOne + allOrNone, exactlyOne + atLeastOne)
+ * - Vacuous constraints (constraints rendered always true/false by defaults)
+ *
+ * @param {Object} constraints - The constraints object from decorator options.
+ * @param {Object} argsSchema - The args schema object from decorator options.
+ * @param {string} blockName - Block name for error messages.
+ */
+export function validateConstraintsSchema(constraints: any, argsSchema: any, blockName: string): void;
+/**
+ * Validates constraints against the provided args at runtime.
+ * Called after defaults are applied.
+ *
+ * @param {Object} constraints - The constraints from block metadata.
+ * @param {Object} args - The resolved args (with defaults applied).
+ * @param {string} blockName - Block name for error messages.
+ * @returns {string|null} Error message if validation fails, null otherwise.
+ */
+export function validateConstraints(constraints: any, args: any, blockName: string): string | null;
+/**
+ * Runs a custom validation function if provided.
+ *
+ * @param {Function} validateFn - The custom validate function.
+ * @param {Object} args - The resolved args (with defaults applied).
+ * @returns {string[]|null} Array of error messages if validation fails, null otherwise.
+ */
+export function runCustomValidation(validateFn: Function, args: any): string[] | null;
+/**
+ * Valid constraint types for cross-arg validation.
+ */
+export const VALID_CONSTRAINT_TYPES: readonly string[];
+//# sourceMappingURL=constraints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../../../../../../../discourse/app/lib/blocks/-internals/validation/constraints.js"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;GAYG;AACH,wFAFW,MAAM,QAmHhB;AAkID;;;;;;;;GAQG;AACH,4EAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAuCvB;AAiHD;;;;;;GAMG;AACH,sEAFa,MAAM,EAAE,GAAC,IAAI,CA0BzB;AAndD;;GAEG;AACH,uDAMG"}