@loozo/angular-router 0.0.2 → 0.0.3

package/schemas/serve.json

@@ -1,39 +1,18 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema",
+  "$comment": "Every option except poll is an @angular/build:dev-server option, passed through and validated by that builder. Router options come from buildTarget.",
   "type": "object",
-  "additionalProperties": false,
-  "required": ["tsconfig", "scanDirectories", "outDirectory", "delegateTarget"],
+  "additionalProperties": true,
+  "required": ["buildTarget"],
   "properties": {
-    "tsconfig": { "type": "string", "minLength": 1 },
-    "scanDirectories": {
-      "type": "array",
-      "minItems": 1,
-      "maxItems": 1,
-      "items": { "type": "string", "minLength": 1 }
+    "buildTarget": {
+      "type": "string",
+      "minLength": 1,
+      "description": "A target using @loozo/angular-router:application, as project:target[:configuration]."
     },
-    "autoDefineRoutes": {
-      "$comment": "Conditional validation prevents Angular addUndefinedDefaults from creating an omitted opt-in object.",
-      "if": true,
-      "then": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "filename": {
-            "type": "string",
-            "pattern": "^[A-Za-z0-9_$][A-Za-z0-9_$.-]*\\.ts$",
-            "not": {
-              "anyOf": [
-                { "pattern": "\\.d\\.ts$" },
-                {
-                  "enum": ["route.generated.ts", "routes.generated.ts", "destinations.generated.ts"]
-                }
-              ]
-            }
-          }
-        }
-      }
-    },
-    "outDirectory": { "type": "string", "minLength": 1 },
-    "delegateTarget": { "type": "string", "minLength": 1 }
+    "poll": {
+      "description": "Watch by polling every this many milliseconds. Defaults to 1000 when omitted. false adds no default, so Angular's own configuration applies, including a poll on the build target.",
+      "oneOf": [{ "type": "number", "exclusiveMinimum": 0 }, { "const": false }]
+    }
   }
 }

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

@@ -1,6 +1,5 @@
-import { RedirectCommand, RunGuardsAndResolvers, ActivatedRouteSnapshot, RouterStateSnapshot, MaybeAsync, GuardResult, Route as Route$1, UrlSegment, PartialMatchRouteSnapshot } from '@angular/router';
-import { Observable } from 'rxjs';
-
+import { ActivatedRouteSnapshot, GuardResult, MaybeAsync, PartialMatchRouteSnapshot, RedirectCommand, Route as Route$1, RouterStateSnapshot, RunGuardsAndResolvers, UrlSegment } from "@angular/router";
+import { Observable } from "rxjs";
 /**
  * Converts one decoded path or search value to and from an application value.
  *
@@ -21,41 +20,42 @@ import { Observable } from 'rxjs';
  * ```
  */
 interface ParamCodec<Value> {
-    /**
-     * Parses one already percent-decoded value; do not decode it again.
-     *
-     * @param raw - A single logical string from Angular's URL inputs.
-     * @returns The logical value or a promise for it.
-     * @throws An application error for invalid input; generated input parsing
-     * reports throws and rejections as invalid path/search values with a cause.
-     */
-    parse(raw: string): Value | Promise<Value>;
-    /**
-     * Serializes one logical value without percent-encoding it.
-     *
-     * @param value - The application value to serialize.
-     * @returns An unencoded string. Path output must not be empty, `.` or `..`.
-     * @throws An application error when the value cannot be serialized.
-     */
-    stringify(value: Value): string;
+  /**
+   * Parses one already percent-decoded value; do not decode it again.
+   *
+   * @param raw - A single logical string from Angular's URL inputs.
+   * @returns The logical value or a promise for it.
+   * @throws An application error for invalid input; generated input parsing
+   * reports throws and rejections as invalid path/search values with a cause.
+   */
+  parse(raw: string): Value | Promise<Value>;
+  /**
+   * Serializes one logical value without percent-encoding it.
+   *
+   * @param value - The application value to serialize.
+   * @returns An unencoded string. Path output must not be empty, `.` or `..`.
+   * @throws An application error when the value cannot be serialized.
+   */
+  stringify(value: Value): string;
 }
 declare const searchPresence: unique symbol;
 /** A search-only codec whose key may be omitted or supplied as `undefined`. */
 type OptionalCodec<Value> = ParamCodec<Value | undefined> & {
-    readonly [searchPresence]: "optional";
+  readonly [searchPresence]: "optional";
 };
 /** A search-only codec that represents explicit `null` as the text `"null"`. */
 type NullableCodec<Value> = ParamCodec<Value | null> & {
-    readonly [searchPresence]: "nullable";
+  readonly [searchPresence]: "nullable";
 };
 type PathCodec = ParamCodec<any> & {
-    readonly [searchPresence]?: never;
+  readonly [searchPresence]?: never;
 };
 type CodecValue<Codec> = Codec extends ParamCodec<infer Value> ? Value : never;
 type IsOptional<Codec> = Codec extends {
-    readonly [searchPresence]: "optional";
+  readonly [searchPresence]: "optional";
 } ? true : false;
-declare function codecPresence(codec: object): "optional" | "nullable" | undefined;
+export declare function codecPresence(codec: object): "optional" | "nullable" | undefined;
+declare function validateCodec(codec: unknown): asserts codec is ParamCodec<any>;
 /**
  * Preserves strings verbatim, including empty strings and literal percent text.
  *
@@ -63,7 +63,7 @@ declare function codecPresence(codec: object): "optional" | "nullable" | undefin
  * Empty, dot and dotdot values are valid codec values but cannot be serialized
  * into path segments by URL creation. Search values may contain them.
  */
-declare const stringParam: ParamCodec<string>;
+export declare const stringParam: ParamCodec<string>;
 /**
  * Parses nonblank text with JavaScript `Number` and requires a finite result.
  *
@@ -72,12 +72,12 @@ declare const stringParam: ParamCodec<string>;
  * Blank text, NaN and infinities throw. Stringification requires a finite number
  * and uses its JavaScript string representation (including `-0` becoming `"0"`).
  */
-declare const numberParam: ParamCodec<number>;
+export declare const numberParam: ParamCodec<number>;
 /**
  * Parses only lowercase `"true"` and `"false"`, and emits those same strings.
  * Other representations and nonboolean values throw.
  */
-declare const booleanParam: ParamCodec<boolean>;
+export declare const booleanParam: ParamCodec<boolean>;
 /**
  * Creates a case-sensitive string codec from a snapshotted list of members.
  *
@@ -92,7 +92,7 @@ declare const booleanParam: ParamCodec<boolean>;
  * tab.parse("reviews"); // "reviews"
  * ```
  */
-declare function enumParam<const Values extends readonly string[]>(values: Values): ParamCodec<Values[number]>;
+export declare function enumParam<const Values extends readonly string[]>(values: Values): ParamCodec<Values[number]>;
 /**
  * Makes a search key optional without changing the handling of present values.
  *
@@ -108,7 +108,7 @@ declare function enumParam<const Values extends readonly string[]>(values: Value
  * @returns A search-only codec allowing omission.
  * @throws TypeError if the codec lacks callable parse/stringify methods.
  */
-declare function optionalSearchParam<Value>(codec: ParamCodec<Value>): OptionalCodec<Value>;
+export declare function optionalSearchParam<Value>(codec: ParamCodec<Value>): OptionalCodec<Value>;
 /**
  * Adds explicit null to a search codec, represented by the decoded text `"null"`.
  *
@@ -129,10 +129,9 @@ declare function optionalSearchParam<Value>(codec: ParamCodec<Value>): OptionalC
  * // Omission, null, and a present number remain distinct.
  * ```
  */
-declare function nullableSearchParam<Value>(codec: ParamCodec<Value> & {
-    readonly [searchPresence]?: "nullable";
+export declare function nullableSearchParam<Value>(codec: ParamCodec<Value> & {
+  readonly [searchPresence]?: "nullable";
 }): NullableCodec<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>;
@@ -142,13 +141,13 @@ type SegmentName<Segment extends string> = Segment extends `$${infer Name}[]` ?
 type PathNames<Path extends string> = Path extends `${infer Head}/${infer Tail}` ? SegmentName<Head> | PathNames<Tail> : SegmentName<Path>;
 type CatchallName<Path extends string> = Path extends `${string}/${infer Tail}` ? CatchallName<Tail> : Path extends `$${infer Name}[]` ? Name : never;
 type Segment = {
-    readonly kind: "static";
-    readonly text: string;
+  readonly kind: "static";
+  readonly text: string;
 } | {
-    readonly kind: "scalar" | "catchall";
-    readonly name: string;
+  readonly kind: "scalar" | "catchall";
+  readonly name: string;
 };
-
+declare function parsePath(path: unknown): readonly Segment[];
 declare const routeBrand: unique symbol;
 /**
  * A nominal route declaration created by `defineRoute`, not a native Angular Route.
@@ -168,27 +167,25 @@ declare const routeBrand: unique symbol;
  * @typeParam Catchall - Whether the declaration is a terminal catchall leaf.
  */
 interface Route<Path extends string, Params, Search, Resolvers = {}, Fragments extends string = string, Catchall extends boolean = CatchallName<Path> extends never ? false : true> {
-    readonly [routeBrand]: {
-        readonly fragments: Fragments;
-        readonly catchall: Catchall;
-    };
-    /** The exact local authored path supplied to `defineRoute`. */
-    readonly path: Path;
-    /** Type-only witness for effective path values; not populated at runtime. */
-    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]>;
-    };
-    /** The snapshotted local resolver map, retaining original callback identities. */
-    readonly resolve?: Readonly<Resolvers>;
-    /** The original native rerun policy; omission preserves Angular's default. */
-    readonly runGuardsAndResolvers?: RunGuardsAndResolvers;
+  readonly [routeBrand]: {
+    readonly fragments: Fragments;
+    readonly catchall: Catchall;
+  };
+  /** The exact local authored path supplied to `defineRoute`. */
+  readonly path: Path;
+  /** Type-only witness for effective path values; not populated at runtime. */
+  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]>; };
+  /** The snapshotted local resolver map, retaining original callback identities. */
+  readonly resolve?: Readonly<Resolvers>;
+  /** The original native rerun policy; omission preserves Angular's default. */
+  readonly runGuardsAndResolvers?: RunGuardsAndResolvers;
 }
 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 Resolved<Callback> = Callback extends ((...args: any[]) => infer Value) ? Exclude<Unwrap<Value>, RedirectCommand> : never;
 type AnyRoute = Route<string, any, any, any, any, boolean>;
 /** 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 : {};
@@ -197,14 +194,8 @@ type SearchOf<Target> = Target extends Route<string, any, infer Search, any, any
 /** 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 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 IsOptional<Codecs[Key]> extends true ? never : Key]: CodecValue<Codecs[Key]>;
-} & {
-    readonly [Key in keyof Codecs as IsOptional<Codecs[Key]> extends true ? Key : never]?: CodecValue<Codecs[Key]>;
-};
+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 IsOptional<Codecs[Key]> extends true ? never : Key]: CodecValue<Codecs[Key]>; } & { readonly [Key in keyof Codecs as IsOptional<Codecs[Key]> extends true ? Key : never]?: CodecValue<Codecs[Key]>; };
 type EffectiveParams<Path extends string, Codecs, Parent> = ParamsOf<Parent> & LocalParams<Path, Codecs>;
 type EffectiveSearch<Codecs, Parent> = SearchOf<Parent> & SearchValues<Codecs>;
 /**
@@ -212,10 +203,10 @@ type EffectiveSearch<Codecs, Parent> = SearchOf<Parent> & SearchValues<Codecs>;
  * The container and maps are shallow-frozen; nested codec values remain opaque.
  */
 type Inputs<Params, Search> = {
-    /** Logical positional path values, not Angular's matrix-merged params. */
-    readonly params: Readonly<Params>;
-    /** Logical declared search values; absent optional keys are omitted. */
-    readonly search: Readonly<Search>;
+  /** Logical positional path values, not Angular's matrix-merged params. */
+  readonly params: Readonly<Params>;
+  /** Logical declared search values; absent optional keys are omitted. */
+  readonly search: Readonly<Search>;
 };
 /**
  * A local resolver invoked after successful effective input parsing.
@@ -250,9 +241,7 @@ type ActivationGuard<Params, Search> = (inputs: Inputs<Params, Search>, snapshot
  * @returns A native guard result; false permits Angular's next candidate.
  */
 type MatchingGuard<Params, Search> = (inputs: Inputs<Params, Search>, routeConfig: Route$1, segments: UrlSegment[], partialSnapshot: PartialMatchRouteSnapshot) => MaybeAsync<GuardResult>;
-type RequiredKeys<Value> = {
-    [Key in keyof Value]-?: Pick<Value, Key> extends Required<Pick<Value, Key>> ? Key : never;
-}[keyof Value];
+type RequiredKeys<Value> = { [Key in keyof Value]-?: Pick<Value, Key> extends Required<Pick<Value, Key>> ? Key : never; }[keyof Value];
 type SearchInput<Schema, Keys extends keyof Schema> = keyof Schema extends never ? Record<string, never> : Pick<Schema, RequiredKeys<Schema> | Keys>;
 /**
  * Explicit values for URL creation and generated link/navigation calls.
@@ -265,39 +254,31 @@ type SearchInput<Schema, Keys extends keyof Schema> = keyof Schema extends never
  * 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;
+  /** Forbidden when the destination has no effective path params. */
+  params?: never;
 } : {
-    /** All effective path values; catchalls are readonly element-value arrays. */
-    params: ParamsOf<Target>;
+  /** All effective path values; catchalls are readonly element-value arrays. */
+  params: ParamsOf<Target>;
 }) & (keyof SearchOf<Target> extends never ? {
-    /** Forbidden when the destination has no search declarations. */
-    search?: never;
+  /** Forbidden when the destination has no search declarations. */
+  search?: never;
 } : RequiredKeys<SearchOf<Target>> extends never ? {
-    /** Optional-only search; absent or undefined optional values are omitted. */
-    search?: SearchInput<SearchOf<Target>, SearchKeys>;
+  /** Optional-only search; absent or undefined optional values are omitted. */
+  search?: SearchInput<SearchOf<Target>, SearchKeys>;
 } : {
-    /** All required search values plus any supplied optional values. */
-    search: SearchInput<SearchOf<Target>, SearchKeys>;
+  /** All required search values plus any supplied optional values. */
+  search: SearchInput<SearchOf<Target>, SearchKeys>;
 }) & (FragmentsOf<Target> extends never ? {
-    /** Forbidden when this declaration has no fragment names. */
-    fragment?: never;
+  /** Forbidden when this declaration has no fragment names. */
+  fragment?: never;
 } : {
-    /** An optional logical name declared by this exact destination, without `#`. */
-    fragment?: FragmentsOf<Target>;
+  /** An optional logical name declared by this exact destination, without `#`. */
+  fragment?: 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;
-type Preservable<Source, Destination> = {
-    [Key in RequiredKeys<Destination>]: Key extends RequiredKeys<Source> ? Source[Key & keyof Source] extends Destination[Key] ? never : Key : Key;
-}[RequiredKeys<Destination>] extends never ? true : false;
+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;
+type Preservable<Source, Destination> = { [Key in RequiredKeys<Destination>]: Key extends RequiredKeys<Source> ? Source[Key & keyof Source] extends Destination[Key] ? never : Key : Key; }[RequiredKeys<Destination>] extends never ? true : false;
 /**
  * A typed redirect to a genuine authored declaration, not a concrete URL.
  *
@@ -311,98 +292,98 @@ type Preservable<Source, Destination> = {
  * whereas replace requires a target-declared name. Angular executes the redirect.
  */
 type Redirect<SourceParams, SourceSearch, Target extends AnyRoute, SearchKeys extends keyof SearchOf<Target>> = {
-    /** The already constructed target; generation requires a direct default import. */
-    to: Target;
-    /** Explicit query policy: preserve incoming text, drop it, or replace with values. */
-    search: {
-        /** Discard incoming queries and serialize explicit target-typed values. */
-        mode: "replace";
-        /** Required target search keys plus selected optional keys; unknown keys fail. */
-        values: SearchInput<SearchOf<NoInfer<Target>>, SearchKeys>;
-    } | (RequiredKeys<SearchOf<Target>> extends never ? {
-        /** Remove all incoming query values; target required keys are forbidden. */
-        mode: "drop";
-    } : never) | (Preservable<SourceSearch, SearchOf<Target>> extends true ? {
-        /** Keep original query text, validating destination-declared cardinality/values. */
-        mode: "preserve";
-    } : never);
-    /** Explicit hash policy; preserved incoming names need not be declared. */
-    fragment: {
-        /** Keep the raw incoming hash, or remove it entirely. */
-        mode: "preserve" | "drop";
-    } | (FragmentsOf<Target> extends never ? never : {
-        /** Replace the incoming hash with an explicitly declared target name. */
-        mode: "replace";
-        /** A logical target fragment name without the `#` delimiter. */
-        value: FragmentsOf<Target>;
-    });
+  /** The already constructed target; generation requires a direct default import. */
+  to: Target;
+  /** Explicit query policy: preserve incoming text, drop it, or replace with values. */
+  search: {
+    /** Discard incoming queries and serialize explicit target-typed values. */
+    mode: "replace";
+    /** Required target search keys plus selected optional keys; unknown keys fail. */
+    values: SearchInput<SearchOf<NoInfer<Target>>, SearchKeys>;
+  } | (RequiredKeys<SearchOf<Target>> extends never ? {
+    /** Remove all incoming query values; target required keys are forbidden. */
+    mode: "drop";
+  } : never) | (Preservable<SourceSearch, SearchOf<Target>> extends true ? {
+    /** Keep original query text, validating destination-declared cardinality/values. */
+    mode: "preserve";
+  } : never);
+  /** Explicit hash policy; preserved incoming names need not be declared. */
+  fragment: {
+    /** Keep the raw incoming hash, or remove it entirely. */
+    mode: "preserve" | "drop";
+  } | (FragmentsOf<Target> extends never ? never : {
+    /** Replace the incoming hash with an explicitly declared target name. */
+    mode: "replace";
+    /** A logical target fragment name without the `#` delimiter. */
+    value: FragmentsOf<Target>;
+  });
 } & (Forwardable<SourceParams, ParamsOf<Target>> extends true ? {
-    /** Optional destination-key to source-key mapping; otherwise forward by name. */
-    params?: Mapping<SourceParams, ParamsOf<Target>>;
+  /** Optional destination-key to source-key mapping; otherwise forward by name. */
+  params?: Mapping<SourceParams, ParamsOf<Target>>;
 } : {
-    /** Required mapping of every destination path key to a compatible source key. */
-    params: Mapping<SourceParams, ParamsOf<Target>>;
+  /** Required mapping of every destination path key to a compatible source key. */
+  params: Mapping<SourceParams, ParamsOf<Target>>;
 });
 /**
  * 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>> = {
-    /** 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; keys are required unless wrapped with optionalSearchParam. */
-    search?: Search & Record<Extract<keyof Search, keyof SearchOf<Parent>>, never>;
-    /** Local parsed-input resolvers; not snapshot-first native ResolveFn callbacks. */
-    resolve?: Resolvers & Record<PropertyKey, Resolver<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>> & {
-        __loozoAngularRouterRouteId?: never;
-    };
-    /** Local logical anchor names, never inherited; this does not enable scrolling. */
-    fragments?: Fragments;
-    /** Native rerun policy. Use paramsOrQueryParamsChange for query-dependent data. */
-    runGuardsAndResolvers?: RunGuardsAndResolvers;
-    /** Guards with declaring-parent inputs and Angular's native child snapshot. */
-    canActivateChild?: readonly ActivationGuard<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>[];
-    /** Native component-first guard functions/tokens, without automatic input parsing. */
-    canDeactivate?: Route$1["canDeactivate"];
-    /** Native route-scoped providers; provider factories are not run at declaration. */
-    providers?: Route$1["providers"];
-    /** Native static title or title resolver, not a parsed-input callback. */
-    title?: Route$1["title"];
-    /** Native static data; cannot set the reserved __loozoAngularRouterRouteId key. */
-    data?: Route$1["data"] & {
-        __loozoAngularRouterRouteId?: never;
-    };
+  /** 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; keys are required unless wrapped with optionalSearchParam. */
+  search?: Search & Record<Extract<keyof Search, keyof SearchOf<Parent>>, never>;
+  /** Local parsed-input resolvers; not snapshot-first native ResolveFn callbacks. */
+  resolve?: Resolvers & Record<PropertyKey, Resolver<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>> & {
+    __loozoAngularRouterRouteId?: never;
+  };
+  /** Local logical anchor names, never inherited; this does not enable scrolling. */
+  fragments?: Fragments;
+  /** Native rerun policy. Use paramsOrQueryParamsChange for query-dependent data. */
+  runGuardsAndResolvers?: RunGuardsAndResolvers;
+  /** Guards with declaring-parent inputs and Angular's native child snapshot. */
+  canActivateChild?: readonly ActivationGuard<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>[];
+  /** Native component-first guard functions/tokens, without automatic input parsing. */
+  canDeactivate?: Route$1["canDeactivate"];
+  /** Native route-scoped providers; provider factories are not run at declaration. */
+  providers?: Route$1["providers"];
+  /** Native static title or title resolver, not a parsed-input callback. */
+  title?: Route$1["title"];
+  /** Native static data; cannot set the reserved __loozoAngularRouterRouteId key. */
+  data?: Route$1["data"] & {
+    __loozoAngularRouterRouteId?: never;
+  };
 } & (PathNames<Path> extends never ? {
-    /** Paths without local placeholders cannot declare a params map. */
-    params?: never;
+  /** Paths without local placeholders cannot declare a params map. */
+  params?: never;
 } : {
-    /** Exactly the local placeholder names; catchall codecs apply per element. */
-    params: Params & Record<PathNames<Path>, PathCodec> & Record<Exclude<keyof Params, PathNames<Path>> | Extract<keyof Params, keyof ParamsOf<Parent>>, never>;
+  /** Exactly the local placeholder names; catchall codecs apply per element. */
+  params: Params & Record<PathNames<Path>, PathCodec> & Record<Exclude<keyof Params, PathNames<Path>> | Extract<keyof Params, keyof ParamsOf<Parent>>, never>;
 }) & (Target extends AnyRoute ? {
-    /** Typed native redirect, incompatible with own canActivate/canMatch fields. */
-    redirect: Redirect<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>, Target, ReplacementKeys>;
-    canActivate?: never;
-    canMatch?: never;
+  /** Typed native redirect, incompatible with own canActivate/canMatch fields. */
+  redirect: Redirect<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>, Target, ReplacementKeys>;
+  canActivate?: never;
+  canMatch?: never;
 } : {
-    redirect?: never;
-    /** Activation guards with effective inherited and local parsed inputs. */
-    canActivate?: readonly ActivationGuard<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>[];
-    /** Matching guards with local path params and effective search only. */
-    canMatch?: readonly MatchingGuard<LocalParams<Path, Params>, EffectiveSearch<Search, Parent>>[];
+  redirect?: never;
+  /** Activation guards with effective inherited and local parsed inputs. */
+  canActivate?: readonly ActivationGuard<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>[];
+  /** Matching guards with local path params and effective search only. */
+  canMatch?: readonly MatchingGuard<LocalParams<Path, Params>, EffectiveSearch<Search, Parent>>[];
 });
-
 interface RouteMetadata {
-    readonly parent?: AnyRoute;
-    readonly localSegments: readonly Segment[];
-    readonly segments: readonly Segment[];
-    readonly localParams: Readonly<Record<string, ParamCodec<any>>>;
-    readonly localSearch: Readonly<Record<string, ParamCodec<any>>>;
-    readonly params: Readonly<Record<string, ParamCodec<any>>>;
-    readonly search: Readonly<Record<string, ParamCodec<any>>>;
-    readonly fragments: readonly string[];
-    readonly config: Readonly<Record<string, unknown>>;
+  readonly parent?: AnyRoute;
+  readonly localSegments: readonly Segment[];
+  readonly segments: readonly Segment[];
+  readonly localParams: Readonly<Record<string, ParamCodec<any>>>;
+  readonly localSearch: Readonly<Record<string, ParamCodec<any>>>;
+  readonly params: Readonly<Record<string, ParamCodec<any>>>;
+  readonly search: Readonly<Record<string, ParamCodec<any>>>;
+  readonly fragments: readonly string[];
+  readonly config: Readonly<Record<string, unknown>>;
 }
-declare function routeMetadata(route: unknown): RouteMetadata;
+export declare function routeMetadata(route: unknown): RouteMetadata;
+declare function validateSearchValues(codecs: Readonly<Record<string, ParamCodec<any>>>, values: Record<string, unknown>): void;
 /**
  * Declares a nominal typed route without executing codecs or native callbacks.
  *
@@ -440,8 +421,7 @@ declare function routeMetadata(route: unknown): RouteMetadata;
  * });
  * ```
  */
-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>(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>;
 /**
  * Synchronously serializes a route's explicit values into a root-relative URL.
  *
@@ -478,7 +458,5 @@ declare function defineRoute<const Path extends string, Parent extends AnyRoute
  * // /products/42#summary
  * ```
  */
-declare function createUrl<Target extends AnyRoute, SearchKeys extends keyof SearchOf<NoInfer<Target>> = never>(route: Target, values: UrlValues<NoInfer<Target>, SearchKeys>): string;
-
-export { booleanParam, codecPresence, createUrl, defineRoute, enumParam, nullableSearchParam, numberParam, optionalSearchParam, routeMetadata, stringParam };
-export type { AnyRoute, FragmentsOf, Inputs, ParamCodec, ParamsOf, Route, RouteMetadata, SearchOf, UrlValues };
+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 };