@kitbag/router 0.23.1 → 0.24.0

package/dist/main.d.ts

@@ -10,10 +10,10 @@ export type { RouteRedirects } from './types/redirects';
 export * from './types/register';
 export type { Rejection, RejectionType, Rejections } from './types/rejection';
 export * from './types/resolved';
-export * from './types/route';
+export type { Route, CreatedRouteOptions } from './types/route';
 export * from './types/router';
 export * from './types/routerLink';
-export * from './types/routerPlugin';
+export type { RouterPlugin, CreateRouterPluginOptions } from './types/routerPlugin';
 export * from './types/routerPush';
 export * from './types/routerPush';
 export * from './types/routerReject';
@@ -23,7 +23,7 @@ export * from './types/routerResolve';
 export * from './types/routerResolve';
 export * from './types/routerRoute';
 export * from './types/urlString';
-export * from './types/url';
+export type { Url, CreateUrlOptions, ParseUrlOptions } from './types/url';
 export * from './types/useLink';
 export { DuplicateParamsError } from './errors/duplicateParamsError';
 export { MetaPropertyConflict } from './errors/metaPropertyConflict';

package/dist/models/hooks.d.ts

@@ -1,4 +1,4 @@
-import { AfterEnterHook, AfterLeaveHook, AfterUpdateHook, BeforeEnterHook, BeforeLeaveHook, BeforeUpdateHook, ErrorHook } from '../types/hooks';
+import { AfterEnterHook, AfterLeaveHook, AfterUpdateHook, BeforeEnterHook, BeforeLeaveHook, BeforeUpdateHook, ErrorHook, RejectionHook } from '../types/hooks';
 import { RedirectHook } from '../types/redirects';
 export declare class Hooks {
     redirects: Set<RedirectHook>;
@@ -9,4 +9,5 @@ export declare class Hooks {
     onAfterRouteUpdate: Set<AfterUpdateHook>;
     onAfterRouteLeave: Set<AfterLeaveHook>;
     onError: Set<ErrorHook>;
+    onRejection: Set<RejectionHook>;
 }

package/dist/services/createCurrentRejection.d.ts

@@ -0,0 +1,10 @@
+import { Rejection, RouterRejection } from '../types/rejection';
+type RejectionUpdate = (rejection: Rejection) => void;
+type RejectionClear = () => void;
+type CurrentRejectionContext = {
+    currentRejection: RouterRejection;
+    updateRejection: RejectionUpdate;
+    clearRejection: RejectionClear;
+};
+export declare function createCurrentRejection(): CurrentRejectionContext;
+export {};

package/dist/services/createRejection.d.ts

@@ -1,6 +1,7 @@
+import { RejectionHooks } from '../types/hooks';
 import { Rejection } from '../types/rejection';
 import { Component } from 'vue';
 export declare function createRejection<TType extends string>(options: {
     type: TType;
     component?: Component;
-}): Rejection<TType>;
+}): Rejection<TType> & RejectionHooks<TType>;

package/dist/services/createRejectionHooks.d.ts

@@ -0,0 +1,9 @@
+import { AddRejectionHook } from '../types/hooks';
+import { Routes } from '../types/route';
+import { Hooks } from '../models/hooks';
+type RejectionHooks<TRoutes extends Routes = Routes, TRejections extends string = string> = {
+    onRejection: AddRejectionHook<TRejections, TRoutes>;
+    store: Hooks;
+};
+export declare function createRejectionHooks(): RejectionHooks;
+export {};

package/dist/services/createRouteHooks.d.ts

@@ -1,7 +1,7 @@
-import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook } from '../types/hooks';
+import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook, AddRejectionHook } from '../types/hooks';
 import { Routes } from '../types/route';
 import { Hooks } from '../models/hooks';
-import { Rejection } from '../types/rejection';
+import { ExtractRejectionTypes, Rejection } from '../types/rejection';
 import { RouteRedirect } from '../types/redirects';
 type RouteHooks<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
     redirect: RouteRedirect;
@@ -12,6 +12,7 @@ type RouteHooks<TRoutes extends Routes = Routes, TRejections extends Rejection[]
     onAfterRouteUpdate: AddAfterUpdateHook<TRoutes, TRejections>;
     onAfterRouteLeave: AddAfterLeaveHook<TRoutes, TRejections>;
     onError: AddErrorHook<TRoutes[number], TRoutes, TRejections>;
+    onRejection: AddRejectionHook<ExtractRejectionTypes<TRejections>, TRoutes>;
     store: Hooks;
 };
 export declare function createRouteHooks(): RouteHooks;

package/dist/services/createRouterHooks.d.ts

@@ -1,10 +1,11 @@
-import { AddGlobalHooks, AddComponentHook, AfterHookRunner, BeforeHookRunner, AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, ErrorHookRunner, AddErrorHook } from '../types/hooks';
+import { AddGlobalHooks, AddComponentHook, AfterHookRunner, BeforeHookRunner, AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, ErrorHookRunner, AddErrorHook, RejectionHookRunner, AddRejectionHook } from '../types/hooks';
 import { HasVueAppStore } from './createVueAppStore';
 export declare const getRouterHooksKey: (routerKey: import('vue').InjectionKey<import('../main').Router>) => import('vue').InjectionKey<RouterHooks>;
 export type RouterHooks = HasVueAppStore & {
     runBeforeRouteHooks: BeforeHookRunner;
     runAfterRouteHooks: AfterHookRunner;
     runErrorHooks: ErrorHookRunner;
+    runRejectionHooks: RejectionHookRunner;
     addComponentHook: AddComponentHook;
     addGlobalRouteHooks: AddGlobalHooks;
     onBeforeRouteEnter: AddBeforeEnterHook;
@@ -14,5 +15,6 @@ export type RouterHooks = HasVueAppStore & {
     onAfterRouteUpdate: AddAfterUpdateHook;
     onAfterRouteLeave: AddAfterLeaveHook;
     onError: AddErrorHook;
+    onRejection: AddRejectionHook;
 };
 export declare function createRouterHooks(): RouterHooks;

package/dist/services/createRouterPlugin.d.ts

@@ -1,4 +1,4 @@
 import { CreateRouterPluginOptions, RouterPlugin, PluginRouteHooks } from '../types/routerPlugin';
 import { Rejections } from '../types/rejection';
 import { Routes } from '../types/route';
-export declare function createRouterPlugin<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections>(plugin: CreateRouterPluginOptions<TRoutes, TRejections>): RouterPlugin<TRoutes, TRejections> & PluginRouteHooks<TRoutes, TRejections>;
+export declare function createRouterPlugin<TRoutes extends Routes = [], TRejections extends Rejections = []>(plugin: CreateRouterPluginOptions<TRoutes, TRejections>): RouterPlugin<TRoutes, TRejections> & PluginRouteHooks<TRoutes, TRejections>;

package/dist/services/getRejectionHooks.d.ts

@@ -0,0 +1,3 @@
+import { Hooks } from '../models/hooks';
+import { Rejection } from '../types/rejection';
+export declare function getRejectionHooksFromRejection(rejection: Rejection): Hooks;

package/dist/services/getRoutesForRouter.d.ts

@@ -1,14 +1,28 @@
-import { Route, Routes } from '../types/route';
+import { Route, RouteInternal, Routes } from '../types/route';
 import { RouterPlugin } from '../types/routerPlugin';
-type RouterRoutes = {
-    routes: Routes;
-    getRouteByName: (name: string) => Route | undefined;
-};
+import { BuiltInRejectionType, Rejection, RejectionInternal } from '../types/rejection';
+import { RouterOptions } from '../types/router';
 /**
  * Takes in routes and plugins and returns a list of routes with the base route inserted if provided.
  * Also checks for duplicate names in the routes.
  *
  * @throws {DuplicateNamesError} If there are duplicate names in the routes.
  */
-export declare function getRoutesForRouter(routes: Routes | Routes[], plugins?: RouterPlugin[], base?: string): RouterRoutes;
-export {};
+export declare function getRoutesForRouter(routes: Routes | Routes[], plugins?: RouterPlugin[], options?: RouterOptions): {
+    routes: (import('../main').Url & {
+        id: string;
+        matched: import('../types/route').CreatedRouteOptions;
+        matches: import('../types/route').CreatedRouteOptions[];
+        name: string;
+        meta: Record<string, unknown>;
+        state: Record<string, import('../main').Param>;
+        prefetch?: import('../main').PrefetchConfig;
+        context: import('../types/routeContext').RouteContext[];
+    } & RouteInternal)[];
+    rejections: (Rejection & RejectionInternal)[];
+    getRouteByName: (type: string) => Route | undefined;
+    getRejectionByType: {
+        (type: BuiltInRejectionType): (Rejection & RejectionInternal);
+        (type: string): (Rejection & RejectionInternal) | undefined;
+    };
+};

package/dist/services/insertBaseRoute.d.ts

@@ -1,2 +1,2 @@
 import { Route } from '../types/route';
-export declare function insertBaseRoute(route: Route, base?: string): Route;
+export declare function insertBaseRoute<T extends Route>(route: T, base?: string): T;

package/dist/types/createRouteOptions.d.ts

@@ -1,7 +1,6 @@
 import { Component } from 'vue';
 import { CombineMeta } from '../services/combineMeta';
 import { CombineState } from '../services/combineState';
-import { WithHooks } from './hooks';
 import { Param } from './paramTypes';
 import { PrefetchConfig } from './prefetch';
 import { RouteMeta } from './register';
@@ -129,5 +128,5 @@ export type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRo
     ...ToRouteContext<TParent['context']>,
     ...ToRouteContext<TOptions['context']>
 ]> : Route<ToName<TOptions['name']>, ToUrl<Identity<TOptions & WithoutComponents>>, ToMeta<TOptions['meta']>, ToState<TOptions['state']>, ToMatches<TOptions, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>, ToRouteContext<TOptions['context']>>;
-export declare function combineRoutes(parent: Route, child: Route): Route & WithHooks;
+export declare function combineRoutes(parent: Route, child: Route): Route;
 export {};

package/dist/types/hooks.d.ts

@@ -5,27 +5,14 @@ import { Route, Routes } from './route';
 import { RouterReject } from './routerReject';
 import { RouterPush } from './routerPush';
 import { RouterReplace } from './routerReplace';
-import { Rejections } from './rejection';
+import { Rejection, Rejections } from './rejection';
 import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './routeContext';
 import { RouterAbort } from './routerAbort';
 import { CallbackContextAbort, CallbackContextPush, CallbackContextReject, CallbackContextSuccess } from './callbackContext';
 import { RouteUpdate } from './routeUpdate';
-/**
- * The stores for routes including ancestors.
- * Order of routes will be from greatest ancestor to narrowest matched.
- * @internal
- */
-export type WithHooks = {
-    hooks: Hooks[];
-};
-/**
- * Type guard to assert that a route has hooks.
- * @internal
- */
-export declare function isWithHooks<T extends Record<string, unknown>>(route: T): route is T & WithHooks;
-export declare function getHooks(route: Record<string, unknown> | undefined | null): Hooks[];
+export declare function getHooks(value: Record<string, unknown> | undefined | null): Hooks[];
 export declare function combineHooks(parent: Route, child: Route): Hooks[];
-export type InternalRouteHooks<TRoute extends Route = Route, TContext extends RouteContext[] = []> = {
+export type InternalRouteHooks<TRoute extends Route = Route, TContext extends RouteContext[] | undefined = undefined> = {
     /**
      * Registers a route hook to be called before the route is entered.
      */
@@ -57,6 +44,12 @@ export type ExternalRouteHooks<TRoute extends Route = Route, TContext extends Ro
      */
     onBeforeRouteEnter: AddBeforeEnterHook<[TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>, TRoute, Route>;
 };
+export type RejectionHooks<TRejections extends string = string> = {
+    /**
+     * Registers a route hook to be called when a rejection occurs.
+     */
+    onRejection: AddRejectionHook<TRejections>;
+};
 export type HookTiming = 'global' | 'component';
 /**
  * Union type for all component route hooks.
@@ -144,6 +137,16 @@ export type AfterHookRunner = <TRoutes extends Routes>(context: {
     to: RouterResolvedRouteUnion<TRoutes>;
     from: RouterResolvedRouteUnion<TRoutes> | null;
 }) => Promise<AfterHookResponse>;
+export type RejectionHookContext<TRoutes extends Routes = Routes, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = {
+    to: ResolvedRouteUnion<TRouteTo> | null;
+    from: ResolvedRouteUnion<TRouteFrom> | null;
+};
+export type RejectionHook<TRejection extends string = string, TRoutes extends Routes = Routes, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (rejection: TRejection, context: RejectionHookContext<TRoutes, TRouteTo, TRouteFrom>) => MaybePromise<void>;
+export type AddRejectionHook<TRejections extends string = string, TRoutes extends Routes = Routes, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: RejectionHook<TRejections, TRoutes, TRouteTo, TRouteFrom>) => HookRemove;
+export type RejectionHookRunner<TRejection extends Rejection = Rejection, TRoutes extends Routes = Routes> = (rejection: TRejection, context: {
+    to: RouterResolvedRouteUnion<TRoutes> | null;
+    from: RouterResolvedRouteUnion<TRoutes> | null;
+}) => void;
 export type ErrorHookContext<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     to: RouterResolvedRouteUnion<TRoutes>;
     from: RouterResolvedRouteUnion<TRoutes> | null;

package/dist/types/redirects.d.ts

@@ -3,17 +3,6 @@ import { Route, Routes } from './route';
 import { RouterReplace } from './routerReplace';
 import { UrlParamsReading, UrlParamsWriting } from './url';
 import { AllPropertiesAreOptional, MaybePromise } from './utilities';
-/**
- * redirect is returned by createRouteHooks but is not part of the Route type, so we use this type to assert that it exists.
- */
-type RouteWithRedirect<TRoute extends Route = Route> = TRoute & {
-    redirect: RouteRedirect;
-};
-/**
- * Type guard to assert that a route has a redirect hook.
- * @internal
- */
-export declare function isRouteWithRedirect(route: Route): route is RouteWithRedirect;
 export type RouteRedirects<TRoute extends Route = Route> = {
     /**
      * Creates a redirect to redirect the current route to another route.

package/dist/types/rejection.d.ts

@@ -1,4 +1,19 @@
-import { Component } from 'vue';
+import { Component, Ref } from 'vue';
+import { ResolvedRoute } from './resolved';
+import { Router } from './router';
+import { RouterReject } from './routerReject';
+import { Hooks } from '../models/hooks';
+export declare const BUILT_IN_REJECTION_TYPES: readonly ["NotFound"];
+export type BuiltInRejectionType = (typeof BUILT_IN_REJECTION_TYPES)[number];
+export type RouterRejection<T extends Rejection = Rejection> = Ref<T | null>;
+export type RouterRejections<TRouter extends Router> = TRouter['reject'] extends RouterReject<infer TRejections extends Rejection[]> ? TRejections[number] : never;
+export declare const IS_REJECTION_SYMBOL: unique symbol;
+export declare function isRejection(value: unknown): value is Rejection & RejectionInternal;
+export type RejectionInternal = {
+    [IS_REJECTION_SYMBOL]: true;
+    route: ResolvedRoute;
+    hooks: Hooks[];
+};
 /**
  * Represents an immutable array of Rejection instances.
  */
@@ -17,3 +32,4 @@ export type RejectionType<TRejections extends Rejections | undefined> = unknown
 export type ExtractRejections<T> = T extends {
     rejections: infer TRejections extends Rejections;
 } ? TRejections : [];
+export type ExtractRejectionTypes<T extends Rejections> = T[number]['type'] extends string ? T[number]['type'] : never;

package/dist/types/resolved.d.ts

@@ -44,6 +44,10 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
      * Hash value of the route.
      */
     hash: string;
+    /**
+     * Title of the route.
+     */
+    title: Promise<string | undefined>;
 }>;
 /**
  * This type is the same as `ResolvedRoute<TRoutes[number]>` while remaining distributive

package/dist/types/route.d.ts

@@ -5,6 +5,18 @@ import { LastInArray } from './utilities';
 import { CreateRouteOptions } from './createRouteOptions';
 import { RouteContext } from './routeContext';
 import { Url } from './url';
+import { GetTitle } from './titles';
+import { Hooks } from '../models/hooks';
+import { RouteRedirect } from './redirects';
+export declare const IS_ROUTE_SYMBOL: unique symbol;
+export declare function isRoute(value: unknown): value is Route & RouteInternal;
+export type RouteInternal = {
+    [IS_ROUTE_SYMBOL]: true;
+    depth: number;
+    hooks: Hooks[];
+    redirect: RouteRedirect;
+    getTitle: GetTitle;
+};
 /**
  * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
  */
@@ -56,11 +68,6 @@ export type Route<TName extends string = string, TUrl extends Url = Url, TMeta e
      * Related routes and rejections for the route. The context is exposed to the hooks and props callback functions for this route.
      */
     context: TContext;
-    /**
-    * A value that represents how many parents a route has. Used for route matching
-    * @internal
-    */
-    depth: number;
 };
 export type GenericRoute = Url & {
     id: string;
@@ -70,5 +77,4 @@ export type GenericRoute = Url & {
     meta: RouteMeta;
     state: Record<string, Param>;
     prefetch?: PrefetchConfig;
-    depth: number;
 };

package/dist/types/router.d.ts

@@ -1,7 +1,7 @@
 import { App, InjectionKey, Ref } from 'vue';
 import { RouterHistoryMode } from '../services/createRouterHistory';
 import { RouterRoute } from './routerRoute';
-import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook } from './hooks';
+import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook, AddRejectionHook } from './hooks';
 import { PrefetchConfig } from './prefetch';
 import { ResolvedRoute } from './resolved';
 import { Route, Routes } from './route';
@@ -11,7 +11,7 @@ import { RouterResolve, RouterResolveOptions } from './routerResolve';
 import { RouterReject } from './routerReject';
 import { RouterPlugin } from './routerPlugin';
 import { RoutesName } from './routesMap';
-import { ExtractRejections, Rejections } from './rejection';
+import { ExtractRejections, ExtractRejectionTypes, Rejections, BuiltInRejectionType } from './rejection';
 /**
  * Options to initialize a {@link Router} instance.
  */
@@ -130,6 +130,10 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
      * If the hook returns true, the error is considered handled and the other hooks are not run. If all hooks return false the error is rethrown
      */
     onError: AddErrorHook<TRoutes[number] | TPlugin['routes'][number], TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
+    /**
+     * Registers a hook to be called when a rejection occurs.
+     */
+    onRejection: AddRejectionHook<ExtractRejectionTypes<ExtractRejections<TOptions>> | ExtractRejectionTypes<ExtractRejections<TPlugin>> | BuiltInRejectionType, TRoutes | TPlugin['routes']>;
     /**
     * Given a URL, returns true if host does not match host stored on router instance
     */

package/dist/types/routerPlugin.d.ts

@@ -9,6 +9,12 @@ import { RouterReplace } from './routerReplace';
 import { CallbackContextAbort } from '../services/createRouterCallbackContext';
 import { MaybePromise } from './utilities';
 export type EmptyRouterPlugin = RouterPlugin<[], []>;
+export declare const IS_ROUTER_PLUGIN_SYMBOL: unique symbol;
+export declare function isRouterPlugin(value: unknown): value is RouterPlugin & RouterPluginInternal;
+export type RouterPluginInternal = {
+    [IS_ROUTER_PLUGIN_SYMBOL]: true;
+    hooks: Hooks;
+};
 export type CreateRouterPluginOptions<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     routes?: TRoutes;
     rejections?: TRejections;
@@ -16,19 +22,12 @@ export type CreateRouterPluginOptions<TRoutes extends Routes = Routes, TRejectio
 export type RouterPlugin<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     /**
      * The routes supplied by the plugin.
-     * @internal
     */
     routes: TRoutes;
     /**
     * The rejections supplied by the plugin.
-     * @internal
-     */
+    */
     rejections: TRejections;
-    /**
-     * The hooks supplied by the plugin.
-     * @internal
-     */
-    hooks: Hooks;
 };
 type PluginBeforeRouteHookContext<TRoutes extends Routes, TRejections extends Rejections> = {
     from: ResolvedRoute | null;

package/dist/types/routerReject.d.ts

@@ -1,3 +1,2 @@
-import { BuiltInRejectionType } from '../services/createRouterReject';
-import { Rejections, RejectionType } from './rejection';
+import { BuiltInRejectionType, Rejections, RejectionType } from './rejection';
 export type RouterReject<TRejections extends Rejections | undefined> = <TSource extends (RejectionType<TRejections> | BuiltInRejectionType)>(type: TSource) => void;

package/dist/types/routerRoute.d.ts

@@ -31,6 +31,10 @@ export type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
      * String value of the resolved URL.
      */
     readonly href: TRoute['href'];
+    /**
+     * Title of the route.
+     */
+    readonly title: TRoute['title'];
     params: TRoute['params'];
     state: TRoute['state'];
     get query(): URLSearchParams;

package/dist/types/titles.d.ts

@@ -14,13 +14,9 @@ export type RouteSetTitle<TRoute extends Route = Route> = {
      */
     setTitle: SetTitle<TRoute>;
 };
-export type RouteGetTitle<TRoute extends Route = Route> = {
-    /**
-     * @internal
-     * Gets the title for the route.
-     */
-    getTitle: GetTitle<TRoute>;
+type CreateRouteTitle = {
+    setTitle: SetTitle;
+    getTitle: GetTitle;
 };
-export declare function isRouteWithTitleSetter<T extends Route | ResolvedRoute>(route: T): route is T & RouteSetTitle;
-export declare function isRouteWithTitleGetter<T extends Route | ResolvedRoute>(route: T): route is T & RouteGetTitle;
-export declare function createRouteTitle(parent: Route | undefined): RouteGetTitle & RouteSetTitle;
+export declare function createRouteTitle(parent: Route | undefined): CreateRouteTitle;
+export {};

package/dist/types/url.d.ts

@@ -5,6 +5,11 @@ import { UrlString } from './urlString';
 import { ParamGetSet } from './paramTypes';
 import { MakeOptional } from '../utilities/makeOptional';
 export declare const IS_URL_SYMBOL: unique symbol;
+export type UrlInternal = {
+    [IS_URL_SYMBOL]: true;
+    schema: Record<string, UrlPart>;
+    params: {};
+};
 export type CreateUrlOptions = {
     host?: string | UrlPart | undefined;
     path?: string | UrlPart | undefined;
@@ -12,13 +17,7 @@ export type CreateUrlOptions = {
     hash?: string | UrlPart | undefined;
 };
 export type ToUrl<TOptions extends CreateUrlOptions> = Url<Identity<ToUrlPart<TOptions['host']>['params'] & ToUrlPart<TOptions['path']>['params'] & ToUrlQueryPart<TOptions['query']>['params'] & ToUrlPart<TOptions['hash']>['params']>>;
-/**
- * Type guard to assert that a url has a schema.
- * @internal
- */
-export declare function isUrlWithSchema(url: unknown): url is Url & {
-    schema: Record<string, UrlPart>;
-};
+export declare function isUrl(url: unknown): url is Url & UrlInternal;
 export type ParseUrlOptions = {
     /**
      * Whether to remove trailing slashes from the path. When true, trailing slashes will be removed from the path.
@@ -58,11 +57,6 @@ export type Url<TParams extends UrlParams = UrlParams> = {
      * True if the url is relative. False if the url is absolute.
      */
     isRelative: boolean;
-    /**
-     * @internal
-     * Symbol to identify if the url is a valid url.
-     */
-    [IS_URL_SYMBOL]: true;
 };
 type UrlParamsArgs<TParams extends UrlParams> = AllPropertiesAreOptional<ToUrlParamsWriting<TParams>> extends true ? [params?: ToUrlParamsWriting<TParams>] : [params: ToUrlParamsWriting<TParams>];
 /**