API › @builder.io/qwik-city

export interface Action<RETURN, INPUT = Record<string, any>, OPTIONAL extends boolean = true>

export interface ActionConstructor

export interface ActionOptions

export interface ActionOptionsWithValidation<B extends TypedDataValidator = TypedDataValidator>

export interface ActionStore<RETURN, INPUT, OPTIONAL extends boolean = true>

<form action={action.actionPath} />

export interface ContentMenu

export type DocumentHead =
  | DocumentHeadValue
  | ((props: DocumentHeadProps) => DocumentHeadValue);

export interface DocumentHeadProps extends RouteLocation

export interface DocumentHeadValue

export interface DocumentLink

export interface DocumentMeta

export interface DocumentStyle

export type FailReturn<T> = T & {
  failed: true;
};

Form: <O, I>(
  { action, spaReset, reloadDocument, onSubmit$, ...rest }: FormProps<O, I>,
  key: string | null
) => QwikJSX.Element;

export interface FormProps<O, I> extends Omit<QwikJSX.IntrinsicElements['form'], 'action' | 'method'>

export interface FormSubmitCompletedDetail<T>

globalAction$: ActionConstructor;

globalActionQrl: ActionConstructorQRL;

export type JSONObject = {
  [x: string]: JSONValue;
};

export type JSONValue =
  | string
  | number
  | boolean
  | {
      [x: string]: JSONValue;
    }
  | Array<JSONValue>;

Link: import("@builder.io/qwik").Component<LinkProps>;

export interface LinkProps extends AnchorAttributes

export interface Loader<RETURN>

export type LoaderSignal<T> = T extends () => ValueOrPromise<infer B>
  ? ReadonlySignal<ValueOrPromise<B>>
  : ReadonlySignal<T>;

export type MenuData = [pathname: string, menuLoader: MenuModuleLoader];

export type NavigationType = "initial" | "form" | "link" | "popstate";

export interface PageModule extends RouteModule

export declare type PathParams = Record<string, string>;

export interface QwikCityMockProps

QwikCityMockProvider: import("@builder.io/qwik").Component<QwikCityMockProps>;

export interface QwikCityPlan

export interface QwikCityProps

QwikCityProvider: import("@builder.io/qwik").Component<QwikCityProps>;

export type ResolvedDocumentHead = Required<DocumentHeadValue>;

routeAction$: ActionConstructor;

routeActionQrl: ActionConstructorQRL;

export type RouteData =
  | [pattern: RegExp, loaders: ModuleLoader[]]
  | [pattern: RegExp, loaders: ModuleLoader[], paramNames: string[]]
  | [
      pattern: RegExp,
      loaders: ModuleLoader[],
      paramNames: string[],
      originalPathname: string,
      routeBundleNames: string[]
    ];

routeLoader$: LoaderConstructor;

routeLoaderQrl: LoaderConstructorQRL;

export interface RouteLocation

export type RouteNavigate = QRL<
  (
    path?: string,
    options?:
      | {
          type?: Exclude<NavigationType, "initial">;
          forceReload?: boolean;
          replaceState?: boolean;
        }
      | boolean
  ) => Promise<void>
>;

RouterOutlet: import("@builder.io/qwik").Component<{}>;

server$: <T extends import("./types").ServerFunction>(first: T) => QRL<T>;

serverQrl: ServerConstructorQRL;

ServiceWorkerRegister: (props: { nonce?: string }) =>
  import("@builder.io/qwik").JSXNode<"script">;

export interface StaticGenerate

export type StaticGenerateHandler = () =>
  | Promise<StaticGenerate>
  | StaticGenerate;

useContent: () => import("./types").ContentState;

useDocumentHead: () => Required<ResolvedDocumentHead>;

useLocation: () => RouteLocation;

useNavigate: () => RouteNavigate;

validator$: ValidatorConstructor;

validatorQrl: ValidatorConstructorQRL;

zod$: ZodConstructor;

export interface ZodConstructor

zodQrl: ZodConstructorQRL;