@loozo/angular-router 0.0.7 → 0.0.9

package/types/loozo-angular-router-_core.d.ts

@@ -8,7 +8,8 @@ import { Observable } from "rxjs";
  * like Angular's matching callbacks, it runs once while matching and again for
  * the activated route. Neither method performs URL encoding. Codecs have no
  * Angular injection context, and their returned objects are not recursively frozen.
- * For a terminal `$name[]` path, this codec applies to each element separately.
+ * For a terminal `$name[]` path or an `arrayParam` search key, this codec applies
+ * to each element separately.
  *
  * @typeParam Value - The logical value, never a promise of that value.
  *
@@ -28,7 +29,8 @@ interface ParamCodec<Value> {
    * @returns The logical value, synchronously. Returning a promise or other
    * thenable is a programming error that fails the navigation with a TypeError.
    * @throws An application error for invalid input: an invalid path value makes
-   * the route not match, and an invalid search value reads as absent or as its fallback.
+   * the route not match, and an invalid search value reads as absent or as its fallback
+   * (an `arrayParam` key reads an empty array).
    */
   parse(raw: string): Value;
   /**
@@ -41,6 +43,7 @@ interface ParamCodec<Value> {
   stringify(value: Value): string;
 }
 declare const searchFallback: unique symbol;
+declare const searchArray: unique symbol;
 /**
  * A search-only codec whose key reads a fallback value when it is missing,
  * repeated or invalid, while URL creation may still omit it.
@@ -48,13 +51,26 @@ declare const searchFallback: unique symbol;
 type FallbackCodec<Value> = ParamCodec<Value> & {
   readonly [searchFallback]: true;
 };
-type PathCodec = ParamCodec<any> & {
+/**
+ * A search-only codec whose key reads every repeated value, in URL order, as a
+ * readonly array; its parse and stringify handle one value each.
+ */
+type ArrayCodec<Value> = ParamCodec<Value> & {
+  readonly [searchArray]: true;
+};
+/** Codecs that may only wrap a plain codec: not a fallback or array codec. */
+type PlainCodec = {
   readonly [searchFallback]?: never;
+  readonly [searchArray]?: never;
 };
+type PathCodec = ParamCodec<any> & PlainCodec;
 type CodecValue<Codec> = Codec extends ParamCodec<infer Value> ? Value : never;
 type HasFallback<Codec> = Codec extends {
   readonly [searchFallback]: true;
 } ? true : false;
+type IsArray<Codec> = Codec extends {
+  readonly [searchArray]: true;
+} ? true : false;
 /** Type-only marker: a codec whose parse returns a promise fails where it is declared. */
 interface SynchronousParse {
   /** Never present: `parse` must return its value synchronously, not a Promise. */
@@ -68,6 +84,7 @@ type SyncCodecs<Codecs> = { [Key in keyof Codecs]: SyncValue<ParseResult<Codecs[
 export declare function codecFallback(codec: object): {
   readonly value: unknown;
 } | undefined;
+export declare function isArrayCodec(codec: object): boolean;
 declare function validateCodec(codec: unknown): asserts codec is ParamCodec<any>;
 /**
  * Preserves strings verbatim, including empty strings and literal percent text.
@@ -115,7 +132,8 @@ export declare function enumParam<const Values extends readonly string[]>(values
  * value of the codec's type, while URL creation, links, navigation and redirect
  * replacements may still omit it. The fallback is returned as is: it is neither
  * parsed nor copied. Present values delegate to the wrapped codec unchanged.
- * Fallback codecs are search-only: a path param can't use one.
+ * Fallback codecs are search-only: a path param can't use one, and neither
+ * `withFallback` nor `arrayParam` can wrap one.
  *
  * @example
  * ```ts
@@ -127,10 +145,36 @@ export declare function enumParam<const Values extends readonly string[]>(values
  * @param codec - The codec used for present search values.
  * @param fallback - The value read when the key is missing, repeated or invalid.
  * @returns A search-only codec that reads the fallback in place of an absent value.
- * @throws TypeError if the codec lacks callable parse/stringify methods or already
- * has a fallback.
+ * @throws TypeError if the codec lacks callable parse/stringify methods, already
+ * has a fallback or is an `arrayParam` codec.
+ */
+export declare function withFallback<Value>(codec: ParamCodec<Value> & SyncValue<NoInfer<Value>> & PlainCodec, fallback: NoInfer<Value>): FallbackCodec<Value>;
+/**
+ * Reads every value of a repeated search key (`?tag=a&tag=b`) as a readonly array.
+ *
+ * @remarks
+ * The key always reads an array, never `undefined`: each value parses with the
+ * wrapped codec, in URL order and keeping duplicates. A missing key reads `[]`, and
+ * so does a key with any invalid value: one invalid value empties the whole list.
+ * URL creation, links, navigation and redirect replacements write one `key=value`
+ * pair per element in array order; `[]` and `undefined` leave the key out, so an
+ * empty list and a missing key share one URL. Array codecs are search-only (a path
+ * uses a terminal `$name[]` instead) and take no fallback: `withFallback` can't wrap
+ * one, and `arrayParam` can't wrap a fallback or another array codec.
+ *
+ * @example
+ * ```ts
+ * search: { tag: arrayParam(enumParam(["news", "guides"])) }
+ * // ?tag=news&tag=guides reads ["news", "guides"]; no tag and ?tag=other read [].
+ * ```
+ *
+ * @typeParam Value - The wrapped codec's logical value.
+ * @param codec - The codec for each value.
+ * @returns A search-only codec whose key reads `readonly Value[]`.
+ * @throws TypeError if the codec lacks callable parse/stringify methods, has a
+ * fallback or is already an array codec.
  */
-export declare function withFallback<Value>(codec: ParamCodec<Value> & SyncValue<NoInfer<Value>>, fallback: NoInfer<Value>): FallbackCodec<Value>;
+export declare function arrayParam<Value>(codec: ParamCodec<Value> & SyncValue<NoInfer<Value>> & PlainCodec): ArrayCodec<Value>;
 type ValidName<Name extends string> = Name extends "" | "__proto__" | `...${string}` | `${string}?${string}` | `${string}*${string}` | `${string}[]${string}` ? false : true;
 type SegmentValid<Segment extends string> = Segment extends `$${infer Name}` ? ValidName<Name> : Segment extends "" | "." | ".." | "*" | "**" | `:${string}` ? false : true;
 type ValidateSegments<Path extends string, Scalars extends string = never> = Path extends `${infer Head}/${infer Tail}` ? Head extends `$${string}[]` ? false : SegmentValid<Head> extends true ? ValidateSegments<Tail, Scalars | ScalarName<Head>> : false : Path extends `$${infer Name}[]` ? ValidName<Name> extends true ? Name extends Scalars ? false : true : false : SegmentValid<Path>;
@@ -153,20 +197,25 @@ declare const routeBrand: unique symbol;
  *
  * @remarks
  * Prefer inference from `defineRoute` over explicit generic arguments. The
- * optional `__params`, `__search` and `__data` members are type witnesses only;
+ * optional `__params`, `__search`, `__data` and `__title` members are type witnesses only;
  * they are not populated runtime properties. Parent/codec/effective-path metadata
  * is private. Spreading a declaration does not produce another valid route.
  *
  * @typeParam Path - The local authored path literal, not the effective URL path.
  * @typeParam Params - Effective inherited and local logical path values.
  * @typeParam Search - Effective inherited and local logical search values; keys
- * without a fallback are optional. URL creation accepts every key as optional.
+ * without a fallback or array codec are optional. URL creation accepts every key as optional.
  * @typeParam Resolvers - Local resolver callbacks; data unwraps Promise/Observable
  * results and excludes Angular RedirectCommand values.
  * @typeParam Fragments - This declaration's own allowed fragment-name union.
  * @typeParam Catchall - Whether the declaration is a terminal catchall leaf.
+ * @typeParam Data - Effective resolver data: the ancestors' resolver results, then
+ * this declaration's own, a nearer key hiding an ancestor's key of the same name.
+ * Defaults to the local results alone.
+ * @typeParam Title - `string` when this declaration or an ancestor declares a title,
+ * otherwise `undefined`.
  */
-interface Route<Path extends string, Params, Search, Resolvers = {}, Fragments extends string = string, Catchall extends boolean = CatchallName<Path> extends never ? false : true> {
+interface Route<Path extends string, Params, Search, Resolvers = {}, Fragments extends string = string, Catchall extends boolean = CatchallName<Path> extends never ? false : true, Data = LocalData<Resolvers>, Title extends string | undefined = undefined> {
   /** Type-only nominal brand carrying fragment and catchall metadata; not populated at runtime. */
   readonly [routeBrand]: {
     /** Type-only: this declaration's own allowed fragment-name union. */
@@ -180,8 +229,10 @@ interface Route<Path extends string, Params, Search, Resolvers = {}, Fragments e
   readonly __params?: Params;
   /** Type-only witness for effective search values; not populated at runtime. */
   readonly __search?: Search;
-  /** Type-only witness for unwrapped local resolver data, excluding redirects. */
-  readonly __data?: { readonly [Key in keyof Resolvers]: Resolved<Resolvers[Key]>; };
+  /** Type-only witness for unwrapped effective resolver data, excluding redirects. */
+  readonly __data?: Data;
+  /** Type-only witness: string when this declaration or an ancestor declares a title. */
+  readonly __title?: Title;
   /** The snapshotted local resolver map, retaining original callback identities. */
   readonly resolve?: Readonly<Resolvers>;
   /** The original native rerun policy; omission preserves Angular's default. */
@@ -189,23 +240,42 @@ interface Route<Path extends string, Params, Search, Resolvers = {}, Fragments e
 }
 type Unwrap<Value> = Value extends Promise<infer Inner> | Observable<infer Inner> ? Unwrap<Inner> : Value;
 type Resolved<Callback> = Callback extends ((...args: any[]) => infer Value) ? Exclude<Unwrap<Value>, RedirectCommand> : never;
-type AnyRoute = Route<string, any, any, any, any, boolean>;
+type AnyRoute = Route<string, any, any, any, any, boolean, any, any>;
 /** Extracts a declaration's effective inherited and local path-value types. */
-type ParamsOf<Target> = Target extends Route<string, infer Params, any, any, any, boolean> ? Params : {};
-/** Extracts effective parsed search-value types; keys without a fallback are optional. */
-type SearchOf<Target> = Target extends Route<string, any, infer Search, any, any, boolean> ? Search : {};
+type ParamsOf<Target> = Target extends Route<string, infer Params, any, any, any, boolean, any, any> ? Params : {};
+/** Extracts effective parsed search-value types; keys without a fallback or array codec are optional. */
+type SearchOf<Target> = Target extends Route<string, any, infer Search, any, any, boolean, any, any> ? Search : {};
 /**
  * Effective search values accepted by URL creation: every key may be omitted or
  * `undefined`, and a supplied value has the key's codec type.
  */
 type SearchInputOf<Target> = { readonly [Key in keyof SearchOf<Target>]?: SearchOf<Target>[Key] | undefined; };
 /** Extracts only the selected declaration's own allowed fragment-name union. */
-type FragmentsOf<Target> = Target extends Route<string, any, any, any, infer Fragments, boolean> ? Fragments : never;
+type FragmentsOf<Target> = Target extends Route<string, any, any, any, infer Fragments, boolean, any, any> ? Fragments : never;
 type CodecMap = Record<string, ParamCodec<any>>;
 type LocalParams<Path extends string, Codecs> = { readonly [Key in keyof Codecs]: Key extends CatchallName<Path> ? readonly CodecValue<Codecs[Key]>[] : CodecValue<Codecs[Key]>; };
-type SearchValues<Codecs> = { readonly [Key in keyof Codecs as HasFallback<Codecs[Key]> extends true ? Key : never]: CodecValue<Codecs[Key]>; } & { readonly [Key in keyof Codecs as HasFallback<Codecs[Key]> extends true ? never : Key]?: CodecValue<Codecs[Key]>; };
+type SearchValue<Codec> = IsArray<Codec> extends true ? readonly CodecValue<Codec>[] : CodecValue<Codec>;
+type AlwaysReads<Codec> = HasFallback<Codec> extends true ? true : IsArray<Codec>;
+type SearchValues<Codecs> = { readonly [Key in keyof Codecs as AlwaysReads<Codecs[Key]> extends true ? Key : never]: SearchValue<Codecs[Key]>; } & { readonly [Key in keyof Codecs as AlwaysReads<Codecs[Key]> extends true ? never : Key]?: SearchValue<Codecs[Key]>; };
 type EffectiveParams<Path extends string, Codecs, Parent> = ParamsOf<Parent> & LocalParams<Path, Codecs>;
 type EffectiveSearch<Codecs, Parent> = SearchOf<Parent> & SearchValues<Codecs>;
+/** Unwrapped results of a declaration's own resolvers, excluding redirects. */
+type LocalData<Resolvers> = { readonly [Key in keyof Resolvers]: Resolved<Resolvers[Key]>; };
+/**
+ * Resolver data of a declaration's whole chain: the parent's effective data with
+ * the local results laid over it, so a local key hides an inherited key of the same name.
+ */
+type EffectiveData<Resolvers, Parent> = Unshadowed<Parent extends {
+  readonly __data?: infer Data;
+} ? Data : {}, keyof Resolvers> & LocalData<Resolvers>;
+/** The title type of a declaration's chain: string when it or an ancestor declares one. */
+type TitleOf<Target> = Target extends {
+  readonly __title?: infer Title;
+} ? Title : undefined;
+/** A local title makes the chain's title a string; otherwise the parent's title type carries over. */
+type EffectiveTitle<LocalTitle, Parent> = unknown extends LocalTitle ? TitleOf<Parent> : [LocalTitle] extends [undefined] ? TitleOf<Parent> : string;
+type KeyIdentity<Key> = Key extends number ? `${Key}` : Key;
+type Unshadowed<Inherited, Local> = { readonly [Key in keyof Inherited as KeyIdentity<Key> extends KeyIdentity<Local> ? never : Key]: Inherited[Key]; };
 /**
  * Shared parsed inputs supplied to typed guards and resolvers.
  * The container and maps are shallow-frozen; nested codec values remain opaque.
@@ -213,7 +283,7 @@ type EffectiveSearch<Codecs, Parent> = SearchOf<Parent> & SearchValues<Codecs>;
 type Inputs<Params, Search> = {
   /** Logical positional path values, not Angular's matrix-merged params. */
   readonly params: Readonly<Params>;
-  /** Logical declared search values; keys without a value or fallback are absent. */
+  /** Logical declared search values; plain keys without a valid value are absent. */
   readonly search: Readonly<Search>;
 };
 /**
@@ -286,36 +356,44 @@ type PathInputError = Error & {
  * to redirect; `true` is rejected because the params are invalid.
  */
 type InvalidParamsHandler = (error: PathInputError, routeConfig: Route$1, segments: UrlSegment[], partialSnapshot: PartialMatchRouteSnapshot) => MaybeAsync<false | UrlTree | RedirectCommand>;
-type SearchInput<Schema, Keys extends keyof Schema> = keyof Schema extends never ? Record<string, never> : Pick<Schema, Keys>;
+type SearchInput<Schema, Keys extends keyof Schema> = keyof Schema extends never ? Record<string, never> : [Keys] extends [never] ? Schema : Pick<Schema, Keys>;
+/** The `search` field type of URL values for supplied keys; `never` for a searchless destination. */
+type SearchFieldOf<Target extends AnyRoute, SearchKeys> = keyof SearchInputOf<Target> extends never ? never : SearchInput<SearchInputOf<Target>, SearchKeys & keyof SearchInputOf<Target>>;
+/** URL values for a destination without effective path params. */
+type PathlessUrlValues<Search, Fragment> = {
+  /** Forbidden: the destination has no effective path params. */
+  params?: never;
+  /** Any declared search values; absent or undefined values are omitted. `never` when the destination declares no search. */
+  search?: Search;
+  /** An optional logical name declared by this exact destination, without `#`. `never` when it declares none. */
+  fragment?: Fragment;
+};
+/** URL values for a destination with effective path params. */
+type PathUrlValues<Params, Search, Fragment> = {
+  /** All effective path values; catchalls are readonly element-value arrays. */
+  params: Params;
+  /** Any declared search values; absent or undefined values are omitted. `never` when the destination declares no search. */
+  search?: Search;
+  /** An optional logical name declared by this exact destination, without `#`. `never` when it declares none. */
+  fragment?: Fragment;
+};
 /**
  * Explicit values for URL creation and generated link/navigation calls.
  * Effective path keys must be present; every search key may be omitted.
  * Paramless/searchless routes forbid those fields. Fragment names come only
  * from the destination's own declaration.
  *
+ * @remarks
+ * One object type literal, not an intersection: TypeScript relates a string to
+ * each member of an intersection without its weak-type check, so String's own
+ * `search` method would match the search field. A type literal, unlike an
+ * interface, stays assignable to `Record<string, unknown>`.
+ *
  * @typeParam Target - The selected route declaration.
  * @typeParam SearchKeys - Supplied search keys inferred by each call to preserve
  * optional-key typing, including keys that coincide with Object members.
  */
-type UrlValues<Target extends AnyRoute, SearchKeys extends keyof SearchOf<Target> = keyof SearchOf<Target>> = (keyof ParamsOf<Target> extends never ? {
-  /** Forbidden when the destination has no effective path params. */
-  params?: never;
-} : {
-  /** All effective path values; catchalls are readonly element-value arrays. */
-  params: ParamsOf<Target>;
-}) & (keyof SearchInputOf<Target> extends never ? {
-  /** Forbidden when the destination has no search declarations. */
-  search?: never;
-} : {
-  /** Any declared search values; absent or undefined values are omitted. */
-  search?: SearchInput<SearchInputOf<Target>, SearchKeys & keyof SearchInputOf<Target>>;
-}) & (FragmentsOf<Target> extends never ? {
-  /** Forbidden when this declaration has no fragment names. */
-  fragment?: never;
-} : {
-  /** An optional logical name declared by this exact destination, without `#`. */
-  fragment?: FragmentsOf<Target>;
-});
+type UrlValues<Target extends AnyRoute, SearchKeys extends keyof SearchOf<Target> = keyof SearchOf<Target>> = keyof ParamsOf<Target> extends never ? PathlessUrlValues<SearchFieldOf<Target, SearchKeys>, FragmentsOf<Target>> : PathUrlValues<ParamsOf<Target>, SearchFieldOf<Target, SearchKeys>, FragmentsOf<Target>>;
 type CompatibleKeys<Source, Value> = { [Key in keyof Source]: Source[Key] extends Value ? Key : never; }[keyof Source];
 type Mapping<Source, Destination> = { [Key in keyof Destination]: CompatibleKeys<Source, Destination[Key]>; };
 type Forwardable<Source, Destination> = { [Key in keyof Destination]: Key extends keyof Source ? Source[Key] extends Destination[Key] ? never : Key : Key; }[keyof Destination] extends never ? true : false;
@@ -364,10 +442,10 @@ type Redirect<SourceParams, Target extends AnyRoute, SearchKeys extends keyof Se
  * Options inferred by `defineRoute`; Angular's structural route fields are excluded.
  * Local params/search cannot redeclare keys inherited from the parent.
  */
-type RouteConfig<Path extends string, Parent extends AnyRoute | undefined, Params extends Record<string, PathCodec>, Search extends CodecMap, Resolvers, Fragments extends readonly string[], Target extends AnyRoute | undefined, ReplacementKeys extends keyof SearchOf<Target>> = {
+type RouteConfig<Path extends string, Parent extends AnyRoute | undefined, Params extends Record<string, PathCodec>, Search extends CodecMap, Resolvers, Fragments extends readonly string[], Target extends AnyRoute | undefined, ReplacementKeys extends keyof SearchOf<Target>, Title = unknown> = {
   /** Genuine authored parent; pathless nodes retain inherited input ownership. */
-  parent?: Parent & (Parent extends Route<string, any, any, any, any, true> ? never : unknown);
-  /** Local search codecs; a key is absent unless present and valid, or wrapped withFallback. */
+  parent?: Parent & (Parent extends Route<string, any, any, any, any, true, any, any> ? never : unknown);
+  /** Local search codecs; a plain key is absent unless present and valid. withFallback and arrayParam keys always read a value. */
   search?: Search & Record<Extract<keyof Search, keyof SearchOf<Parent>>, never> & SyncCodecs<NoInfer<Search>>;
   /** Local parsed-input resolvers; not snapshot-first native ResolveFn callbacks. */
   resolve?: Resolvers & Record<PropertyKey, Resolver<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>> & {
@@ -384,7 +462,7 @@ type RouteConfig<Path extends string, Parent extends AnyRoute | undefined, Param
   /** Native route-scoped providers; provider factories are not run at declaration. */
   providers?: Route$1["providers"];
   /** A static title, or a parsed-input callback; not a snapshot-first native ResolveFn. */
-  title?: string | TitleResolver<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>;
+  title?: Title & (string | TitleResolver<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>);
   /** Native static data; cannot set the reserved __loozoAngularRouterRouteId key. */
   data?: Route$1["data"] & {
     __loozoAngularRouterRouteId?: never;
@@ -435,8 +513,9 @@ export declare function routeMetadata(route: unknown): RouteMetadata;
  * catchall. Repeated local scalar names reuse one value. Leading/trailing or
  * repeated slashes, dot segments and Angular `:name`/wildcard notation are invalid.
  *
- * Parents compose effective params/search transitively, including through
- * pathless nodes. Children cannot redeclare ancestor-owned keys or have a
+ * Parents compose effective params/search and resolver data transitively,
+ * including through pathless nodes; a local resolver key hides an inherited
+ * one. Children cannot redeclare ancestor-owned param or search keys or have a
  * catchall parent. Fragment names belong only to this declaration.
  * The route and copied containers are shallow-frozen; application codecs,
  * callbacks, providers and opaque values retain identity and are not deep-frozen.
@@ -450,10 +529,11 @@ export declare function routeMetadata(route: unknown): RouteMetadata;
  * @param config - Local codecs, parent, fragments and supported native behavior.
  * Structural Angular options such as children, component and matcher are
  * generator-owned and cannot be overridden.
- * @returns A frozen route preserving inferred effective input and local data types.
+ * @returns A frozen route preserving inferred effective input and resolver data types.
  * @throws TypeError for invalid paths/configuration, missing or extra local
- * codecs, fallback codecs in path params, inherited key conflicts, or
- * nongenuine parent/redirect routes.
+ * codecs, fallback or array codecs in path params, inherited key conflicts,
+ * nonarray redirect replacements for array search keys, or nongenuine
+ * parent/redirect routes.
  *
  * @example
  * ```ts
@@ -464,20 +544,22 @@ export declare function routeMetadata(route: unknown): RouteMetadata;
  * });
  * ```
  */
-export declare function defineRoute<const Path extends string, Parent extends AnyRoute | undefined = undefined, Params extends Record<string, PathCodec> = {}, Search extends CodecMap = {}, Resolvers extends Record<string, (...args: any[]) => unknown> = {}, const Fragments extends readonly string[] = [], Target extends AnyRoute | undefined = undefined, ReplacementKeys extends keyof SearchOf<NoInfer<Target>> = never>(path: Path & ValidPath<Path>, config: RouteConfig<Path, Parent, Params, Search, Resolvers, Fragments, Target, ReplacementKeys>): Route<Path, EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>, Resolvers, Fragments[number], CatchallName<Path> extends never ? false : true>;
+export declare function defineRoute<const Path extends string, Parent extends AnyRoute | undefined = undefined, Params extends Record<string, PathCodec> = {}, Search extends CodecMap = {}, Resolvers extends Record<string, (...args: any[]) => unknown> = {}, const Fragments extends readonly string[] = [], Target extends AnyRoute | undefined = undefined, ReplacementKeys extends keyof SearchOf<NoInfer<Target>> = never, Title = unknown>(path: Path & ValidPath<Path>, config: RouteConfig<Path, Parent, Params, Search, Resolvers, Fragments, Target, ReplacementKeys, Title>): Route<Path, EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>, Resolvers, Fragments[number], CatchallName<Path> extends never ? false : true, EffectiveData<Resolvers, Parent>, EffectiveTitle<Title, Parent>>;
 /**
  * Synchronously serializes a route's explicit values into a root-relative URL.
  *
  * @remarks
  * Includes inherited path/search declarations, but only this route's fragment
  * names. Every effective path value must be supplied; any search key may be
- * omitted. Searchless/paramless routes forbid those records. Catchalls require readonly arrays, including a valid empty array.
+ * omitted. Searchless/paramless routes forbid those records. Catchalls and
+ * `arrayParam` search keys require readonly arrays, including a valid empty array.
  * Values are never taken from a current navigation.
  *
  * Stringifies without calling parsers, guards, resolvers or redirects. Static
  * segments and logical values are component-encoded (also escaping parentheses),
  * so a dynamic slash becomes `%2F`. Search keys are globally sorted; omitted
- * and `undefined` values are left out. An empty effective path produces `/`.
+ * and `undefined` values are left out. An `arrayParam` key writes one pair per
+ * element in array order, and nothing for `[]`. An empty effective path produces `/`.
  * Redirect declarations serialize their source URL, not their redirect target.
  *
  * @param route - A genuine declaration from this physical package instance,
@@ -487,7 +569,7 @@ export declare function defineRoute<const Path extends string, Parent extends An
  * @returns A root-relative URL string, typed `` `/${string}` ``; this does not navigate or
  * return a UrlTree.
  * @throws TypeError for invalid routes/records, missing or unknown keys,
- * undeclared fragments, nonarray catchalls, nonstring codec output, or empty/dot
+ * undeclared fragments, nonarray catchalls or array search values, nonstring codec output, or empty/dot
  * path output. Application stringifier failures propagate unchanged.
  * @throws URIError for ill-formed Unicode in a serialized value.
  *
@@ -502,4 +584,4 @@ export declare function defineRoute<const Path extends string, Parent extends An
  * ```
  */
 export declare function createUrl<Target extends AnyRoute, SearchKeys extends keyof SearchOf<NoInfer<Target>> = never>(route: Target, values: UrlValues<NoInfer<Target>, SearchKeys>): `/${string}`;
-export type { AnyRoute, FragmentsOf, Inputs, ParamCodec, ParamsOf, Route, RouteMetadata, SearchOf, UrlValues };
+export type { AnyRoute, FragmentsOf, Inputs, ParamCodec, ParamsOf, PathUrlValues, PathlessUrlValues, Route, RouteMetadata, SearchFieldOf, SearchOf, TitleOf, UrlValues };