litzjs 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,559 @@
+import * as React from "react";
+
+//#region src/index.d.ts
+type MiddlewareOverrides<TContext = unknown> = {
+  context?: TContext;
+};
+type MiddlewareContext<TContext = unknown> = {
+  request: Request;
+  params: Record<string, string>;
+  signal: AbortSignal;
+  context: TContext;
+};
+type MiddlewareNext<TContext = unknown, TResult = unknown> = (overrides?: MiddlewareOverrides<TContext>) => Promise<TResult>;
+type MiddlewareHandler<TContext = unknown, TResult = unknown> = (context: MiddlewareContext<TContext>, next: MiddlewareNext<TContext, TResult>) => TResult | Promise<TResult>;
+type Middleware<TContext = unknown, TResult = ServerResult> = MiddlewareHandler<TContext, TResult>;
+type MiddlewareRef<TContext = unknown, TResult = unknown> = MiddlewareHandler<TContext, TResult>;
+type RouteErrorLike = {
+  kind: "error";
+  status: number;
+  message: string;
+  code?: string;
+  data?: unknown;
+} | {
+  kind: "fault";
+  status: number;
+  message: string;
+  digest?: string;
+};
+type RouteStatus = "idle" | "loading" | "submitting" | "revalidating" | "offline-stale" | "error";
+type SubmitOptions<TResult extends ServerResult = ServerResult> = {
+  onBeforeSubmit?: (formData: FormData) => void;
+  onSuccess?: (result: ActionSuccessResultFor<TResult>) => void;
+  onError?: (result: ActionErrorResultFor<TResult>) => void;
+  replace?: boolean;
+  revalidate?: boolean | string[];
+};
+type SearchParamsUpdate = Record<string, string | string[] | null | undefined>;
+type LitzLocation = {
+  href: string;
+  pathname: string;
+  search: URLSearchParams;
+  hash: string;
+};
+type SetSearchParams = (params: SearchParamsUpdate, options?: {
+  replace?: boolean;
+}) => void;
+type RouteFormProps = Omit<React.ComponentPropsWithoutRef<"form">, "action" | "method"> & {
+  replace?: boolean;
+  revalidate?: boolean | string[];
+};
+type NormalizedResult = {
+  kind: "data";
+  status: number;
+  headers: Headers;
+  data: unknown;
+  revalidate: string[];
+} | {
+  kind: "invalid";
+  status: number;
+  headers: Headers;
+  fields?: Record<string, string>;
+  formError?: string;
+  data?: unknown;
+} | {
+  kind: "redirect";
+  status: number;
+  headers: Headers;
+  location: string;
+  replace: boolean;
+  revalidate: string[];
+} | {
+  kind: "error";
+  status: number;
+  headers: Headers;
+  message: string;
+  code?: string;
+  data?: unknown;
+} | {
+  kind: "fault";
+  status: number;
+  headers: Headers;
+  message: string;
+  digest?: string;
+};
+type DataResult<TData = unknown> = {
+  kind: "data";
+  status?: number;
+  headers?: HeadersInit;
+  data: TData;
+  revalidate?: string[];
+};
+type ViewResult<TNode extends React.ReactNode = React.ReactNode> = {
+  kind: "view";
+  headers?: HeadersInit;
+  node: TNode;
+  revalidate?: string[];
+};
+type InvalidResult<TData = unknown> = {
+  kind: "invalid";
+  status?: number;
+  headers?: HeadersInit;
+  fields?: Record<string, string>;
+  formError?: string;
+  data?: TData;
+};
+type RedirectResult = {
+  kind: "redirect";
+  status?: number;
+  headers?: HeadersInit;
+  location: string;
+  replace?: boolean;
+  revalidate?: string[];
+};
+type ErrorResult<TData = unknown> = {
+  kind: "error";
+  status: number;
+  headers?: HeadersInit;
+  message: string;
+  code?: string;
+  data?: TData;
+};
+type FaultResult = {
+  kind: "fault";
+  status: number;
+  headers?: HeadersInit;
+  message: string;
+  digest?: string;
+};
+type ServerResult = DataResult<any> | ViewResult<any> | InvalidResult<any> | RedirectResult | ErrorResult<any> | FaultResult;
+type ResultWithHeaders = {
+  headers?: HeadersInit;
+};
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+type NoInferType<T> = [T][T extends any ? 0 : never];
+type PresentResult<T> = [T] extends [never] ? never : T;
+type ExtractPathParamName<TSegment extends string> = TSegment extends `${infer TParam}/${string}` ? TParam : TSegment extends `${infer TParam}?${string}` ? TParam : TSegment extends `${infer TParam}#${string}` ? TParam : TSegment;
+type ExtractPathParamRest<TSegment extends string> = TSegment extends `${string}/${infer TRest}` ? TRest : never;
+type ExtractPathParamNames<TPath extends string> = string extends TPath ? string : TPath extends `${string}:${infer TSegment}` ? ExtractPathParamName<TSegment> | (ExtractPathParamRest<TSegment> extends never ? never : ExtractPathParamNames<ExtractPathParamRest<TSegment>>) : never;
+type PathParams<TPath extends string> = string extends TPath ? Record<string, string> : [ExtractPathParamNames<TPath>] extends [never] ? {} : Simplify<{ [TKey in ExtractPathParamNames<TPath>]: string }>;
+type PathRequestParams<TPath extends string> = string extends TPath ? {
+  params?: Record<string, string>;
+} : [ExtractPathParamNames<TPath>] extends [never] ? {
+  params?: {};
+} : {
+  params: PathParams<TPath>;
+};
+type SearchRequest = {
+  search?: URLSearchParams | Record<string, string>;
+};
+type HasRequiredPathParams<TPath extends string> = string extends TPath ? false : [ExtractPathParamNames<TPath>] extends [never] ? false : true;
+type MaybeRequiredArg<TPath extends string, TValue> = HasRequiredPathParams<TPath> extends true ? [value: TValue] : [value?: TValue];
+type LoaderDataFor<TResult extends ServerResult> = Extract<TResult, {
+  kind: "data";
+}> extends {
+  data: infer TData;
+} ? TData : never;
+type LoaderNodeFor<TResult extends ServerResult> = Extract<TResult, {
+  kind: "view";
+}> extends {
+  node: infer TNode;
+} ? TNode : never;
+type InvalidDataFor<TResult extends ServerResult> = Extract<TResult, {
+  kind: "invalid";
+}> extends {
+  data?: infer TData;
+} ? TData : never;
+type ActionDataFor<TResult extends ServerResult> = Extract<TResult, {
+  kind: "data";
+}> extends {
+  data: infer TData;
+} ? TData : never;
+type ActionViewNodeFor<TResult extends ServerResult> = Extract<TResult, {
+  kind: "view";
+}> extends {
+  node: infer TNode;
+} ? TNode : never;
+type ErrorDataFor<TResult extends ServerResult> = Extract<TResult, {
+  kind: "error";
+}> extends {
+  data?: infer TData;
+} ? TData : never;
+type LoaderDataHookBranch<TData> = {
+  kind: "data";
+  status: number;
+  headers: Headers;
+  stale: boolean;
+  data: TData;
+  render(this: void): React.ReactNode;
+};
+type LoaderViewHookBranch<TNode extends React.ReactNode> = {
+  kind: "view";
+  status: number;
+  headers: Headers;
+  stale: boolean;
+  node: TNode;
+  render(this: void): React.ReactNode;
+};
+type ActionInvalidHookBranch<TData> = {
+  kind: "invalid";
+  status: number;
+  headers: Headers;
+  fields?: Record<string, string>;
+  formError?: string;
+  data?: TData;
+};
+type ActionDataHookBranch<TData> = {
+  kind: "data";
+  status: number;
+  headers: Headers;
+  data: TData;
+};
+type ActionViewHookBranch<TNode extends React.ReactNode> = {
+  kind: "view";
+  status: number;
+  headers: Headers;
+  node: TNode;
+  render(this: void): React.ReactNode;
+};
+type ActionRedirectHookBranch = {
+  kind: "redirect";
+  status: number;
+  headers: Headers;
+  location: string;
+  replace: boolean;
+};
+type ActionErrorHookBranch<TData> = {
+  kind: "error";
+  status: number;
+  headers: Headers;
+  message: string;
+  code?: string;
+  data?: TData;
+};
+type ActionFaultHookBranch = {
+  kind: "fault";
+  status: number;
+  headers: Headers;
+  message: string;
+  digest?: string;
+};
+type LoaderHookResultFor<TResult extends ServerResult = ServerResult> = PresentResult<Extract<TResult, {
+  kind: "data";
+}> extends never ? never : LoaderDataHookBranch<LoaderDataFor<TResult>>> | PresentResult<Extract<TResult, {
+  kind: "view";
+}> extends never ? never : LoaderViewHookBranch<LoaderNodeFor<TResult> & React.ReactNode>>;
+type ActionHookResultFor<TResult extends ServerResult = ServerResult> = null | PresentResult<Extract<TResult, {
+  kind: "invalid";
+}> extends never ? never : ActionInvalidHookBranch<InvalidDataFor<TResult>>> | PresentResult<Extract<TResult, {
+  kind: "data";
+}> extends never ? never : ActionDataHookBranch<ActionDataFor<TResult>>> | PresentResult<Extract<TResult, {
+  kind: "view";
+}> extends never ? never : ActionViewHookBranch<ActionViewNodeFor<TResult> & React.ReactNode>> | PresentResult<Extract<TResult, {
+  kind: "redirect";
+}> extends never ? never : ActionRedirectHookBranch> | PresentResult<Extract<TResult, {
+  kind: "error";
+}> extends never ? never : ActionErrorHookBranch<ErrorDataFor<TResult>>> | PresentResult<Extract<TResult, {
+  kind: "fault";
+}> extends never ? never : ActionFaultHookBranch>;
+type LoaderHookResult = LoaderHookResultFor<ServerResult>;
+type ActionHookResult = ActionHookResultFor<ServerResult>;
+type LoaderDataValueFor<TResult extends ServerResult> = LoaderDataFor<TResult> | null;
+type LoaderViewValueFor<TResult extends ServerResult> = (LoaderNodeFor<TResult> & React.ReactNode) | null;
+type ActionDataValueFor<TResult extends ServerResult> = ActionDataFor<TResult> | null;
+type ActionViewValueFor<TResult extends ServerResult> = (ActionViewNodeFor<TResult> & React.ReactNode) | null;
+type ActionInvalidValueFor<TResult extends ServerResult> = Extract<ActionHookResultFor<TResult>, {
+  kind: "invalid";
+}> | null;
+type ActionExplicitErrorValueFor<TResult extends ServerResult> = Extract<ActionHookResultFor<TResult>, {
+  kind: "error";
+}> | null;
+type MergedDataValueFor<TLoaderResult extends ServerResult, TActionResult extends ServerResult> = LoaderDataFor<TLoaderResult> | ActionDataFor<TActionResult> | null;
+type MergedViewValueFor<TLoaderResult extends ServerResult, TActionResult extends ServerResult> = (LoaderNodeFor<TLoaderResult> & React.ReactNode) | (ActionViewNodeFor<TActionResult> & React.ReactNode) | null;
+type ActionErrorResultFor<TResult extends ServerResult = ServerResult> = Extract<ActionHookResultFor<TResult>, {
+  kind: "error" | "fault";
+}>;
+type ActionSuccessResultFor<TResult extends ServerResult = ServerResult> = Exclude<ActionHookResultFor<TResult>, null | ActionErrorResultFor<TResult>>;
+type RouteHandlerContext<TContext = unknown, TPath extends string = string> = {
+  request: Request;
+  params: PathParams<TPath>;
+  signal: AbortSignal;
+  context: TContext;
+};
+type ResourceHandlerContext<TContext = unknown, TPath extends string = string> = {
+  request: Request;
+  params: PathParams<TPath>;
+  signal: AbortSignal;
+  context: TContext;
+};
+type ApiHandlerContext<TContext = unknown, TPath extends string = string> = {
+  request: Request;
+  params: PathParams<TPath>;
+  signal: AbortSignal;
+  context: TContext;
+};
+type ApiRouteMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD" | "ALL";
+type ApiRouteHandler<TContext = unknown, TPath extends string = string> = (context: ApiHandlerContext<TContext, TPath>) => Promise<Response> | Response;
+type ApiRouteHandlers<TContext = unknown, TPath extends string = string> = Partial<Record<ApiRouteMethod, ApiRouteHandler<TContext, TPath>>>;
+type DefineApiRouteOptions<TContext = unknown, TPath extends string = string, TMethods extends ApiRouteHandlers<TContext, TPath> = ApiRouteHandlers<TContext, TPath>> = Simplify<TMethods & {
+  middleware?: MiddlewareRef<NoInferType<TContext>, Response>[];
+}>;
+type ApiFetchMethod<TMethods extends ApiRouteHandlers<any, any>> = "ALL" extends keyof TMethods ? Exclude<ApiRouteMethod, "ALL"> : Exclude<Extract<keyof TMethods, ApiRouteMethod>, "ALL">;
+type ApiFetchOptions<TPath extends string = string, TMethods extends ApiRouteHandlers<any, TPath> = ApiRouteHandlers<any, TPath>> = Omit<RequestInit, "method"> & PathRequestParams<TPath> & SearchRequest & {
+  method?: ApiFetchMethod<TMethods>;
+};
+type RouteServerHandler<TContext = unknown, TResult extends ServerResult = ServerResult, TPath extends string = string> = (context: RouteHandlerContext<TContext, TPath>) => Promise<TResult> | TResult;
+type ResourceServerHandler<TContext = unknown, TResult extends ServerResult = ServerResult, TPath extends string = string> = (context: ResourceHandlerContext<TContext, TPath>) => Promise<TResult> | TResult;
+type ServerHandler<TContext = unknown, TResult extends ServerResult = ServerResult> = RouteServerHandler<TContext, TResult> | ResourceServerHandler<TContext, TResult>;
+type DefineRouteOptions<TPath extends string = string, TContext = unknown, TLoaderResult extends ServerResult = ServerResult, TActionResult extends ServerResult = ServerResult> = {
+  component: React.ComponentType;
+  layout?: LayoutReference;
+  loader?: RouteServerHandler<TContext, TLoaderResult, NoInferType<TPath>>;
+  action?: RouteServerHandler<TContext, TActionResult, NoInferType<TPath>>;
+  middleware?: MiddlewareRef<TContext, ServerResult>[];
+  pendingComponent?: React.ComponentType;
+  errorComponent?: React.ComponentType<{
+    error: RouteErrorLike;
+  }>;
+  offline?: {
+    fallbackComponent?: React.ComponentType;
+    preserveStaleOnFailure?: boolean;
+  };
+};
+type RouteBaseOptions<TPath extends string = string, TContext = unknown> = Omit<DefineRouteOptions<TPath, TContext, ServerResult, ServerResult>, "loader" | "action">;
+type RouteLoaderOption<TPath extends string = string, TContext = unknown, TLoaderResult extends ServerResult = never> = [TLoaderResult] extends [never] ? {
+  loader?: never;
+} : {
+  loader: RouteServerHandler<TContext, TLoaderResult, TPath>;
+};
+type RouteActionOption<TPath extends string = string, TContext = unknown, TActionResult extends ServerResult = never> = [TActionResult] extends [never] ? {
+  action?: never;
+} : {
+  action: RouteServerHandler<TContext, TActionResult, TPath>;
+};
+type DefineLayoutOptions<TPath extends string = string, TContext = unknown, TLoaderResult extends ServerResult = ServerResult> = {
+  component: React.JSXElementConstructor<{
+    children: React.ReactNode;
+  }>;
+  layout?: LayoutReference;
+  loader?: RouteServerHandler<TContext, TLoaderResult, NoInferType<TPath>>;
+  middleware?: MiddlewareRef<TContext, ServerResult>[];
+  pendingComponent?: React.ComponentType;
+  errorComponent?: React.ComponentType<{
+    error: RouteErrorLike;
+  }>;
+};
+type LayoutBaseOptions<TPath extends string = string, TContext = unknown> = Omit<DefineLayoutOptions<TPath, TContext, ServerResult>, "loader">;
+type LayoutLoaderOption<TPath extends string = string, TContext = unknown, TLoaderResult extends ServerResult = never> = [TLoaderResult] extends [never] ? {
+  loader?: never;
+} : {
+  loader: RouteServerHandler<TContext, TLoaderResult, TPath>;
+};
+type LitzLayout<TPath extends string = string, TContext = unknown, TLoaderResult extends ServerResult = never> = Simplify<{
+  id: TPath;
+  path: TPath;
+  component: React.JSXElementConstructor<{
+    children: React.ReactNode;
+  }>;
+  options: LayoutBaseOptions<TPath, TContext> & LayoutLoaderOption<TPath, TContext, TLoaderResult>;
+  useParams(): PathParams<TPath>;
+  useSearch(): [URLSearchParams, SetSearchParams];
+  useStatus(): RouteStatus;
+  usePending(): boolean;
+} & ([TLoaderResult] extends [never] ? {} : LayoutLoaderClientHooks<TLoaderResult>)>;
+type LayoutReference = {
+  id: string;
+  path: string;
+  component: React.JSXElementConstructor<{
+    children: React.ReactNode;
+  }>;
+  options?: {
+    layout?: LayoutReference;
+    loader?: unknown;
+    middleware?: MiddlewareRef<any, ServerResult>[];
+    pendingComponent?: React.ComponentType;
+    errorComponent?: React.ComponentType<{
+      error: RouteErrorLike;
+    }>;
+  };
+};
+type LayoutLoaderClientHooks<TLoaderResult extends ServerResult> = {
+  useLoaderResult(): LoaderHookResultFor<TLoaderResult> | null;
+  useLoaderData(): LoaderDataValueFor<TLoaderResult>;
+  useLoaderView(): LoaderViewValueFor<TLoaderResult>;
+  useData(): LoaderDataValueFor<TLoaderResult>;
+  useView(): LoaderViewValueFor<TLoaderResult>;
+  useRetry(): () => void;
+  useReload(): () => void;
+};
+type RouteLoaderClientHooks<TLoaderResult extends ServerResult> = {
+  useLoaderResult(): LoaderHookResultFor<TLoaderResult> | null;
+  useLoaderData(): LoaderDataValueFor<TLoaderResult>;
+  useLoaderView(): LoaderViewValueFor<TLoaderResult>;
+  useRetry(): () => void;
+  useReload(): () => void;
+};
+type RouteActionClientHooks<TActionResult extends ServerResult> = {
+  useActionResult(): ActionHookResultFor<TActionResult>;
+  useActionData(): ActionDataValueFor<TActionResult>;
+  useActionView(): ActionViewValueFor<TActionResult>;
+  useActionError(): ActionExplicitErrorValueFor<TActionResult>;
+  useInvalid(): ActionInvalidValueFor<TActionResult>;
+  useSubmit(opts?: SubmitOptions<TActionResult>): (payload: FormData | Record<string, unknown>) => Promise<void>;
+  Form: React.ComponentType<RouteFormProps>;
+};
+type LitzRoute<TPath extends string = string, TContext = unknown, TLoaderResult extends ServerResult = never, TActionResult extends ServerResult = never> = Simplify<{
+  id: TPath;
+  path: TPath;
+  component: React.ComponentType;
+  options: RouteBaseOptions<TPath, TContext> & RouteLoaderOption<TPath, TContext, TLoaderResult> & RouteActionOption<TPath, TContext, TActionResult>;
+  useParams(): PathParams<TPath>;
+  useSearch(): [URLSearchParams, SetSearchParams];
+  useStatus(): RouteStatus;
+  usePending(): boolean;
+} & ([TLoaderResult] extends [never] ? {} : RouteLoaderClientHooks<TLoaderResult>) & ([TActionResult] extends [never] ? {} : RouteActionClientHooks<TActionResult>) & ([TLoaderResult] extends [never] ? [TActionResult] extends [never] ? {} : {
+  useData(): ActionDataValueFor<TActionResult>;
+  useView(): ActionViewValueFor<TActionResult>;
+  useError(): ActionExplicitErrorValueFor<TActionResult>;
+} : [TActionResult] extends [never] ? {
+  useData(): LoaderDataValueFor<TLoaderResult>;
+  useView(): LoaderViewValueFor<TLoaderResult>;
+} : {
+  useData(): MergedDataValueFor<TLoaderResult, TActionResult>;
+  useView(): MergedViewValueFor<TLoaderResult, TActionResult>;
+  useError(): ActionExplicitErrorValueFor<TActionResult>;
+})>;
+type LitzMatch<TPath extends string = string> = {
+  id: TPath;
+  path: TPath;
+  params: PathParams<TPath>;
+  search: URLSearchParams;
+};
+type ResourceRequest<TPath extends string = string> = Simplify<PathRequestParams<TPath> & SearchRequest>;
+type ResourceComponentProps<TPath extends string = string> = ResourceRequest<TPath>;
+type LitzApiRoute<TPath extends string = string, TContext = unknown, TMethods extends ApiRouteHandlers<TContext, TPath> = ApiRouteHandlers<TContext, TPath>> = {
+  path: TPath;
+  middleware?: MiddlewareRef<TContext, Response>[];
+  methods: TMethods;
+  fetch(...args: MaybeRequiredArg<TPath, ApiFetchOptions<TPath, TMethods>>): Promise<Response>;
+};
+type LitzResource<TPath extends string = string, TContext = unknown, TLoaderResult extends ServerResult = never, TActionResult extends ServerResult = never, TComponent extends React.ComponentType<ResourceComponentProps<TPath>> = React.ComponentType<ResourceComponentProps<TPath>>> = Simplify<{
+  path: TPath;
+  middleware?: MiddlewareRef<TContext, ServerResult>[];
+  component: TComponent;
+  Component: React.ComponentType<ResourceComponentProps<TPath>>;
+  useParams(): PathParams<TPath>;
+  useSearch(): [URLSearchParams, SetSearchParams];
+  useStatus(): RouteStatus;
+  usePending(): boolean;
+} & ([TLoaderResult] extends [never] ? {} : {
+  loader: ResourceServerHandler<TContext, TLoaderResult, TPath>;
+  useLoaderResult(): LoaderHookResultFor<TLoaderResult> | null;
+  useLoaderData(): LoaderDataValueFor<TLoaderResult>;
+  useLoaderView(): LoaderViewValueFor<TLoaderResult>;
+  useRetry(): () => void;
+  useReload(): () => void;
+}) & ([TActionResult] extends [never] ? {} : {
+  action: ResourceServerHandler<TContext, TActionResult, TPath>;
+  useActionResult(): ActionHookResultFor<TActionResult>;
+  useActionData(): ActionDataValueFor<TActionResult>;
+  useActionView(): ActionViewValueFor<TActionResult>;
+  useActionError(): ActionExplicitErrorValueFor<TActionResult>;
+  useInvalid(): ActionInvalidValueFor<TActionResult>;
+  useSubmit(opts?: SubmitOptions<TActionResult>): (payload: FormData | Record<string, unknown>) => Promise<void>;
+  Form: React.ComponentType<RouteFormProps>;
+}) & ([TLoaderResult] extends [never] ? [TActionResult] extends [never] ? {} : {
+  useData(): ActionDataValueFor<TActionResult>;
+  useView(): ActionViewValueFor<TActionResult>;
+  useError(): ActionExplicitErrorValueFor<TActionResult>;
+} : [TActionResult] extends [never] ? {
+  useData(): LoaderDataValueFor<TLoaderResult>;
+  useView(): LoaderViewValueFor<TLoaderResult>;
+} : {
+  useData(): MergedDataValueFor<TLoaderResult, TActionResult>;
+  useView(): MergedViewValueFor<TLoaderResult, TActionResult>;
+  useError(): ActionExplicitErrorValueFor<TActionResult>;
+})>;
+type ResourceComponentOption<TPath extends string = string, TComponent extends React.ComponentType<ResourceComponentProps<TPath>> = React.ComponentType<ResourceComponentProps<TPath>>> = {
+  component: TComponent;
+};
+type ResourceLoaderOption<TPath extends string = string, TContext = unknown, TLoaderResult extends ServerResult = never> = [TLoaderResult] extends [never] ? {
+  loader?: never;
+} : {
+  loader: ResourceServerHandler<TContext, TLoaderResult, TPath>;
+};
+type ResourceActionOption<TPath extends string = string, TContext = unknown, TActionResult extends ServerResult = never> = [TActionResult] extends [never] ? {
+  action?: never;
+} : {
+  action: ResourceServerHandler<TContext, TActionResult, TPath>;
+};
+type ResourceOptions<TPath extends string = string, TContext = unknown, TLoaderResult extends ServerResult = never, TActionResult extends ServerResult = never, TComponent extends React.ComponentType<ResourceComponentProps<TPath>> = never> = ResourceComponentOption<TPath, TComponent> & ResourceLoaderOption<TPath, TContext, TLoaderResult> & ResourceActionOption<TPath, TContext, TActionResult> & {
+  middleware?: MiddlewareRef<TContext, ServerResult>[];
+};
+declare function defineRoute<TContext = unknown, const TPath extends string = string>(path: TPath, options: RouteBaseOptions<NoInferType<TPath>, TContext> & {
+  loader?: never;
+  action?: never;
+}): LitzRoute<TPath, TContext, never, never>;
+declare function defineRoute<TContext = unknown, const TPath extends string = string, TLoaderResult extends ServerResult = ServerResult>(path: TPath, options: RouteBaseOptions<NoInferType<TPath>, TContext> & {
+  loader: RouteServerHandler<TContext, TLoaderResult, NoInferType<TPath>>;
+  action?: never;
+}): LitzRoute<TPath, TContext, TLoaderResult, never>;
+declare function defineRoute<TContext = unknown, const TPath extends string = string, TActionResult extends ServerResult = ServerResult>(path: TPath, options: RouteBaseOptions<NoInferType<TPath>, TContext> & {
+  loader?: never;
+  action: RouteServerHandler<TContext, TActionResult, NoInferType<TPath>>;
+}): LitzRoute<TPath, TContext, never, TActionResult>;
+declare function defineRoute<TContext = unknown, const TPath extends string = string, TLoaderResult extends ServerResult = ServerResult, TActionResult extends ServerResult = ServerResult>(path: TPath, options: RouteBaseOptions<NoInferType<TPath>, TContext> & {
+  loader: RouteServerHandler<TContext, TLoaderResult, NoInferType<TPath>>;
+  action: RouteServerHandler<TContext, TActionResult, NoInferType<TPath>>;
+}): LitzRoute<TPath, TContext, TLoaderResult, TActionResult>;
+declare function defineLayout<TContext = unknown, const TPath extends string = string>(path: TPath, options: LayoutBaseOptions<NoInferType<TPath>, TContext> & {
+  loader?: never;
+}): LitzLayout<TPath, TContext, never>;
+declare function defineLayout<TContext = unknown, const TPath extends string = string, TLoaderResult extends ServerResult = ServerResult>(path: TPath, options: LayoutBaseOptions<NoInferType<TPath>, TContext> & {
+  loader: RouteServerHandler<TContext, TLoaderResult, NoInferType<TPath>>;
+}): LitzLayout<TPath, TContext, TLoaderResult>;
+declare function useMatches(): LitzMatch[];
+declare function usePathname(): string;
+declare function useLocation(): LitzLocation;
+declare function defineApiRoute<TContext = unknown, const TPath extends string = string, TMethods extends ApiRouteHandlers<TContext, TPath> = ApiRouteHandlers<TContext, TPath>>(path: TPath, definition: DefineApiRouteOptions<NoInferType<TContext>, NoInferType<TPath>, TMethods>): LitzApiRoute<TPath, TContext, TMethods>;
+declare function defineResource<TContext = unknown, const TPath extends string = string>(path: TPath, options: ResourceOptions<NoInferType<TPath>, NoInferType<TContext>, never, never, React.ComponentType<ResourceComponentProps<TPath>>>): LitzResource<TPath, TContext, never, never, React.ComponentType<ResourceComponentProps<TPath>>>;
+declare function defineResource<TContext = unknown, const TPath extends string = string, TLoaderResult extends ServerResult = ServerResult, TComponent extends React.ComponentType<ResourceComponentProps<TPath>> = React.ComponentType<ResourceComponentProps<TPath>>>(path: TPath, options: ResourceOptions<NoInferType<TPath>, NoInferType<TContext>, TLoaderResult, never, TComponent>): LitzResource<TPath, TContext, TLoaderResult, never, TComponent>;
+declare function defineResource<TContext = unknown, const TPath extends string = string, TActionResult extends ServerResult = ServerResult, TComponent extends React.ComponentType<ResourceComponentProps<TPath>> = React.ComponentType<ResourceComponentProps<TPath>>>(path: TPath, options: ResourceOptions<NoInferType<TPath>, NoInferType<TContext>, never, TActionResult, TComponent>): LitzResource<TPath, TContext, never, TActionResult, TComponent>;
+declare function defineResource<TContext = unknown, const TPath extends string = string, TLoaderResult extends ServerResult = ServerResult, TActionResult extends ServerResult = ServerResult, TComponent extends React.ComponentType<ResourceComponentProps<TPath>> = React.ComponentType<ResourceComponentProps<TPath>>>(path: TPath, options: ResourceOptions<NoInferType<TPath>, NoInferType<TContext>, TLoaderResult, TActionResult, TComponent>): LitzResource<TPath, TContext, TLoaderResult, TActionResult, TComponent>;
+declare function server<TContext = unknown, TResult extends ServerResult = ServerResult, TPath extends string = string>(handler: (context: {
+  request: Request;
+  params: PathParams<NoInferType<TPath>>;
+  signal: AbortSignal;
+  context: NoInferType<TContext>;
+}) => Promise<TResult> | TResult): RouteServerHandler<TContext, TResult, TPath>;
+declare function withHeaders<TResponse extends Response>(result: TResponse, headers: HeadersInit): TResponse;
+declare function withHeaders<TResult extends ResultWithHeaders>(result: TResult, headers: HeadersInit): TResult;
+declare function data<TData>(value: TData, options?: {
+  headers?: HeadersInit;
+  status?: number;
+  revalidate?: string[];
+}): DataResult<TData>;
+declare function view<TNode extends React.ReactNode>(node: TNode, options?: {
+  headers?: HeadersInit;
+  revalidate?: string[];
+}): ViewResult<TNode>;
+declare function invalid<TData = unknown>(options: {
+  headers?: HeadersInit;
+  status?: number;
+  fields?: Record<string, string>;
+  formError?: string;
+  data?: TData;
+}): InvalidResult<TData>;
+declare function redirect(location: string, options?: {
+  headers?: HeadersInit;
+  status?: number;
+  replace?: boolean;
+  revalidate?: string[];
+}): RedirectResult;
+declare function error<TData = unknown>(status: number, message: string, options?: {
+  headers?: HeadersInit;
+  code?: string;
+  data?: TData;
+}): ErrorResult<TData>;
+//#endregion
+export { ActionErrorResultFor, ActionHookResult, ActionHookResultFor, ActionSuccessResultFor, ApiFetchOptions, ApiHandlerContext, ApiRouteHandler, ApiRouteHandlers, ApiRouteMethod, DataResult, DefineApiRouteOptions, DefineLayoutOptions, DefineRouteOptions, ErrorResult, FaultResult, InvalidResult, LayoutReference, LitzApiRoute, LitzLayout, LitzLocation, LitzMatch, LitzResource, LitzRoute, LoaderHookResult, LoaderHookResultFor, Middleware, MiddlewareContext, MiddlewareHandler, MiddlewareNext, MiddlewareOverrides, MiddlewareRef, NormalizedResult, PathParams, RedirectResult, ResourceComponentProps, ResourceHandlerContext, ResourceRequest, ResourceServerHandler, RouteErrorLike, RouteFormProps, RouteHandlerContext, RouteServerHandler, RouteStatus, SearchParamsUpdate, ServerHandler, ServerResult, SetSearchParams, SubmitOptions, ViewResult, data, defineApiRoute, defineLayout, defineResource, defineRoute, error, invalid, redirect, server, useLocation, useMatches, usePathname, view, withHeaders };