inertia-angular 3.7.1

package/types/inertia-angular.d.ts

@@ -0,0 +1,498 @@
+import * as _inertiajs_core from '@inertiajs/core';
+import { PageProps, SharedPageProps, CreateInertiaAppOptions, Page, LayoutCallbackReturn, ServerHeadOption, HeadManager, LayoutProps, NamedLayoutProps, LinkComponentBaseProps, UrlMethodPair, Method, RequestPayload, LinkPrefetchOption, CacheForOption, CancelToken, PendingVisit, ActiveVisit, Errors, ReloadOptions, PollOptions, VisitOptions, FormDataErrors, Progress, FormDataKeys, FormDataValues, UseFormTransformCallback, ErrorValue, UseFormWithPrecognitionArguments, UseFormSubmitArguments, UseFormSubmitOptions, OptimisticCallback, FormDataType, UseHttpSubmitArguments, UseHttpSubmitOptions, FormDataConvertible, HttpProgressEvent, FormComponentOptions, FormComponentOptimisticCallback, FormComponentOnSubmitCompleteArguments, FormComponentProps, InfiniteScrollRef, InfiniteScrollSlotProps, InfiniteScrollActionSlotProps } from '@inertiajs/core';
+export { http, progress, router } from '@inertiajs/core';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, Type, Provider, EnvironmentProviders, ApplicationRef, ViewContainerRef, Signal, OnInit, WritableSignal, TemplateRef } from '@angular/core';
+import { NamedInputEvent, ValidationConfig, Validator } from 'laravel-precognition';
+
+declare class App implements AfterViewInit {
+    #private;
+    private readonly outlet;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<App, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<App, "inertia-app", never, {}, {}, never, never, true, never>;
+}
+
+type AngularRenderNode = {
+    component: Type<unknown>;
+    children: AngularRenderNode[];
+};
+type AngularRenderFunction = (h: (component: Type<unknown>, children?: AngularRenderNode | AngularRenderNode[]) => AngularRenderNode, page: AngularRenderNode) => AngularRenderNode;
+type LayoutCallback = (props: SharedPageProps) => LayoutCallbackReturn<Type<unknown>>;
+type AngularLayout = Type<unknown> | Type<unknown>[] | LayoutCallback | AngularRenderFunction | LayoutCallbackReturn<Type<unknown>>;
+type ResolvedComponent = Type<unknown> & {
+    layout?: AngularLayout;
+};
+type ComponentResolver = (name: string, page?: Page<SharedPageProps>) => ResolvedComponent | Promise<ResolvedComponent> | {
+    default: ResolvedComponent;
+};
+type InertiaAppProps<SharedProps extends PageProps = PageProps> = {
+    initialPage: Page<SharedProps>;
+    initialComponent: ResolvedComponent;
+    resolveComponent: (name: string, page?: Page) => Promise<ResolvedComponent>;
+    titleCallback?: (title: string, page: Page) => string;
+    defaultLayout?: (name: string, page: Page) => unknown;
+    serverHead?: ServerHeadOption;
+    onHeadUpdate?: (elements: string[]) => void;
+};
+type SetupOptions<SharedProps extends PageProps = PageProps> = {
+    el: HTMLElement | null;
+    App: Type<unknown>;
+    props: InertiaAppProps<SharedProps>;
+    providers: Array<Provider | EnvironmentProviders>;
+};
+type AngularWithApp<SharedProps extends PageProps = PageProps> = (options: {
+    ssr: boolean;
+    page: Page<SharedProps>;
+}) => Array<Provider | EnvironmentProviders>;
+type AngularInertiaAppConfig = Record<never, never>;
+type AngularCreateInertiaAppOptions<SharedProps extends PageProps = PageProps & SharedPageProps> = Omit<CreateInertiaAppOptions<ComponentResolver, SetupOptions<SharedProps>, ApplicationRef | void, AngularInertiaAppConfig>, 'setup'> & {
+    page?: Page<SharedProps>;
+    setup?: (options: SetupOptions<SharedProps>) => ApplicationRef | void | Promise<ApplicationRef | void>;
+    withApp?: AngularWithApp<SharedProps>;
+};
+
+declare const config: _inertiajs_core.Config<_inertiajs_core.InertiaAppConfig & AngularInertiaAppConfig>;
+
+declare function createInertiaApp<SharedProps extends PageProps = PageProps & SharedPageProps>(options: AngularCreateInertiaAppOptions<SharedProps>): Promise<ApplicationRef | void>;
+
+declare class LayoutOutlet implements AfterViewInit {
+    #private;
+    readonly outlet: _angular_core.Signal<ViewContainerRef>;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayoutOutlet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LayoutOutlet, "inertia-layout-outlet", never, {}, {}, never, never, true, never>;
+}
+declare function h(component: Type<unknown>, children?: AngularRenderNode | AngularRenderNode[]): AngularRenderNode;
+declare class InertiaRenderer {
+    #private;
+    constructor();
+    render(root: ViewContainerRef, component: ResolvedComponent, page: Page, key: number | null, dynamicProps: {
+        shared: Record<string, unknown>;
+        named: Record<string, Record<string, unknown>>;
+    }, defaultLayout?: (name: string, page: Page) => unknown): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InertiaRenderer, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InertiaRenderer>;
+}
+
+declare class InertiaRuntime {
+    #private;
+    readonly page: Signal<Page<PageProps>>;
+    readonly component: Signal<ResolvedComponent>;
+    readonly key: Signal<number | null>;
+    readonly layoutProps: Signal<{
+        shared: Record<string, unknown>;
+        named: Record<string, Record<string, unknown>>;
+    }>;
+    readonly headManager: HeadManager;
+    constructor();
+    /** @internal Not part of the public API. May change or be removed without notice. */
+    connectRenderer(render: () => void): () => void;
+    setLayoutProps(props: Partial<LayoutProps>): void;
+    setNamedLayoutProps<K extends keyof NamedLayoutProps>(name: K, props: Partial<NamedLayoutProps[K]>): void;
+    resetLayoutProps(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InertiaRuntime, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InertiaRuntime>;
+}
+declare function usePage<TProps extends PageProps = PageProps>(): Signal<Page<TProps & PageProps>>;
+declare function useLayoutProps(): {
+    set: (props: Partial<LayoutProps>) => void;
+    setFor: <K extends keyof NamedLayoutProps>(name: K, props: Partial<NamedLayoutProps[K]>) => void;
+    reset: () => void;
+};
+
+interface InertiaLinkProps extends LinkComponentBaseProps {
+    href: string | UrlMethodPair;
+}
+declare class Link implements OnInit {
+    #private;
+    readonly href: _angular_core.InputSignal<string | UrlMethodPair>;
+    readonly method: _angular_core.InputSignal<Method | "GET" | "POST" | "PUT" | "PATCH" | "DELETE">;
+    readonly data: _angular_core.InputSignal<RequestPayload>;
+    readonly preserveScroll: _angular_core.InputSignal<NonNullable<_inertiajs_core.PreserveStateOption | undefined>>;
+    readonly preserveState: _angular_core.InputSignal<_inertiajs_core.PreserveStateOption | null | undefined>;
+    readonly preserveUrl: _angular_core.InputSignal<boolean>;
+    readonly replace: _angular_core.InputSignal<boolean>;
+    readonly only: _angular_core.InputSignal<string[]>;
+    readonly except: _angular_core.InputSignal<string[]>;
+    readonly headers: _angular_core.InputSignal<Record<string, string>>;
+    readonly queryStringArrayFormat: _angular_core.InputSignal<NonNullable<_inertiajs_core.QueryStringArrayFormatOption | undefined>>;
+    readonly async: _angular_core.InputSignal<boolean>;
+    readonly viewTransition: _angular_core.InputSignal<NonNullable<boolean | ((viewTransition: ViewTransition) => void) | undefined>>;
+    readonly component: _angular_core.InputSignal<string | null>;
+    readonly instant: _angular_core.InputSignal<boolean>;
+    readonly pageProps: _angular_core.InputSignal<Record<string, unknown> | ((currentProps: _inertiajs_core.PageProps, sharedProps: Partial<_inertiajs_core.PageProps>) => Record<string, unknown>) | null>;
+    readonly prefetch: _angular_core.InputSignal<boolean | LinkPrefetchOption | LinkPrefetchOption[]>;
+    readonly cacheFor: _angular_core.InputSignal<CacheForOption | CacheForOption[] | undefined>;
+    readonly cacheTags: _angular_core.InputSignal<string | string[]>;
+    readonly onCancelToken: _angular_core.InputSignal<_inertiajs_core.CancelTokenCallback | null>;
+    readonly onBefore: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"before", RequestPayload> | null>;
+    readonly onStart: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"start", RequestPayload> | null>;
+    readonly onProgress: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"progress", RequestPayload> | null>;
+    readonly onFinish: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"finish", RequestPayload> | null>;
+    readonly onCancel: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"cancel", RequestPayload> | null>;
+    readonly onSuccess: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"success", RequestPayload> | null>;
+    readonly onError: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"error", RequestPayload> | null>;
+    readonly onPrefetching: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"prefetching", RequestPayload> | null>;
+    readonly onPrefetched: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"prefetched", RequestPayload> | null>;
+    readonly cancelToken: _angular_core.OutputEmitterRef<CancelToken>;
+    readonly before: _angular_core.OutputEmitterRef<PendingVisit>;
+    readonly start: _angular_core.OutputEmitterRef<PendingVisit>;
+    readonly progress: _angular_core.OutputEmitterRef<_inertiajs_core.HttpProgressEvent | undefined>;
+    readonly finish: _angular_core.OutputEmitterRef<ActiveVisit>;
+    readonly cancel: _angular_core.OutputEmitterRef<void>;
+    readonly success: _angular_core.OutputEmitterRef<Page<_inertiajs_core.PageProps>>;
+    readonly error: _angular_core.OutputEmitterRef<Errors>;
+    readonly prefetching: _angular_core.OutputEmitterRef<PendingVisit>;
+    readonly prefetched: _angular_core.OutputEmitterRef<{
+        response: unknown;
+        visit: PendingVisit;
+    }>;
+    readonly loading: _angular_core.Signal<boolean>;
+    readonly anchorHref: _angular_core.Signal<string | null>;
+    readonly buttonType: _angular_core.Signal<"button" | null>;
+    constructor();
+    ngOnInit(): void;
+    handleClick(event: MouseEvent): void;
+    handleMouseEnter(): void;
+    handleMouseLeave(): void;
+    handleMouseDown(event: MouseEvent): void;
+    handleMouseUp(event: MouseEvent): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    handleKeyUp(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Link, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Link, "[inertiaLink]", ["inertiaLink"], { "href": { "alias": "href"; "required": false; "isSignal": true; }; "method": { "alias": "method"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "preserveScroll": { "alias": "preserveScroll"; "required": false; "isSignal": true; }; "preserveState": { "alias": "preserveState"; "required": false; "isSignal": true; }; "preserveUrl": { "alias": "preserveUrl"; "required": false; "isSignal": true; }; "replace": { "alias": "replace"; "required": false; "isSignal": true; }; "only": { "alias": "only"; "required": false; "isSignal": true; }; "except": { "alias": "except"; "required": false; "isSignal": true; }; "headers": { "alias": "headers"; "required": false; "isSignal": true; }; "queryStringArrayFormat": { "alias": "queryStringArrayFormat"; "required": false; "isSignal": true; }; "async": { "alias": "async"; "required": false; "isSignal": true; }; "viewTransition": { "alias": "viewTransition"; "required": false; "isSignal": true; }; "component": { "alias": "component"; "required": false; "isSignal": true; }; "instant": { "alias": "instant"; "required": false; "isSignal": true; }; "pageProps": { "alias": "pageProps"; "required": false; "isSignal": true; }; "prefetch": { "alias": "prefetch"; "required": false; "isSignal": true; }; "cacheFor": { "alias": "cacheFor"; "required": false; "isSignal": true; }; "cacheTags": { "alias": "cacheTags"; "required": false; "isSignal": true; }; "onCancelToken": { "alias": "onCancelToken"; "required": false; "isSignal": true; }; "onBefore": { "alias": "onBefore"; "required": false; "isSignal": true; }; "onStart": { "alias": "onStart"; "required": false; "isSignal": true; }; "onProgress": { "alias": "onProgress"; "required": false; "isSignal": true; }; "onFinish": { "alias": "onFinish"; "required": false; "isSignal": true; }; "onCancel": { "alias": "onCancel"; "required": false; "isSignal": true; }; "onSuccess": { "alias": "onSuccess"; "required": false; "isSignal": true; }; "onError": { "alias": "onError"; "required": false; "isSignal": true; }; "onPrefetching": { "alias": "onPrefetching"; "required": false; "isSignal": true; }; "onPrefetched": { "alias": "onPrefetched"; "required": false; "isSignal": true; }; }, { "cancelToken": "cancelToken"; "before": "before"; "start": "start"; "progress": "progress"; "finish": "finish"; "cancel": "cancel"; "success": "success"; "error": "error"; "prefetching": "prefetching"; "prefetched": "prefetched"; }, never, never, true, never>;
+}
+
+declare function usePoll(interval: number, requestOptions?: ReloadOptions | (() => ReloadOptions), options?: PollOptions): {
+    stop: VoidFunction;
+    start: VoidFunction;
+    polling: Signal<boolean>;
+};
+
+declare function usePrefetch(options?: VisitOptions): {
+    lastUpdatedAt: Signal<number | null>;
+    isPrefetching: Signal<boolean>;
+    isPrefetched: Signal<boolean>;
+    flush: () => void;
+};
+
+declare function useRemember<T>(initialState: T, key?: string, exclude?: readonly string[]): WritableSignal<T>;
+
+type SetDataByObject<TForm> = (data: Partial<TForm>) => void;
+type SetDataByMethod<TForm> = (data: (previousData: TForm) => TForm) => void;
+type SetDataByKeyValuePair<TForm> = <K extends FormDataKeys<TForm>>(key: K, value: FormDataValues<TForm, K>) => void;
+type SetDataAction<TForm extends object> = SetDataByObject<TForm> & SetDataByMethod<TForm> & SetDataByKeyValuePair<TForm>;
+type PrecognitionValidationConfig<TKeys> = ValidationConfig & {
+    only?: TKeys[] | Iterable<TKeys> | ArrayLike<TKeys>;
+};
+interface FormState<TForm extends object> {
+    data: WritableSignal<TForm>;
+    isDirty: Signal<boolean>;
+    errors: Signal<FormDataErrors<TForm>>;
+    hasErrors: Signal<boolean>;
+    processing: Signal<boolean>;
+    progress: Signal<Progress | null>;
+    wasSuccessful: Signal<boolean>;
+    recentlySuccessful: Signal<boolean>;
+    setData: SetDataAction<TForm>;
+    transform(callback: UseFormTransformCallback<TForm>): this;
+    setDefaults: {
+        (): void;
+        <K extends FormDataKeys<TForm>>(field: K, value: FormDataValues<TForm, K>): void;
+        (fields: Partial<TForm>): void;
+    };
+    reset<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    clearErrors<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    resetAndClearErrors<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    setError: {
+        <K extends FormDataKeys<TForm>>(field: K, value: ErrorValue): void;
+        (errors: FormDataErrors<TForm>): void;
+    };
+    withPrecognition(...args: UseFormWithPrecognitionArguments): PrecognitiveFormState<TForm>;
+}
+interface FormValidationState<TForm extends object> {
+    validating: Signal<boolean>;
+    invalid<K extends FormDataKeys<TForm>>(field: K): boolean;
+    setValidationTimeout(duration: number): this;
+    touch<K extends FormDataKeys<TForm>>(field: K | NamedInputEvent | Array<K>, ...fields: K[]): this;
+    touched<K extends FormDataKeys<TForm>>(field?: K): boolean;
+    valid<K extends FormDataKeys<TForm>>(field: K): boolean;
+    validate<K extends FormDataKeys<TForm>>(field?: K | NamedInputEvent | PrecognitionValidationConfig<K>, validationConfig?: PrecognitionValidationConfig<K>): this;
+    validateFiles(): this;
+    validator(): Validator;
+    withAllErrors(): this;
+    withoutFileValidation(): this;
+    setErrors(errors: FormDataErrors<TForm>): this;
+    forgetError<K extends FormDataKeys<TForm> | NamedInputEvent>(field: K): this;
+}
+type PrecognitiveFormState<TForm extends object> = FormState<TForm> & FormValidationState<TForm>;
+
+interface InertiaFormProps$1<TForm extends object> extends FormState<TForm> {
+    submit(...args: UseFormSubmitArguments): void;
+    get(url: string, options?: UseFormSubmitOptions): void;
+    post(url: string, options?: UseFormSubmitOptions): void;
+    put(url: string, options?: UseFormSubmitOptions): void;
+    patch(url: string, options?: UseFormSubmitOptions): void;
+    delete(url: string, options?: UseFormSubmitOptions): void;
+    cancel(): void;
+    dontRemember<K extends FormDataKeys<TForm>>(...fields: K[]): this;
+    optimistic<TProps>(callback: OptimisticCallback<TProps>): this;
+    withPrecognition(...args: UseFormWithPrecognitionArguments): InertiaPrecognitiveFormProps<TForm>;
+}
+type InertiaPrecognitiveFormProps<TForm extends object> = InertiaFormProps$1<TForm> & FormValidationState<TForm>;
+type InertiaForm$1<TForm extends object> = InertiaFormProps$1<TForm>;
+type InertiaPrecognitiveForm$1<TForm extends object> = InertiaPrecognitiveFormProps<TForm>;
+declare function useForm<TForm extends FormDataType<TForm>>(method: Method | (() => Method), url: string | (() => string), data: TForm | (() => TForm)): InertiaPrecognitiveFormProps<TForm>;
+declare function useForm<TForm extends FormDataType<TForm>>(urlMethodPair: UrlMethodPair | (() => UrlMethodPair), data: TForm | (() => TForm)): InertiaPrecognitiveFormProps<TForm>;
+declare function useForm<TForm extends FormDataType<TForm>>(rememberKey: string, data: TForm | (() => TForm)): InertiaFormProps$1<TForm>;
+declare function useForm<TForm extends FormDataType<TForm>>(data: TForm | (() => TForm)): InertiaFormProps$1<TForm>;
+declare function useForm<TForm extends FormDataType<TForm>>(): InertiaFormProps$1<TForm>;
+
+interface UseHttpProps<TForm extends object, TResponse = unknown> extends FormState<TForm> {
+    response: Signal<TResponse | null>;
+    submit(...args: UseHttpSubmitArguments<TResponse, TForm>): Promise<TResponse>;
+    get(url: string, options?: UseHttpSubmitOptions<TResponse, TForm>): Promise<TResponse>;
+    post(url: string, options?: UseHttpSubmitOptions<TResponse, TForm>): Promise<TResponse>;
+    put(url: string, options?: UseHttpSubmitOptions<TResponse, TForm>): Promise<TResponse>;
+    patch(url: string, options?: UseHttpSubmitOptions<TResponse, TForm>): Promise<TResponse>;
+    delete(url: string, options?: UseHttpSubmitOptions<TResponse, TForm>): Promise<TResponse>;
+    cancel(): void;
+    dontRemember<K extends FormDataKeys<TForm>>(...fields: K[]): this;
+    optimistic(callback: (currentData: TForm) => Partial<TForm>): this;
+    withAllErrors(): this;
+    withPrecognition(...args: UseFormWithPrecognitionArguments): UseHttpPrecognitiveProps<TForm, TResponse>;
+}
+type UseHttpValidationProps<TForm extends object> = FormValidationState<TForm>;
+type UseHttp<TForm extends object, TResponse = unknown> = UseHttpProps<TForm, TResponse>;
+type UseHttpPrecognitiveProps<TForm extends object, TResponse = unknown> = UseHttpProps<TForm, TResponse> & UseHttpValidationProps<TForm>;
+declare function useHttp<TForm extends FormDataType<TForm>, TResponse = unknown>(method: Method | (() => Method), url: string | (() => string), data: TForm | (() => TForm)): UseHttpPrecognitiveProps<TForm, TResponse>;
+declare function useHttp<TForm extends FormDataType<TForm>, TResponse = unknown>(urlMethodPair: UrlMethodPair | (() => UrlMethodPair), data: TForm | (() => TForm)): UseHttpPrecognitiveProps<TForm, TResponse>;
+declare function useHttp<TForm extends FormDataType<TForm>, TResponse = unknown>(rememberKey: string, data: TForm | (() => TForm)): UseHttpProps<TForm, TResponse>;
+declare function useHttp<TForm extends FormDataType<TForm>, TResponse = unknown>(data: TForm | (() => TForm)): UseHttpProps<TForm, TResponse>;
+declare function useHttp<TForm extends FormDataType<TForm>, TResponse = unknown>(): UseHttpProps<TForm, TResponse>;
+
+type FormType<TForm extends object> = {
+    readonly __inertiaFormType?: TForm;
+};
+declare function createForm<TForm extends object>(): FormType<TForm>;
+interface InertiaForm<TForm extends object = Record<string, FormDataConvertible>> {
+    errors: Signal<FormDataErrors<TForm>>;
+    hasErrors: Signal<boolean>;
+    processing: Signal<boolean>;
+    progress: Signal<HttpProgressEvent | null>;
+    wasSuccessful: Signal<boolean>;
+    recentlySuccessful: Signal<boolean>;
+    isDirty: Signal<boolean>;
+    validating: Signal<boolean>;
+    clearErrors<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    resetAndClearErrors<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    setError: {
+        <K extends FormDataKeys<TForm>>(field: K, value: ErrorValue): void;
+        (errors: FormDataErrors<TForm>): void;
+    };
+    reset<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    submit(submitter?: HTMLElement | null): void;
+    cancel(): void;
+    defaults(): void;
+    getData(submitter?: HTMLElement | null): TForm;
+    getFormData(submitter?: HTMLElement | null): FormData;
+    valid<K extends FormDataKeys<TForm>>(field: K): boolean;
+    invalid<K extends FormDataKeys<TForm>>(field: K): boolean;
+    validate<K extends FormDataKeys<TForm>>(field?: K | NamedInputEvent | ValidationConfig, validationConfig?: ValidationConfig): void;
+    touch<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    touched<K extends FormDataKeys<TForm>>(field?: K): boolean;
+    validator(): Validator;
+}
+declare function useFormContext<TForm extends object = Record<string, FormDataConvertible>>(): InertiaForm<TForm> | null;
+declare class Form<TForm extends object = Record<string, FormDataConvertible>> implements AfterViewInit, InertiaForm<TForm> {
+    #private;
+    readonly formType: _angular_core.InputSignal<FormType<TForm> | null>;
+    readonly action: _angular_core.InputSignal<string | UrlMethodPair>;
+    readonly method: _angular_core.InputSignal<Method | "GET" | "POST" | "PUT" | "PATCH" | "DELETE">;
+    readonly headers: _angular_core.InputSignal<Record<string, string>>;
+    readonly queryStringArrayFormat: _angular_core.InputSignal<"indices" | "brackets">;
+    readonly errorBag: _angular_core.InputSignal<string | null>;
+    readonly showProgress: _angular_core.InputSignal<boolean>;
+    readonly transform: _angular_core.InputSignal<(data: TForm) => Record<string, FormDataConvertible>>;
+    readonly options: _angular_core.InputSignal<FormComponentOptions>;
+    readonly resetOnError: _angular_core.InputSignal<boolean | FormDataKeys<TForm>[]>;
+    readonly resetOnSuccess: _angular_core.InputSignal<boolean | FormDataKeys<TForm>[]>;
+    readonly setDefaultsOnSuccess: _angular_core.InputSignal<boolean>;
+    readonly disableWhileProcessing: _angular_core.InputSignal<boolean>;
+    readonly cancelOnUnmount: _angular_core.InputSignal<boolean>;
+    readonly invalidateCacheTags: _angular_core.InputSignal<string | string[]>;
+    readonly validateFiles: _angular_core.InputSignal<boolean>;
+    readonly validationTimeout: _angular_core.InputSignal<number>;
+    readonly optimistic: _angular_core.InputSignal<FormComponentOptimisticCallback<_inertiajs_core.PageProps & {
+        errors: _inertiajs_core.Errors & _inertiajs_core.ErrorBag;
+        deferred?: Record<string, VisitOptions["only"]>;
+    }, TForm> | null>;
+    readonly withAllErrors: _angular_core.InputSignal<boolean | null>;
+    readonly component: _angular_core.InputSignal<string | null>;
+    readonly instant: _angular_core.InputSignal<boolean>;
+    readonly onCancelToken: _angular_core.InputSignal<_inertiajs_core.CancelTokenCallback | null>;
+    readonly onBefore: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"before", _inertiajs_core.RequestPayload> | null>;
+    readonly onStart: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"start", _inertiajs_core.RequestPayload> | null>;
+    readonly onProgress: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"progress", _inertiajs_core.RequestPayload> | null>;
+    readonly onFinish: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"finish", _inertiajs_core.RequestPayload> | null>;
+    readonly onCancel: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"cancel", _inertiajs_core.RequestPayload> | null>;
+    readonly onSuccess: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"success", _inertiajs_core.RequestPayload> | null>;
+    readonly onError: _angular_core.InputSignal<_inertiajs_core.GlobalEventCallback<"error", _inertiajs_core.RequestPayload> | null>;
+    readonly onSubmitComplete: _angular_core.InputSignal<((props: FormComponentOnSubmitCompleteArguments<TForm>) => void) | null | undefined>;
+    readonly cancelToken: _angular_core.OutputEmitterRef<CancelToken>;
+    readonly before: _angular_core.OutputEmitterRef<PendingVisit>;
+    readonly start: _angular_core.OutputEmitterRef<PendingVisit>;
+    readonly progressEvent: _angular_core.OutputEmitterRef<HttpProgressEvent | undefined>;
+    readonly finish: _angular_core.OutputEmitterRef<ActiveVisit>;
+    readonly cancelEvent: _angular_core.OutputEmitterRef<void>;
+    readonly success: _angular_core.OutputEmitterRef<Page<_inertiajs_core.PageProps>>;
+    readonly error: _angular_core.OutputEmitterRef<FormDataErrors<TForm>>;
+    readonly submitComplete: _angular_core.OutputEmitterRef<FormComponentOnSubmitCompleteArguments<TForm>>;
+    readonly isDirty: Signal<boolean>;
+    readonly errors: Signal<FormDataErrors<TForm>>;
+    readonly hasErrors: Signal<boolean>;
+    readonly processing: Signal<boolean>;
+    readonly progress: Signal<HttpProgressEvent | null>;
+    readonly wasSuccessful: Signal<boolean>;
+    readonly recentlySuccessful: Signal<boolean>;
+    readonly validating: Signal<boolean>;
+    readonly resolvedMethod: Signal<Method>;
+    readonly resolvedAction: Signal<string>;
+    constructor();
+    ngAfterViewInit(): void;
+    handleFormUpdate(event: Event): void;
+    handleSubmit(event: SubmitEvent): void;
+    getFormData(submitter?: HTMLElement | null): FormData;
+    getData(submitter?: HTMLElement | null): TForm;
+    submit(submitter?: HTMLElement | null): void;
+    clearErrors<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    cancel(): void;
+    reset<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    resetAndClearErrors<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    readonly setError: InertiaForm<TForm>["setError"];
+    defaults(): void;
+    valid<K extends FormDataKeys<TForm>>(field: K): boolean;
+    invalid<K extends FormDataKeys<TForm>>(field: K): boolean;
+    validate<K extends FormDataKeys<TForm>>(field?: K | NamedInputEvent | ValidationConfig, validationConfig?: ValidationConfig): void;
+    touch<K extends FormDataKeys<TForm>>(...fields: K[]): void;
+    touched<K extends FormDataKeys<TForm>>(field?: K): boolean;
+    validator(): Validator;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Form<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Form<any>, "form[inertiaForm]", ["inertiaForm"], { "formType": { "alias": "formType"; "required": false; "isSignal": true; }; "action": { "alias": "action"; "required": false; "isSignal": true; }; "method": { "alias": "method"; "required": false; "isSignal": true; }; "headers": { "alias": "headers"; "required": false; "isSignal": true; }; "queryStringArrayFormat": { "alias": "queryStringArrayFormat"; "required": false; "isSignal": true; }; "errorBag": { "alias": "errorBag"; "required": false; "isSignal": true; }; "showProgress": { "alias": "showProgress"; "required": false; "isSignal": true; }; "transform": { "alias": "transform"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "resetOnError": { "alias": "resetOnError"; "required": false; "isSignal": true; }; "resetOnSuccess": { "alias": "resetOnSuccess"; "required": false; "isSignal": true; }; "setDefaultsOnSuccess": { "alias": "setDefaultsOnSuccess"; "required": false; "isSignal": true; }; "disableWhileProcessing": { "alias": "disableWhileProcessing"; "required": false; "isSignal": true; }; "cancelOnUnmount": { "alias": "cancelOnUnmount"; "required": false; "isSignal": true; }; "invalidateCacheTags": { "alias": "invalidateCacheTags"; "required": false; "isSignal": true; }; "validateFiles": { "alias": "validateFiles"; "required": false; "isSignal": true; }; "validationTimeout": { "alias": "validationTimeout"; "required": false; "isSignal": true; }; "optimistic": { "alias": "optimistic"; "required": false; "isSignal": true; }; "withAllErrors": { "alias": "withAllErrors"; "required": false; "isSignal": true; }; "component": { "alias": "component"; "required": false; "isSignal": true; }; "instant": { "alias": "instant"; "required": false; "isSignal": true; }; "onCancelToken": { "alias": "onCancelToken"; "required": false; "isSignal": true; }; "onBefore": { "alias": "onBefore"; "required": false; "isSignal": true; }; "onStart": { "alias": "onStart"; "required": false; "isSignal": true; }; "onProgress": { "alias": "onProgress"; "required": false; "isSignal": true; }; "onFinish": { "alias": "onFinish"; "required": false; "isSignal": true; }; "onCancel": { "alias": "onCancel"; "required": false; "isSignal": true; }; "onSuccess": { "alias": "onSuccess"; "required": false; "isSignal": true; }; "onError": { "alias": "onError"; "required": false; "isSignal": true; }; "onSubmitComplete": { "alias": "onSubmitComplete"; "required": false; "isSignal": true; }; }, { "cancelToken": "cancelToken"; "before": "before"; "start": "start"; "progressEvent": "progress"; "finish": "finish"; "cancelEvent": "cancel"; "success": "success"; "error": "error"; "submitComplete": "submitComplete"; }, never, never, true, never>;
+}
+type InertiaFormProps<TForm extends object = Record<string, FormDataConvertible>> = FormComponentProps<TForm>;
+type InertiaPrecognitiveForm<TForm extends object = Record<string, FormDataConvertible>> = InertiaForm<TForm>;
+
+declare class Head implements AfterViewInit {
+    #private;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    constructor();
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Head, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Head, "ng-template[inertiaHead]", ["inertiaHead"], { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DeferredTemplateContext {
+    reloading: boolean;
+}
+declare class DeferredContent {
+    readonly template: TemplateRef<DeferredTemplateContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeferredContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DeferredContent, "ng-template[inertiaDeferredContent]", never, {}, {}, never, never, true, never>;
+}
+declare class DeferredFallback {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeferredFallback, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DeferredFallback, "ng-template[inertiaDeferredFallback]", never, {}, {}, never, never, true, never>;
+}
+declare class DeferredRescue {
+    readonly template: TemplateRef<DeferredTemplateContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeferredRescue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DeferredRescue, "ng-template[inertiaDeferredRescue]", never, {}, {}, never, never, true, never>;
+}
+declare class Deferred {
+    #private;
+    readonly data: _angular_core.InputSignal<string | string[]>;
+    readonly content: _angular_core.Signal<DeferredContent | undefined>;
+    readonly fallback: _angular_core.Signal<DeferredFallback | undefined>;
+    readonly rescue: _angular_core.Signal<DeferredRescue | undefined>;
+    readonly ready: _angular_core.Signal<boolean>;
+    readonly rescued: _angular_core.Signal<boolean>;
+    readonly context: _angular_core.Signal<{
+        reloading: boolean;
+    }>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Deferred, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Deferred, "inertia-deferred", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, ["content", "fallback", "rescue"], never, true, never>;
+}
+
+interface WhenVisibleTemplateContext {
+    fetching: boolean;
+}
+declare class WhenVisibleContent {
+    readonly template: TemplateRef<WhenVisibleTemplateContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WhenVisibleContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WhenVisibleContent, "ng-template[inertiaWhenVisibleContent]", never, {}, {}, never, never, true, never>;
+}
+declare class WhenVisibleFallback {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WhenVisibleFallback, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WhenVisibleFallback, "ng-template[inertiaWhenVisibleFallback]", never, {}, {}, never, never, true, never>;
+}
+declare class WhenVisible {
+    #private;
+    private readonly sentinel;
+    readonly data: _angular_core.InputSignal<string | string[] | undefined>;
+    readonly params: _angular_core.InputSignal<ReloadOptions>;
+    readonly buffer: _angular_core.InputSignal<number>;
+    readonly always: _angular_core.InputSignal<boolean>;
+    readonly content: _angular_core.Signal<WhenVisibleContent | undefined>;
+    readonly fallback: _angular_core.Signal<WhenVisibleFallback | undefined>;
+    readonly loaded: _angular_core.Signal<boolean>;
+    readonly context: _angular_core.Signal<{
+        fetching: boolean;
+    }>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WhenVisible, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WhenVisible, "inertia-when-visible", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "buffer": { "alias": "buffer"; "required": false; "isSignal": true; }; "always": { "alias": "always"; "required": false; "isSignal": true; }; }, {}, ["content", "fallback"], never, true, never>;
+}
+
+type ElementTarget = HTMLElement | string | null;
+declare class InfiniteScroll implements InfiniteScrollRef {
+    #private;
+    readonly data: _angular_core.InputSignal<string>;
+    readonly buffer: _angular_core.InputSignal<number>;
+    readonly manual: _angular_core.InputSignal<boolean>;
+    readonly manualAfter: _angular_core.InputSignal<number>;
+    readonly preserveUrl: _angular_core.InputSignal<boolean>;
+    readonly reverse: _angular_core.InputSignal<boolean>;
+    readonly autoScroll: _angular_core.InputSignal<boolean | undefined>;
+    readonly onlyNext: _angular_core.InputSignal<boolean>;
+    readonly onlyPrevious: _angular_core.InputSignal<boolean>;
+    readonly params: _angular_core.InputSignal<ReloadOptions>;
+    readonly startElement: _angular_core.InputSignal<ElementTarget>;
+    readonly endElement: _angular_core.InputSignal<ElementTarget>;
+    readonly itemsElement: _angular_core.InputSignal<ElementTarget>;
+    readonly loadingPrevious: Signal<boolean>;
+    readonly loadingNext: Signal<boolean>;
+    readonly loading: Signal<boolean>;
+    readonly manualMode: Signal<boolean>;
+    readonly hasPreviousPage: Signal<boolean>;
+    readonly hasNextPage: Signal<boolean>;
+    readonly slot: Signal<InfiniteScrollSlotProps>;
+    readonly previous: Signal<InfiniteScrollActionSlotProps>;
+    readonly next: Signal<InfiniteScrollActionSlotProps>;
+    constructor();
+    fetchNext(options?: ReloadOptions): void;
+    fetchPrevious(options?: ReloadOptions): void;
+    hasPrevious(): boolean;
+    hasNext(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfiniteScroll, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InfiniteScroll, "[inertiaInfiniteScroll]", ["inertiaInfiniteScroll"], { "data": { "alias": "inertiaInfiniteScroll"; "required": true; "isSignal": true; }; "buffer": { "alias": "buffer"; "required": false; "isSignal": true; }; "manual": { "alias": "manual"; "required": false; "isSignal": true; }; "manualAfter": { "alias": "manualAfter"; "required": false; "isSignal": true; }; "preserveUrl": { "alias": "preserveUrl"; "required": false; "isSignal": true; }; "reverse": { "alias": "reverse"; "required": false; "isSignal": true; }; "autoScroll": { "alias": "autoScroll"; "required": false; "isSignal": true; }; "onlyNext": { "alias": "onlyNext"; "required": false; "isSignal": true; }; "onlyPrevious": { "alias": "onlyPrevious"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "startElement": { "alias": "startElement"; "required": false; "isSignal": true; }; "endElement": { "alias": "endElement"; "required": false; "isSignal": true; }; "itemsElement": { "alias": "itemsElement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare function provideInertiaApp(props: InertiaAppProps, additionalProviders?: Array<Provider | EnvironmentProviders>): EnvironmentProviders;
+
+export { App, Deferred, DeferredContent, DeferredFallback, DeferredRescue, Form, Head, InertiaRenderer, InertiaRuntime, InfiniteScroll, LayoutOutlet, Link, WhenVisible, WhenVisibleContent, WhenVisibleFallback, config, createForm, createInertiaApp, h, provideInertiaApp, useForm, useFormContext, useHttp, useLayoutProps, usePage, usePoll, usePrefetch, useRemember };
+export type { AngularCreateInertiaAppOptions, AngularInertiaAppConfig, AngularLayout, AngularRenderFunction, AngularRenderNode, AngularWithApp, ComponentResolver, DeferredTemplateContext, FormType, InertiaAppProps, InertiaForm$1 as InertiaForm, InertiaForm as InertiaFormComponent, InertiaFormProps as InertiaFormComponentProps, InertiaFormProps$1 as InertiaFormProps, InertiaLinkProps, InertiaPrecognitiveForm$1 as InertiaPrecognitiveForm, InertiaPrecognitiveForm as InertiaPrecognitiveFormComponent, InertiaPrecognitiveFormProps, LayoutCallback, ResolvedComponent, SetDataAction, SetDataByKeyValuePair, SetDataByMethod, SetDataByObject, SetupOptions, UseHttp, UseHttpPrecognitiveProps, UseHttpProps, UseHttpValidationProps, WhenVisibleTemplateContext };