@hybridly/vue 0.10.0-beta.3 → 0.10.0-beta.30

package/dist/index.d.mts

@@ -1,120 +1,326 @@
-import * as vue0 from "vue";
-import { App, ComputedRef, DeepReadonly, DefineComponent, MaybeRefOrGetter, Plugin, Ref, h } from "vue";
-import { GlobalHybridlyProperties, HybridRequestOptions, Method, Plugin as Plugin$1, Progress, RouteName, RouteParameters, RouterContext, RouterContextOptions, UrlResolvable, can, registerHook as registerHook$1, route, router } from "@hybridly/core";
-import { FormDataConvertible, RequestData } from "@hybridly/utils";
-import { Path, PathValue, SearchableObject } from "@clickbar/dot-diver";
+import { FormDataConvertible, Path, PathValue, RequestData, SearchableObject } from "@hybridly/utils";
+import * as vue from "vue";
+import { App, Component, ComputedRef, DeepReadonly, DefineComponent, MaybeRefOrGetter, Plugin, PropType, Ref, SlotsType, h } from "vue";
+import * as _hybridly_core0 from "@hybridly/core";
+import { Errors, GlobalHybridlyProperties, HttpClient, HybridRequestOptions, Method, NavigationResponse, Plugin as Plugin$1, Progress, RequestMode, RouteName, RouteParameters, RouterContext, RouterContextOptions, UrlResolvable, Validation, registerHook as registerHook$1, route, router } from "@hybridly/core";
+import { Path as Path$1, SearchableObject as SearchableObject$1 } from "@clickbar/dot-diver";
 
-//#region ../hybridly/src/index.d.ts
-
-import * as import__hybridly_core from "@hybridly/core";
-//#endregion
-//#region src/plugins/progress.d.ts
-interface ProgressOptions {
-  /**
-   * The delay after which the progress bar will
-   * appear during navigation, in milliseconds.
-   *
-   * @default 250
-   */
-  delay: number;
-  /**
-   * The color of the progress bar.
-   *
-   * Defaults to #29d.
-   */
-  color: string;
-  /**
-   * Whether to include the default NProgress styles.
-   *
-   * Defaults to true.
-   */
-  includeCSS: boolean;
-  /**
-   * Whether the NProgress spinner will be shown.
-   *
-   * Defaults to false.
-   */
-  spinner: boolean;
+//#region src/components/load-state.d.ts
+interface LoadStateSlotProps {
+  reloading: boolean;
+  loading: boolean;
+  loaded: boolean;
 }
 //#endregion
-//#region src/composables/property.d.ts
-type Property$1 = string | number | boolean | Property$1[] | {
-  [name: string]: Property$1;
-};
-type InternalProperties = GlobalHybridlyProperties & {
-  [key: string]: Property$1;
-};
-/** Accesses all current properties. */
-declare function useProperties<T extends object, Global extends InternalProperties = InternalProperties>(): vue0.DeepReadonly<vue0.UnwrapNestedRefs<T & Global>>;
-/** Accesses a property with a dot notation. */
-declare function useProperty<Override = never, T extends SearchableObject = GlobalHybridlyProperties, P extends Path<T> & string = Path<T> & string, ReturnType = ([Override] extends [never] ? PathValue<T, P> : Override)>(path: [Override] extends [never] ? P : string): ComputedRef<ReturnType>;
-/**
- * Sets the property at the given path to the given value.
- * Note: this helper is experimental and may change in the future.
- */
-declare function setProperty<Override = never, T extends SearchableObject = GlobalHybridlyProperties, P extends Path<T> & string = Path<T> & string, ValueType = ([Override] extends [never] ? PathValue<T, P> : Override)>(path: [Override] extends [never] ? P : string, value: ValueType): void;
+//#region src/components/deferred.d.ts
+declare const Deferred: vue.DefineComponent<vue.ExtractPropTypes<{
+  data: {
+    type: PropType<string | string[]>;
+    required: true;
+  };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+  [key: string]: any;
+}>[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+  data: {
+    type: PropType<string | string[]>;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, SlotsType<{
+  default: LoadStateSlotProps;
+  fallback: LoadStateSlotProps;
+}>, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 //#endregion
 //#region src/composables/form.d.ts
-type Errors<T extends SearchableObject> = { [K in keyof T]?: T[K] extends Record<string, any> ? Errors<T[K]> : string };
-type DefaultFormOptions = Pick<FormOptions<object>, 'timeout' | 'reset' | 'updateInitials' | 'progress' | 'preserveScroll' | 'preserveState' | 'preserveUrl' | 'headers' | 'errorBag' | 'spoof' | 'transformUrl' | 'updateHistoryState' | 'useFormData'>;
-interface FormOptions<T extends SearchableObject> extends Omit<HybridRequestOptions, 'data' | 'url'> {
-  fields: T;
+type Errors$1<T extends SearchableObject$1> = { [K in keyof T]?: T[K] extends Record<string, any> ? Errors$1<T[K]> : string };
+type FormFieldBehavior$1 = boolean | string[];
+type DefaultFormOptions = Pick<FormOptions<object>, 'timeout' | 'resetOnSuccess' | 'resetOnError' | 'setDefaultOnSuccess' | 'progress' | 'preserveScroll' | 'preserveState' | 'preserveUrl' | 'headers' | 'errorBag' | 'spoof' | 'transformUrl' | 'updateHistoryState' | 'useFormData'>;
+type FormSubmitOptions$1<T extends SearchableObject$1> = Omit<HybridRequestOptions, 'data' | 'url' | 'reset'> & {
   url?: UrlResolvable | (() => UrlResolvable);
-  key?: string | false;
   /**
    * Defines the delay after which the `recentlySuccessful` and `recentlyFailed` variables are reset to `false`.
    */
   timeout?: number;
   /**
-   * Resets the fields of the form to their initial value after a successful submission.
+   * Resets the fields of the form to their default value after a successful submission.
    * @default true
    */
-  reset?: boolean;
+  resetOnSuccess?: FormFieldBehavior$1;
   /**
-   * Updates the initial values from the form after a successful submission.
+   * Resets the fields of the form to their default value after a failed submission.
    * @default false
    */
-  updateInitials?: boolean;
+  resetOnError?: FormFieldBehavior$1;
+  /**
+   * Updates the default values from the form after a successful submission.
+   * @default false
+   */
+  setDefaultOnSuccess?: FormFieldBehavior$1;
   /**
    * Callback executed before the form submission for transforming the fields.
    */
   transform?: (fields: T) => any;
+};
+type FormAutomaticallySubmitOptions<T extends SearchableObject$1> = true | (FormSubmitOptions$1<T> & {
+  /**
+   * Debounce delay in milliseconds before submitting automatically.
+   * @default 100
+   */
+  debounce?: number;
+  /**
+   * Whether to immediately submit the form on any change. If `false`, submits after the `debounce` delay.
+   * @default true
+   */
+  immediate?: boolean;
+});
+interface FormOptions<T extends SearchableObject$1> extends FormSubmitOptions$1<T> {
+  fields: T;
+  key?: string | false;
+  /**
+   * Automatically submits the form when fields change.
+   * Pass `true` to use defaults or an object to customize submit overrides and debounce delay.
+   */
+  automaticallySubmit?: FormAutomaticallySubmitOptions<T>;
 }
-interface FormReturn<T extends SearchableObject, P extends Path<T> & string = Path<T> & string> {
+interface FormReturn<T extends SearchableObject$1, P extends Path$1<T> & string = Path$1<T> & string> {
   resetFields: (...keys: P[]) => void;
   reset: () => void;
   resetSubmissionState: () => void;
   clear: (...keys: P[]) => void;
   fields: T;
   abort: () => void;
-  setErrors: (incoming: Errors<T>) => void;
+  setErrors: (incoming: Errors$1<T>) => void;
   clearErrors: (...keys: P[]) => void;
   clearError: (key: P) => void;
-  setInitial: (newInitial: Partial<T>) => void;
+  setDefault: (newDefault: Partial<T>) => void;
   hasDirty: (...keys: P[]) => boolean;
-  submitWith: (optionsOverrides?: Omit<FormOptions<T>, 'fields' | 'key'>) => Promise<any>;
-  submitWithOptions: (optionsOverrides?: Omit<FormOptions<T>, 'fields' | 'key'>) => Promise<any>;
-  submit: () => Promise<any>;
+  submit: (optionsOverrides?: FormSubmitOptions$1<T>) => Promise<any>;
   hasErrors: boolean;
-  initial: DeepReadonly<T>;
+  defaults: DeepReadonly<T>;
   loaded: DeepReadonly<T>;
   progress: Progress | undefined;
   isDirty: boolean;
-  errors: Errors<T>;
+  errors: Errors$1<T>;
   processing: boolean;
   successful: boolean;
   failed: boolean;
   recentlySuccessful: boolean;
   recentlyFailed: boolean;
 }
-declare function useForm<T extends SearchableObject, P extends Path<T> & string = Path<T> & string>(options: FormOptions<T>): FormReturn<T, P>;
+declare function useForm<T extends SearchableObject$1, P extends Path$1<T> & string = Path$1<T> & string>(options: FormOptions<T>): FormReturn<T, P>;
 //#endregion
-//#region src/composables/history.d.ts
-/**
- * Returns a ref with a value saved in the history state through Hybridly.
- * The state is linked to a specific browser history entry.
- */
-declare function useHistoryState<T = any>(key: string, initial: T): Ref<T>;
+//#region src/components/form.d.ts
+type DefaultFormFields = Record<string, any>;
+type FormInternalSubmitOptions<T extends SearchableObject$1 = DefaultFormFields> = NonNullable<Parameters<FormReturn<T>['submit']>[0]>;
+type FormFieldBehavior = boolean | string[];
+type FormRequestOptions = Omit<HybridRequestOptions, 'url' | 'data' | 'method' | 'errorBag' | 'progress'>;
+type FormSubmitOptions<T extends SearchableObject$1 = DefaultFormFields> = FormInternalSubmitOptions<T>;
+type FormSlotProps<T extends SearchableObject$1 = DefaultFormFields> = Omit<FormReturn<T>, 'submit' | 'reset' | 'resetFields' | 'errors'> & {
+  errors: Record<string, any>;
+  getError: (key: string) => any;
+  submit: (optionsOverrides?: FormSubmitOptions<T>) => Promise<any>;
+  reset: () => void;
+  resetFields: (...keys: string[]) => void;
+};
+interface FormProps {
+  action?: string;
+  method?: Method | Lowercase<Method>;
+  options?: FormRequestOptions;
+  errorBag?: string;
+  showProgress?: boolean;
+  disableWhileProcessing?: boolean;
+  resetOnSuccess?: FormFieldBehavior;
+  resetOnError?: FormFieldBehavior;
+  setDefaultOnSuccess?: FormFieldBehavior;
+}
+declare const Form: vue.DefineComponent<vue.ExtractPropTypes<{
+  action: {
+    type: StringConstructor;
+    required: false;
+    default: undefined;
+  };
+  method: {
+    type: PropType<NonNullable<FormProps["method"]>>;
+    default: "POST";
+  };
+  options: {
+    type: PropType<FormRequestOptions>;
+    default: () => {};
+  };
+  errorBag: {
+    type: StringConstructor;
+    required: false;
+    default: undefined;
+  };
+  showProgress: {
+    type: BooleanConstructor;
+    required: false;
+    default: undefined;
+  };
+  disableWhileProcessing: {
+    type: BooleanConstructor;
+    default: false;
+  };
+  resetOnSuccess: {
+    type: PropType<FormFieldBehavior>;
+    default: true;
+  };
+  resetOnError: {
+    type: PropType<FormFieldBehavior>;
+    default: false;
+  };
+  setDefaultOnSuccess: {
+    type: PropType<FormFieldBehavior>;
+    default: false;
+  };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+  action: {
+    type: StringConstructor;
+    required: false;
+    default: undefined;
+  };
+  method: {
+    type: PropType<NonNullable<FormProps["method"]>>;
+    default: "POST";
+  };
+  options: {
+    type: PropType<FormRequestOptions>;
+    default: () => {};
+  };
+  errorBag: {
+    type: StringConstructor;
+    required: false;
+    default: undefined;
+  };
+  showProgress: {
+    type: BooleanConstructor;
+    required: false;
+    default: undefined;
+  };
+  disableWhileProcessing: {
+    type: BooleanConstructor;
+    default: false;
+  };
+  resetOnSuccess: {
+    type: PropType<FormFieldBehavior>;
+    default: true;
+  };
+  resetOnError: {
+    type: PropType<FormFieldBehavior>;
+    default: false;
+  };
+  setDefaultOnSuccess: {
+    type: PropType<FormFieldBehavior>;
+    default: false;
+  };
+}>> & Readonly<{}>, {
+  action: string;
+  method: NonNullable<Method | "get" | "post" | "put" | "patch" | "delete" | undefined>;
+  options: FormRequestOptions;
+  errorBag: string;
+  showProgress: boolean;
+  disableWhileProcessing: boolean;
+  resetOnSuccess: FormFieldBehavior;
+  resetOnError: FormFieldBehavior;
+  setDefaultOnSuccess: FormFieldBehavior;
+}, SlotsType<{
+  default: FormSlotProps;
+}>, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/link.d.ts
+interface RouterLinkProps {
+  href?: string;
+  as?: string | object;
+  method?: Method | Lowercase<Method>;
+  mode?: RequestMode;
+  data?: RequestData;
+  external?: boolean;
+  disabled?: boolean;
+  options?: Omit<HybridRequestOptions, 'url' | 'data' | 'method'>;
+  text?: string;
+  preload?: boolean | 'hover' | 'mount';
+  preserveScroll?: boolean;
+  preserveState?: boolean;
+}
+declare const RouterLink: DefineComponent<RouterLinkProps>;
+//#endregion
+//#region src/components/when-visible.d.ts
+declare const WhenVisible: vue.DefineComponent<vue.ExtractPropTypes<{
+  as: {
+    type: StringConstructor;
+    default: string;
+  };
+  data: {
+    type: PropType<string | string[]>;
+    required: true;
+  };
+  buffer: {
+    type: NumberConstructor;
+    default: number;
+  };
+  root: {
+    type: PropType<string | Element | null>;
+    default: null;
+  };
+  once: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  fallbackOnHidden: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  options: {
+    type: PropType<Omit<HybridRequestOptions, "url" | "data" | "method">>;
+    default: () => {};
+  };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+  loading: (_state: LoadStateSlotProps) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+  as: {
+    type: StringConstructor;
+    default: string;
+  };
+  data: {
+    type: PropType<string | string[]>;
+    required: true;
+  };
+  buffer: {
+    type: NumberConstructor;
+    default: number;
+  };
+  root: {
+    type: PropType<string | Element | null>;
+    default: null;
+  };
+  once: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  fallbackOnHidden: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  options: {
+    type: PropType<Omit<HybridRequestOptions, "url" | "data" | "method">>;
+    default: () => {};
+  };
+}>> & Readonly<{
+  onLoading?: ((_state: LoadStateSlotProps) => any) | undefined;
+}>, {
+  options: Omit<HybridRequestOptions<Record<string, any>>, "data" | "method" | "url">;
+  as: string;
+  buffer: number;
+  root: string | Element | null;
+  once: boolean;
+  fallbackOnHidden: boolean;
+}, SlotsType<{
+  default: LoadStateSlotProps;
+  fallback: LoadStateSlotProps;
+}>, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 //#endregion
 //#region src/composables/back-forward.d.ts
 type BackForwardCallback = (context: RouterContext) => void;
@@ -129,6 +335,74 @@ declare function useBackForward(options?: UseBackForwardOptions): {
   reloadOnBackForward: (options?: HybridRequestOptions) => void;
 };
 //#endregion
+//#region src/composables/bulk-select.d.ts
+interface BulkSelection<T = any> {
+  /** Whether all records are selected. */
+  all: boolean;
+  /** Included records. */
+  only: Set<T>;
+  /** Excluded records. */
+  except: Set<T>;
+}
+/**
+ * Returns the inclusive range between two records in the given order.
+ *
+ * This is useful for implementing shift-click bulk selection: keep track of the last selected anchor,
+ * then pass the currently visible record identifiers and the clicked target identifier to this helper.
+ * If the target is not in the list, an empty range is returned. If the anchor is missing, only the target is returned.
+ */
+declare function getBulkSelectionRange<T>(records: readonly T[], anchor: T | undefined, target: T): T[];
+declare function useBulkSelect<T = any>(): {
+  allSelected: vue.ComputedRef<boolean>;
+  anySelected: vue.ComputedRef<boolean>;
+  toggleAll: (force?: boolean) => void;
+  selectAll: () => void;
+  deselectAll: () => void;
+  select: (...records: T[]) => void;
+  deselect: (...records: T[]) => void;
+  toggle: (record: T, force?: boolean) => void;
+  selected: (record: T) => boolean;
+  selection: Ref<BulkSelection<T>, BulkSelection<T>>;
+  bindCheckbox: (key: T) => {
+    onChange: (event: Event) => void;
+    checked: boolean;
+    value: T;
+  };
+};
+//#endregion
+//#region src/composables/current-route.d.ts
+declare function useRoute(): {
+  isNavigating: Readonly<vue.Ref<boolean, boolean>>;
+  current: Readonly<vue.Ref<string | undefined, string | undefined>>;
+  matches: <T extends RouteName>(name: MaybeRefOrGetter<T>, parameters?: RouteParameters<T>) => boolean;
+};
+import * as import__hybridly_core from "@hybridly/core";
+//#endregion
+//#region ../core/src/router/types.d.ts
+type Property$1 = null | string | number | boolean | Property$1[] | {
+  [name: string]: Property$1;
+};
+type Properties = Record<string | number, Property$1>;
+//#endregion
+//#region src/composables/dialog.d.ts
+/**
+ * Exposes utilities related to the dialogs.
+ */
+declare function useDialog(): {
+  /** Closes the dialog. */close: () => Promise<void | index_d_exports.NavigationResponse>; /** Closes the dialog without a server round-trip. */
+  closeLocally: () => Promise<void | index_d_exports.NavigationResponse>; /** Unmounts the dialog. Should be called after its closing animations. */
+  unmount: () => void; /** Whether the dialog is shown. */
+  show: vue.WritableComputedRef<boolean | undefined, boolean | undefined>; /** Properties of the dialog. */
+  properties: vue.ComputedRef<Properties | undefined>;
+};
+//#endregion
+//#region src/composables/history.d.ts
+/**
+ * Returns a ref with a value saved in the history state through Hybridly.
+ * The state is linked to a specific browser history entry.
+ */
+declare function useHistoryState<T = any>(key: string, initial: T): Ref<T>;
+//#endregion
 //#region src/composables/paginator.d.ts
 declare global {
   /**
@@ -200,293 +474,576 @@ interface PaginatorMeta {
   prev_page_url?: string;
 }
 type MaybeWithData<T> = T | Omit<T, 'data'>;
-type PaginatorResult<T, P> = P extends MaybeWithData<Paginator<T>> ? P & {
-  to: (page: number) => Promise<index_d_exports.NavigationResponse> | undefined;
+type PaginatorResult<T, P = MaybeWithData<Paginator<T>>> = P extends MaybeWithData<Paginator<T>> ? P & {
+  to: (page: number, options?: Omit<index_d_exports.HybridRequestOptions, 'method' | 'url'>) => Promise<index_d_exports.NavigationResponse> | undefined;
 } : P;
-declare function createPaginator<T, P extends MaybeWithData<Paginator<T> | SimplePaginator<T> | CursorPaginator<T>>>(paginator: P, options?: Omit<index_d_exports.HybridRequestOptions, 'method' | 'url'>): PaginatorResult<T, P>;
+declare function createPaginator<T, P extends MaybeWithData<Paginator<T> | SimplePaginator<T> | CursorPaginator<T>>>(paginator: P, defaultOptions?: Omit<index_d_exports.HybridRequestOptions, 'method' | 'url'>): PaginatorResult<T, P>;
 //#endregion
-//#region src/composables/register-hook.d.ts
+//#region src/composables/property.d.ts
+type Property = string | number | boolean | Property[] | {
+  [name: string]: Property;
+};
+type InternalProperties = GlobalHybridlyProperties & {
+  [key: string]: Property;
+};
+/** Accesses all current properties. */
+declare function useProperties<T extends object, Global extends InternalProperties = InternalProperties>(): vue.DeepReadonly<vue.UnwrapNestedRefs<T & Global>>;
+/** Accesses a property with a dot notation. */
+declare function useProperty<Override = never, T extends SearchableObject = GlobalHybridlyProperties, P extends Path<T> & string = Path<T> & string, ReturnType = ([Override] extends [never] ? PathValue<T, P> : Override)>(path: [Override] extends [never] ? P : string): ComputedRef<ReturnType>;
 /**
- * Registers a global hook.
- * If called inside a component, unregisters after the component is unmounted.
+ * Sets the property at the given path to the given value.
+ * Note: this helper is experimental and may change in the future.
  */
-declare const registerHook: typeof registerHook$1;
+declare function setProperty<Override = never, T extends SearchableObject = GlobalHybridlyProperties, P extends Path<T> & string = Path<T> & string, ValueType = ([Override] extends [never] ? PathValue<T, P> : Override)>(path: [Override] extends [never] ? P : string, value: ValueType): void;
 //#endregion
-//#region ../core/src/router/types.d.ts
-type Property = null | string | number | boolean | Property[] | {
-  [name: string]: Property;
-};
-type Properties = Record<string | number, Property>;
+//#region src/composables/query-parameters.d.ts
+/**
+ * Access reactive query parameters.
+ *
+ * @see https://hybridly.dev/api/utils/use-query-parameters.html
+ */
+declare function useQueryParameters<T extends Record<string, any> = Record<string, any>>(): T;
+type RouteParameter = string | number | boolean | null | undefined;
+type TransformFunction<V extends RouteParameter, R> = (val: V) => R;
+type TransformType<T extends RouteParameter, O> = O extends {
+  transform: 'number';
+} ? number : O extends {
+  transform: 'bool';
+} ? boolean : O extends {
+  transform: 'string';
+} ? string : O extends {
+  transform: 'date';
+} ? Date : O extends {
+  transform: TransformFunction<T, infer R>;
+} ? R : T;
+interface UseQueryParameterOptions<V extends RouteParameter, R> {
+  /**
+   * Specifies a default value if the query parameter does not exist.
+   */
+  defaultValue?: MaybeRefOrGetter<R>;
+  /**
+   * Transforms the query parameter.
+   */
+  transform?: 'number' | 'bool' | 'string' | 'date' | TransformFunction<V, R>;
+}
+/**
+ * Makes the specified query parameter reactive.
+ *
+ * @see https://hybridly.dev/api/utils/use-query-parameter.html
+ */
+declare function useQueryParameter<ParameterType extends RouteParameter = RouteParameter, Options extends UseQueryParameterOptions<ParameterType, any> = UseQueryParameterOptions<ParameterType, ParameterType>>(name: string, options?: Options): Ref<TransformType<ParameterType, Options>>;
 //#endregion
-//#region src/composables/dialog.d.ts
+//#region src/composables/refinements.d.ts
+type SortDirection = 'asc' | 'desc';
+type AvailableHybridRequestOptions = Omit<HybridRequestOptions, 'url' | 'data'>;
+type AvailableHybridRequestOptionsForFilters = AvailableHybridRequestOptions & {
+  operator?: FilterOperator;
+  options?: {
+    /**
+     * Show empty relationships in relationship filters.
+     */
+    empty?: boolean;
+    [key: string]: any;
+  };
+};
+type FilterOperator = 'equals' | 'not_equals' | 'in' | 'not_in' | 'is_null' | 'is_not_null' | 'contains' | 'not_contains' | 'begins_with' | 'ends_with' | 'is_empty' | 'is_not_empty' | 'greater_than' | 'greater_than_or_equal' | 'less_than' | 'less_than_or_equal' | 'between' | 'not_between' | 'after' | 'before' | 'in_the_last' | 'not_in_the_last';
+interface ToggleSortOptions extends AvailableHybridRequestOptions {
+  direction?: SortDirection;
+  /** Additional sort data, only applied when sorting. */
+  sortData?: {
+    [key: string]: FormDataConvertible;
+  };
+}
+interface BindFilterOptions<T> extends AvailableHybridRequestOptions {
+  transformValue?: (value?: T) => any;
+  /** If specified, this callback will be responsible for watching the specified ref that contains the filter value.  */
+  watch?: (ref: Ref<T>, cb: any) => void;
+  /**
+   * The debounce time in milliseconds for applying this filter.
+   * @default 250ms
+   */
+  debounce?: number;
+  /**
+   * The debounce time in milliseconds for updating the ref.
+   * @default 250ms
+   */
+  syncDebounce?: number;
+}
+/**
+ * Base interface for all filter refinements.
+ */
+interface BaseFilterRefinement {
+  /**
+   * Whether this filter is currently active.
+   */
+  is_active: boolean;
+  /**
+   * A string-based icon identifier.
+   */
+  icon?: string;
+  /**
+   * The type of this filter.
+   */
+  type: string;
+  /**
+   * The label of the filter.
+   */
+  label: string;
+  /**
+   * The name of the filter.
+   */
+  name: string;
+  /**
+   * The current value of the filter.
+   */
+  value: any;
+  /**
+   * The current search query of the filter.
+   */
+  search_query?: string;
+  /**
+   * The current options of the filter.
+   */
+  options?: Record<string, any>;
+  /**
+   * Whether this filter is hidden.
+   */
+  hidden: boolean;
+  /**
+   * The default value of the filter.
+   */
+  default: any;
+  /**
+   * Whether this filter has an explicitly configured default value.
+   */
+  has_default: boolean;
+  /**
+   * The current operator of the filter.
+   */
+  operator?: FilterOperator;
+  /**
+   * The default operator of the filter.
+   */
+  default_operator?: FilterOperator;
+  /**
+   * The list of supported operators for this filter.
+   */
+  supported_operators?: FilterOperator[];
+  /**
+   * The metadata attributes of the filter.
+   */
+  metadata: {
+    /**
+     * A string-based icon identifier.
+     */
+    icon?: string;
+    /**
+     * The label of the filter, suitable for display purposes.
+     */
+    label?: string;
+    /**
+     * A label suitable for previewing this filter in a compact context, like a pill.
+     */
+    preview_label?: string;
+    /**
+     * A string-based identifier suitable for previewing this filter in a compact context, like a pill.
+     */
+    current_value_label?: string;
+    /**
+     * A string-based icon identifier suitable for displaying next to the current value of this filter in a compact context, like a pill.
+     */
+    current_value_icon?: string;
+    /**
+     * A custom property.
+     */
+    [key: string]: any;
+  };
+}
+/**
+ * Text filter refinement.
+ */
+interface TextFilterRefinement extends BaseFilterRefinement {
+  type: 'text';
+  operator?: FilterOperator;
+}
+/**
+ * Select filter refinement.
+ */
+interface SelectFilterRefinement extends BaseFilterRefinement {
+  type: 'select';
+  operator?: FilterOperator;
+  metadata: BaseFilterRefinement['metadata'] & {
+    /**
+     * Whether multiple options can be selected.
+     */
+    is_multiple?: boolean;
+    /**
+     * Whether the select filter is searchable.
+     */
+    is_searchable?: boolean;
+    /**
+     * Available options for the select filter.
+     */
+    options?: Record<string | number, string>;
+    /**
+     * Label for the selected options.
+     */
+    selected_options_label?: string;
+    /**
+     * Whether the filter allows an empty relationship option.
+     */
+    allows_empty_relationship_option?: boolean;
+    /**
+     * Label for the empty relationship option.
+     */
+    empty_relationship_option_label?: string;
+    /**
+     * Label for the empty search result.
+     */
+    empty_search_result_label?: string;
+  };
+}
+/**
+ * Ternary filter refinement.
+ */
+interface TernaryFilterRefinement extends BaseFilterRefinement {
+  type: 'ternary';
+  operator?: FilterOperator;
+  metadata: BaseFilterRefinement['metadata'] & {
+    /**
+     * Label for the true state.
+     */
+    true_label?: string;
+    /**
+     * Label for the false state.
+     */
+    false_label?: string;
+    /**
+     * Placeholder label.
+     */
+    placeholder?: string;
+  };
+  supported_operators?: never;
+}
+/**
+ * Boolean filter refinement.
+ */
+interface BooleanFilterRefinement extends BaseFilterRefinement {
+  type: 'boolean';
+  operator?: FilterOperator;
+  metadata: BaseFilterRefinement['metadata'] & {
+    /**
+     * Label for the true state.
+     */
+    true_label?: string;
+    /**
+     * Label for the false state.
+     */
+    false_label?: string;
+  };
+}
+/**
+ * Numeric filter refinement.
+ */
+interface NumericFilterRefinement extends BaseFilterRefinement {
+  type: 'numeric';
+  operator?: FilterOperator;
+}
+/**
+ * Time suggestion for single date filters.
+ */
+interface TimeSuggestion {
+  type: 'time';
+  label: string;
+  date: string;
+  is_current: boolean;
+}
+/**
+ * Timeframe suggestion for date range filters.
+ */
+interface TimeframeSuggestion {
+  type: 'timeframe';
+  label: string;
+  start: string;
+  end: string;
+  is_current: boolean;
+}
+/**
+ * Date filter refinement.
+ */
+interface DateFilterRefinement extends BaseFilterRefinement {
+  type: 'date';
+  operator?: FilterOperator;
+  metadata: BaseFilterRefinement['metadata'] & {
+    /**
+     * Whether this is a timeframe filter (with start and end columns).
+     */
+    is_timeframe?: boolean;
+    /**
+     * The start column for timeframe filters.
+     */
+    start_column?: string;
+    /**
+     * The end column for timeframe filters.
+     */
+    end_column?: string;
+    /**
+     * Suggested dates or timeframes for this filter.
+     */
+    suggestions?: Array<TimeSuggestion | TimeframeSuggestion>;
+    /**
+     * A description for this filter, suitable for display purposes.
+     */
+    description?: string;
+  };
+}
+/**
+ * Trashed filter refinement.
+ */
+interface TrashedFilterRefinement extends BaseFilterRefinement {
+  type: 'trashed';
+  supported_operators?: never;
+}
+/**
+ * Callback filter refinement.
+ */
+interface CallbackFilterRefinement extends BaseFilterRefinement {
+  type: 'callback' | (string & {});
+  supported_operators?: never;
+}
+/**
+ * Represents a filter.
+ */
+type FilterRefinement = TextFilterRefinement | SelectFilterRefinement | TernaryFilterRefinement | BooleanFilterRefinement | NumericFilterRefinement | DateFilterRefinement | TrashedFilterRefinement | CallbackFilterRefinement;
+interface SortRefinement {
+  /**
+   * Whether this sort is currently active.
+   */
+  is_active: boolean;
+  /**
+   * The current direction of the sort.
+   */
+  direction?: SortDirection;
+  /**
+   * The default direction of the sort.
+   */
+  default?: SortDirection;
+  /**
+   * Whether this sort has an explicitly configured default direction.
+   */
+  has_default: boolean;
+  /**
+   * The label of the sort.
+   */
+  label: string;
+  /**
+   * The metadata attributes of the sort.
+   */
+  metadata: Record<string, any>;
+  /**
+   * The name of the sort.
+   */
+  name: string;
+  /**
+   * The value corresponding to the descending sort.
+   */
+  desc: string;
+  /**
+   * The value corresponding to the ascending sort.
+   */
+  asc: string;
+  /**
+   * The value that will be applied on toggle.
+   */
+  next: string;
+  /**
+   * Whether this sort is hidden.
+   */
+  hidden: boolean;
+}
+interface Refinements {
+  /**
+   * The list of available filters.
+   */
+  filters: Array<FilterRefinement>;
+  /**
+   * The list of available sorts.
+   */
+  sorts: Array<SortRefinement>;
+  /**
+   * The URL scope for these refinements.
+   */
+  scope?: string;
+  /**
+   * The scope keys for these refinements.
+   */
+  keys: {
+    /**
+     * The scope key for sorting.
+     */
+    sorts: string;
+    /**
+     * The scope key for filtering.
+     */
+    filters: string;
+  };
+}
+/**
+ * Base bound filter refinement with common methods.
+ */
+interface BoundFilterRefinementMethods {
+  /**
+   * Applies this filter.
+   */
+  apply: (value: any, options?: AvailableHybridRequestOptionsForFilters) => Promise<NavigationResponse | undefined>;
+  /**
+   * Clears this filter.
+   */
+  clear: (options?: AvailableHybridRequestOptions) => Promise<NavigationResponse>;
+  /**
+   * Searches this filter.
+   */
+  search: (value?: string | number, options?: AvailableHybridRequestOptions) => Promise<NavigationResponse | undefined>;
+  /**
+   * Whether this filter is a date filter.
+   */
+  isDateFilter: () => boolean;
+  /**
+   * Whether this filter is a select filter.
+   */
+  isSelectFilter: () => boolean;
+  /**
+   * Whether this filter is a search filter.
+   */
+  isSearchFilter: () => boolean;
+  /**
+   * Whether this filter is a ternary filter.
+   */
+  isTernaryFilter: () => boolean;
+  /**
+   * Whether this filter is a boolean filter.
+   */
+  isBooleanFilter: () => boolean;
+  /**
+   * Whether this filter is a trashed filter.
+   */
+  isTrashedFilter: () => boolean;
+  /**
+   * Whether this filter is a callback filter.
+   */
+  isCallbackFilter: () => boolean;
+}
+/**
+ * Checks whether the given filter is a text filter, and narrows its type.
+ */
+declare function isTextFilter(filter: FilterRefinement | BoundFilterRefinement): filter is BoundTextFilterRefinement;
+/**
+ * Checks whether the given filter is a date filter, and narrows its type.
+ */
+declare function isDateFilter(filter: FilterRefinement | BoundFilterRefinement): filter is BoundDateFilterRefinement;
+/**
+ * Checks whether the given filter is a select filter, and narrows its type.
+ */
+declare function isSelectFilter(filter: FilterRefinement | BoundFilterRefinement): filter is BoundSelectFilterRefinement;
+/**
+ * Checks whether the given filter is a ternary filter, and narrows its type.
+ */
+declare function isTernaryFilter(filter: FilterRefinement | BoundFilterRefinement): filter is BoundTernaryFilterRefinement;
+/**
+ * Checks whether the given filter is a boolean filter, and narrows its type.
+ */
+declare function isBooleanFilter(filter: FilterRefinement | BoundFilterRefinement): filter is BoundBooleanFilterRefinement;
+/**
+ * Checks whether the given filter is a trashed filter, and narrows its type.
+ */
+declare function isTrashedFilter(filter: FilterRefinement | BoundFilterRefinement): filter is BoundTrashedFilterRefinement;
+/**
+ * Checks whether the given filter is a callback filter, and narrows its type.
+ */
+declare function isCallbackFilter(filter: FilterRefinement | BoundFilterRefinement): filter is BoundCallbackFilterRefinement;
+/**
+ * Bound text filter refinement with type-specific methods.
+ */
+interface BoundTextFilterRefinement extends TextFilterRefinement, BoundFilterRefinementMethods {}
+/**
+ * Bound date filter refinement with type-specific methods.
+ */
+interface BoundDateFilterRefinement extends DateFilterRefinement, BoundFilterRefinementMethods {}
+/**
+ * Bound select filter refinement with type-specific methods.
+ */
+interface BoundSelectFilterRefinement extends SelectFilterRefinement, BoundFilterRefinementMethods {}
+/**
+ * Bound ternary filter refinement with type-specific methods.
+ */
+interface BoundTernaryFilterRefinement extends TernaryFilterRefinement, BoundFilterRefinementMethods {}
+/**
+ * Bound boolean filter refinement with type-specific methods.
+ */
+interface BoundBooleanFilterRefinement extends BooleanFilterRefinement, BoundFilterRefinementMethods {}
+/**
+ * Bound trashed filter refinement with type-specific methods.
+ */
+interface BoundTrashedFilterRefinement extends TrashedFilterRefinement, BoundFilterRefinementMethods {}
 /**
- * Exposes utilities related to the dialogs.
+ * Bound callback filter refinement with type-specific methods.
  */
-declare function useDialog(): {
-  /** Closes the dialog. */close: () => void; /** Closes the dialog without a server round-trip. */
-  closeLocally: () => void; /** Unmounts the dialog. Should be called after its closing animations. */
-  unmount: () => void; /** Whether the dialog is shown. */
-  show: vue0.WritableComputedRef<boolean | undefined, boolean | undefined>; /** Properties of the dialog. */
-  properties: vue0.ComputedRef<Properties | undefined>;
-};
-//#endregion
-//#region src/composables/refinements.d.ts
-type SortDirection = 'asc' | 'desc';
-type AvailableHybridRequestOptions = Omit<HybridRequestOptions, 'url' | 'data'>;
-interface ToggleSortOptions extends AvailableHybridRequestOptions {
-  direction?: SortDirection;
-  /** Additional sort data, only applied when sorting. */
-  sortData?: {
-    [key: string]: FormDataConvertible;
-  };
-}
-interface BindFilterOptions<T> extends AvailableHybridRequestOptions {
-  transformValue?: (value?: T) => any;
-  /** If specified, this callback will be responsible for watching the specified ref that contains the filter value.  */
-  watch?: (ref: Ref<T>, cb: any) => void;
+interface BoundCallbackFilterRefinement extends CallbackFilterRefinement, BoundFilterRefinementMethods {}
+/**
+ * Union of all bound filter refinement types.
+ */
+type BoundFilterRefinement = BoundTextFilterRefinement | BoundSelectFilterRefinement | BoundTernaryFilterRefinement | BoundBooleanFilterRefinement | BoundTrashedFilterRefinement | BoundCallbackFilterRefinement;
+interface BoundSortRefinement extends SortRefinement {
   /**
-   * The debounce time in milliseconds for applying this filter.
-   * @default 250ms
+   * Toggles this sort.
    */
-  debounce?: number;
+  toggle: (options?: ToggleSortOptions) => Promise<NavigationResponse | undefined>;
   /**
-   * The debounce time in milliseconds for updating the ref.
-   * @default 250ms
+   * Checks if this sort is active.
    */
-  syncDebounce?: number;
-}
-declare global {
-  interface FilterRefinement {
-    /**
-     * Whether this filter is currently active.
-     */
-    is_active: boolean;
-    /**
-     * The type of this filter.
-     */
-    type: 'trashed' | 'callback' | 'exact' | 'similar:loose' | 'similar:begins_with_strict' | 'similar:ends_with_strict' | string;
-    /**
-     * The label of the filter.
-     */
-    label: string;
-    /**
-     * The metadata attributes of the filter.
-     */
-    metadata: Record<string, any>;
-    /**
-     * The name of the fitler.
-     */
-    name: string;
-    /**
-     * The current value of the filter.
-     */
-    value: any;
-    /**
-     * Whether this filter is hidden.
-     */
-    hidden: boolean;
-    /**
-     * The default value of the filter.
-     */
-    default: any;
-  }
-  interface SortRefinement {
-    /**
-     * Whether this sort is currently active.
-     */
-    is_active: boolean;
-    /**
-     * The current direction of the sort.
-     */
-    direction?: SortDirection;
-    /**
-     * The default direction of the sort.
-     */
-    default?: SortDirection;
-    /**
-     * The label of the sort.
-     */
-    label: string;
-    /**
-     * The metadata attributes of the sort.
-     */
-    metadata: Record<string, any>;
-    /**
-     * The name of the sort.
-     */
-    name: string;
-    /**
-     * The value corresponding to the descending sort.
-     */
-    desc: string;
-    /**
-     * The value corresponding to the ascending sort.
-     */
-    asc: string;
-    /**
-     * The value that will be applied on toggle.
-     */
-    next: string;
-    /**
-     * Whether this sort is hidden.
-     */
-    hidden: boolean;
-  }
-  interface Refinements {
-    /**
-     * The list of available filters.
-     */
-    filters: Array<FilterRefinement>;
-    /**
-     * The list of available sorts.
-     */
-    sorts: Array<SortRefinement>;
-    /**
-     * The URL scope for these refinements.
-     */
-    scope?: string;
-    /**
-     * The scope keys for these refinements.
-     */
-    keys: {
-      /**
-       * The scope key for sorting.
-       */
-      sorts: string;
-      /**
-       * The scope key for filtering.
-       */
-      filters: string;
-    };
-  }
+  isSorting: (direction?: SortDirection) => boolean;
+  /**
+   * Clears this sort.
+   */
+  clear: (options?: AvailableHybridRequestOptions) => Promise<NavigationResponse>;
 }
-declare function useRefinements<Properties extends object, RefinementsKey extends { [K in keyof Properties]: Properties[K] extends Refinements ? K : never }[keyof Properties]>(properties: Properties, refinementsKeys: RefinementsKey, defaultOptions?: AvailableHybridRequestOptions): {
+interface UseRefinements {
   /**
    * Binds a named filter to a ref, applying filters when it changes and updating the ref accordingly.
    */
-  bindFilter: <T = string | number>(name: string, options?: BindFilterOptions<T>) => Ref<T>;
+  bindFilter: <T = string | number>(name: string, options?: BindFilterOptions<T>) => Ref<string>;
   /**
    * Available filters.
    */
-  filters: {
-    /**
-     * Applies this filter.
-     */
-    apply: (value: any, options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse | undefined>;
-    /**
-     * Clears this filter.
-     */
-    clear: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
-    /**
-     * Whether this filter is currently active.
-     */
-    is_active: boolean;
-    /**
-     * The type of this filter.
-     */
-    type: "trashed" | "callback" | "exact" | "similar:loose" | "similar:begins_with_strict" | "similar:ends_with_strict" | string;
-    /**
-     * The label of the filter.
-     */
-    label: string;
-    /**
-     * The metadata attributes of the filter.
-     */
-    metadata: Record<string, any>;
-    /**
-     * The name of the fitler.
-     */
-    name: string;
-    /**
-     * The current value of the filter.
-     */
-    value: any;
-    /**
-     * Whether this filter is hidden.
-     */
-    hidden: boolean;
-    /**
-     * The default value of the filter.
-     */
-    default: any;
-  }[];
+  filters: ComputedRef<Array<BoundFilterRefinement>>;
   /**
    * Available sorts.
    */
-  sorts: {
-    /**
-     * Toggles this sort.
-     */
-    toggle: (options?: ToggleSortOptions) => Promise<index_d_exports.NavigationResponse | undefined>;
-    /**
-     * Checks if this sort is active.
-     */
-    isSorting: (direction?: SortDirection) => boolean;
-    /**
-     * Clears this sort.
-     */
-    clear: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
-    /**
-     * Whether this sort is currently active.
-     */
-    is_active: boolean;
-    /**
-     * The current direction of the sort.
-     */
-    direction?: SortDirection;
-    /**
-     * The default direction of the sort.
-     */
-    default?: SortDirection;
-    /**
-     * The label of the sort.
-     */
-    label: string;
-    /**
-     * The metadata attributes of the sort.
-     */
-    metadata: Record<string, any>;
-    /**
-     * The name of the sort.
-     */
-    name: string;
-    /**
-     * The value corresponding to the descending sort.
-     */
-    desc: string;
-    /**
-     * The value corresponding to the ascending sort.
-     */
-    asc: string;
-    /**
-     * The value that will be applied on toggle.
-     */
-    next: string;
-    /**
-     * Whether this sort is hidden.
-     */
-    hidden: boolean;
-  }[];
+  sorts: ComputedRef<Array<BoundSortRefinement>>;
   /**
    * The key for the filters.
    */
-  filtersKey: vue0.ComputedRef<string>;
+  filtersKey: Readonly<Ref<string>>;
+  /**
+   * The key for the sorts.
+   */
+  sortsKey: Readonly<Ref<string>>;
   /**
    * Gets a filter by name.
    */
-  getFilter: (name: string) => FilterRefinement | undefined;
+  getFilter: (name: string) => BoundFilterRefinement | undefined;
   /**
    * Gets a sort by name.
    */
-  getSort: (name: string) => SortRefinement | undefined;
+  getSort: (name: string) => BoundSortRefinement | undefined;
   /**
    * Resets all filters and sorts.
    */
-  reset: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
+  reset: (options?: AvailableHybridRequestOptions) => Promise<NavigationResponse>;
   /**
    * Toggles the specified sort.
    */
-  toggleSort: (name: string, options?: ToggleSortOptions) => Promise<index_d_exports.NavigationResponse | undefined>;
+  toggleSort: (name: string, options?: ToggleSortOptions) => Promise<NavigationResponse | undefined>;
   /**
    * Whether a sort is active.
    */
@@ -506,67 +1063,42 @@ declare function useRefinements<Properties extends object, RefinementsKey extend
   /**
    * Clears the given filter.
    */
-  clearFilter: (filter: string, options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
+  clearFilter: (filter: string, options?: AvailableHybridRequestOptions) => Promise<NavigationResponse>;
   /**
    * Resets all sorts.
    */
-  clearSorts: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
+  clearSorts: (options?: AvailableHybridRequestOptions) => Promise<NavigationResponse>;
   /**
    * Resets all filters.
    */
-  clearFilters: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
+  clearFilters: (options?: AvailableHybridRequestOptions) => Promise<NavigationResponse>;
   /**
    * Applies the given filter.
    */
-  applyFilter: (name: string, value: any, options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse | undefined>;
-};
-//#endregion
-//#region src/composables/current-route.d.ts
-declare function useRoute(): {
-  isNavigating: Readonly<vue0.Ref<boolean, boolean>>;
-  current: Readonly<vue0.Ref<string | undefined, string | undefined>>;
-  matches: <T extends RouteName>(name: MaybeRefOrGetter<T>, parameters?: RouteParameters<T>) => boolean;
-};
-//#endregion
-//#region src/composables/bulk-select.d.ts
-interface BulkSelection<T = any> {
-  /** Whether all records are selected. */
-  all: boolean;
-  /** Included records. */
-  only: Set<T>;
-  /** Excluded records. */
-  except: Set<T>;
+  applyFilter: (name: string, value: any, options?: AvailableHybridRequestOptionsForFilters) => Promise<NavigationResponse | undefined>;
 }
-declare function useBulkSelect<T = any>(): {
-  allSelected: vue0.ComputedRef<boolean>;
-  selectAll: () => void;
-  deselectAll: () => void;
-  select: (...records: T[]) => void;
-  deselect: (...records: T[]) => void;
-  toggle: (record: T, force?: boolean) => void;
-  selected: (record: T) => boolean;
-  selection: Ref<BulkSelection<T>, BulkSelection<T>>;
-  bindCheckbox: (key: T) => {
-    onChange: (event: Event) => void;
-    checked: boolean;
-    value: T;
-  };
-};
+declare function useRefinements<T extends Refinements>(input: MaybeRefOrGetter<T>, defaultOptions?: AvailableHybridRequestOptions): UseRefinements;
+//#endregion
+//#region src/composables/register-hook.d.ts
+/**
+ * Registers a global hook.
+ * If called inside a component, unregisters after the component is unmounted.
+ */
+declare const registerHook: typeof registerHook$1;
 //#endregion
 //#region src/composables/table.d.ts
-declare global {
-  interface Table<T extends Record<string, any> = any, PaginatorKind extends 'cursor' | 'length-aware' | 'simple' = 'length-aware'> {
-    id: string;
-    keyName: string;
-    scope?: string;
-    columns: Column<T>[];
-    inlineActions: InlineAction[];
-    bulkActions: BulkAction[];
-    records: Array<T>;
-    paginator: Omit<PaginatorKind extends 'cursor' ? CursorPaginator<T> : (PaginatorKind extends 'simple' ? SimplePaginator<T> : Paginator<T>), 'data'>;
-    refinements: Refinements;
-    endpoint: string;
-  }
+interface Table<T extends Record<string, any> = any, PaginatorKind extends 'cursor' | 'length-aware' | 'simple' = 'length-aware'> {
+  id: string;
+  keyName: keyof T | null;
+  scope?: string;
+  columns: Column<T>[];
+  inlineActions: InlineAction[];
+  bulkActions: BulkAction[];
+  records: Array<T>;
+  cells: TableCellRow<T>[];
+  paginator: Omit<PaginatorKind extends 'cursor' ? CursorPaginator<T> : (PaginatorKind extends 'simple' ? SimplePaginator<T> : Paginator<T>), 'data'>;
+  refinements: Refinements;
+  endpoint: string;
 }
 interface Column<T extends object = never> {
   /** The name of this column. */
@@ -578,6 +1110,14 @@ interface Column<T extends object = never> {
   /** Metadata of this column. */
   metadata: Record<string, any>;
 }
+interface TableCell<T extends object = never> {
+  value: any;
+  extra: Record<string, any>;
+}
+interface TableCellRow<T extends object = never> {
+  key: RecordIdentifier | null;
+  columns: Partial<Record<keyof T | string, TableCell<T>>>;
+}
 interface Action {
   /** The name of this action. */
   name: string;
@@ -587,21 +1127,19 @@ interface Action {
   type: string;
   /** Custom metadata for this action. */
   metadata: any;
+  /** A user-defined URL to which to post the action. */
+  url?: string;
 }
 interface BulkAction extends Action {
   /** Should deselect all records after action. */
   deselect: boolean;
 }
-interface BulkActionOptions {
+interface BulkActionOptions extends Omit<HybridRequestOptions, 'url'> {
   /** Force deselecting all records after action. */
   deselect?: boolean;
 }
 interface InlineAction extends Action {}
 type RecordIdentifier = string | number;
-type AsRecordTypeWithExtra<T extends Record<string, any>> = { [K in keyof T]: {
-  extra: Record<string, any>;
-  value: T[K];
-} };
 interface TableDefaultOptions extends AvailableHybridRequestOptions {
   /**
    * Whether to include existing query parameters in the request.
@@ -613,154 +1151,165 @@ interface TableDefaultOptions extends AvailableHybridRequestOptions {
    */
   data?: Record<string, FormDataConvertible> | FormDataConvertible;
 }
-/**
- * Provides utilities for working with tables.
- */
-declare function useTable<RecordType extends (Props[PropsKey] extends Table<infer T, any> ? T : never), RecordTypeWithExtra extends AsRecordTypeWithExtra<RecordType>, PaginatorKindName extends (Props[PropsKey] extends Table<any, infer PaginatorKind> ? PaginatorKind : never), TableType extends (Props[PropsKey] extends Table<any, PaginatorKindName> ? Table<RecordTypeWithExtra, PaginatorKindName> : never), Props extends Record<string, unknown>, PropsKey extends keyof Props>(props: Props, key: PropsKey, defaultOptions?: TableDefaultOptions): {
-  bindFilter: <T = string | number>(name: string, options?: BindFilterOptions<T>) => vue0.Ref<T, T>;
-  filters: {
-    apply: (value: any, options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse | undefined>;
-    clear: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
-    is_active: boolean;
-    type: "trashed" | "callback" | "exact" | "similar:loose" | "similar:begins_with_strict" | "similar:ends_with_strict" | string;
-    label: string;
-    metadata: Record<string, any>;
-    name: string;
-    value: any;
-    hidden: boolean;
-    default: any;
-  }[];
-  sorts: {
-    toggle: (options?: ToggleSortOptions) => Promise<index_d_exports.NavigationResponse | undefined>;
-    isSorting: (direction?: SortDirection) => boolean;
-    clear: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
-    is_active: boolean;
-    direction?: SortDirection | undefined;
-    default?: SortDirection | undefined;
-    label: string;
-    metadata: Record<string, any>;
-    name: string;
-    desc: string;
-    asc: string;
-    next: string;
-    hidden: boolean;
-  }[];
-  filtersKey: string;
-  getFilter: (name: string) => FilterRefinement | undefined;
-  getSort: (name: string) => SortRefinement | undefined;
-  reset: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
-  toggleSort: (name: string, options?: ToggleSortOptions) => Promise<index_d_exports.NavigationResponse | undefined>;
-  isSorting: (name?: string, direction?: SortDirection) => boolean;
-  isFiltering: (name?: string) => boolean;
-  currentSorts: () => Array<SortRefinement>;
-  currentFilters: () => Array<FilterRefinement>;
-  clearFilter: (filter: string, options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
-  clearSorts: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
-  clearFilters: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>;
-  applyFilter: (name: string, value: any, options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse | undefined>;
+type UseTableNavigationResponse = Promise<_hybridly_core0.NavigationResponse | undefined>;
+type ExtractRefValue<T> = T extends {
+  value: infer Value;
+} ? Value : T;
+interface UseTableInlineActionItem<RecordType extends Record<string, any>> extends InlineAction {
+  /** Executes the action. */
+  execute: (record: RecordIdentifier | RecordType) => UseTableNavigationResponse;
+}
+interface UseTableBulkActionItem extends BulkAction {
+  /** Executes the action. */
+  execute: (options?: BulkActionOptions) => UseTableNavigationResponse;
+}
+interface UseTableColumn<RecordType extends Record<string, any>> extends Column<RecordType> {
+  /** Toggles sorting for this column. */
+  toggleSort: (options?: ToggleSortOptions) => UseTableNavigationResponse;
+  /** Checks whether the column is being sorted. */
+  isSorting: (direction?: SortDirection) => boolean;
+  /** Applies the filter for this column. */
+  applyFilter: (value: any, options?: AvailableHybridRequestOptions) => UseTableNavigationResponse;
+  /** Clears the filter for this column. */
+  clearFilter: (options?: AvailableHybridRequestOptions) => UseTableNavigationResponse;
+  /** Checks whether the column is sortable. */
+  isSortable: boolean;
+  /** Checks whether the column is filterable. */
+  isFilterable: boolean;
+}
+interface UseTableRecordItem<RecordType extends Record<string, any>> {
+  /** The actual record. */
+  record: RecordType;
+  /** Local key of the record. Use this as a rendering key. */
+  key: RecordIdentifier;
+  /** Server-side key of the record, if any. */
+  recordKey: RecordIdentifier | undefined;
+  /** Whether this record has a server-side key. */
+  hasKey: boolean;
+  /** Executes the given inline action. */
+  execute: (action: string | InlineAction) => UseTableNavigationResponse;
+  /** Gets the available inline actions. */
+  actions: Array<InlineAction & {
+    execute: () => UseTableNavigationResponse;
+  }>;
+  /** Selects this record. */
+  select: () => void;
+  /** Deselects this record. */
+  deselect: () => void;
+  /** Toggles the selection for this record. */
+  toggle: (force?: boolean) => void;
+  /** Checks whether this record is selected. */
+  selected: boolean;
+  /** Gets the value of the record for the specified column. */
+  value: (column: string | Column<RecordType>) => any;
+  /** Gets the extra object of the record for the specified column. */
+  extra: (column: string | Column<RecordType>, path: string) => any;
+}
+interface UseTableReturn<T extends Table<any, any>, RecordType extends Record<string, any> = (T extends Table<infer R, any> ? R : any), PaginatorKind extends 'cursor' | 'length-aware' | 'simple' = (T extends Table<any, infer P> ? P : 'length-aware')> extends Omit<UseRefinements, 'filters' | 'sorts' | 'filtersKey' | 'sortsKey'> {
+  /** Selects all records. */
   selectAll: () => void;
+  /** Deselects all records. */
   deselectAll: () => void;
+  /** Selects records on the current page. */
   selectPage: () => void;
+  /** Deselects records on the current page. */
   deselectPage: () => void;
+  /** Whether all records on the current page are selected. */
   isPageSelected: boolean;
-  isSelected: (record: RecordTypeWithExtra) => boolean;
+  /** Checks if the given record is selected. */
+  isSelected: (record: RecordType) => boolean;
+  /** Whether all records are selected. */
   allSelected: boolean;
+  /** Whether any records are selected. */
+  anySelected: boolean;
+  /** The current record selection. */
   selection: BulkSelection<RecordIdentifier>;
+  /** Binds a checkbox to its selection state. */
   bindCheckbox: (key: RecordIdentifier) => {
     onChange: (event: Event) => void;
     checked: boolean;
     value: RecordIdentifier;
   };
-  toggle: (record: RecordTypeWithExtra) => void;
-  select: (record: RecordTypeWithExtra) => void;
-  deselect: (record: RecordTypeWithExtra) => void;
-  inlineActions: {
-    /** The name of this action. */name: string; /** The label of this action. */
-    label: string; /** The type of this action. */
-    type: string; /** Custom metadata for this action. */
-    metadata: any; /** Executes the action. */
-    execute: (record: RecordTypeWithExtra | RecordIdentifier) => Promise<index_d_exports.NavigationResponse>;
-  }[];
-  bulkActions: {
-    /** Should deselect all records after action. */deselect: boolean; /** The name of this action. */
-    name: string; /** The label of this action. */
-    label: string; /** The type of this action. */
-    type: string; /** Custom metadata for this action. */
-    metadata: any; /** Executes the action. */
-    execute: (options?: BulkActionOptions) => Promise<index_d_exports.NavigationResponse>;
-  }[];
-  executeInlineAction: (action: Action | string, record: RecordTypeWithExtra | RecordIdentifier) => Promise<index_d_exports.NavigationResponse>;
-  executeBulkAction: (action: Action | string, options?: BulkActionOptions) => Promise<index_d_exports.NavigationResponse>;
-  columns: {
-    /** Toggles sorting for this column. */toggleSort: (options?: ToggleSortOptions) => Promise<index_d_exports.NavigationResponse | undefined>; /** Checks whether the column is being sorted. */
-    isSorting: (direction?: SortDirection) => boolean; /** Applies the filer for this column. */
-    applyFilter: (value: any, options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse | undefined>; /** Clears the filter for this column. */
-    clearFilter: (options?: AvailableHybridRequestOptions) => Promise<index_d_exports.NavigationResponse>; /** Checks whether the column is sortable. */
-    isSortable: boolean; /** Checks whether the column is filterable. */
-    isFilterable: boolean; /** The name of this column. */
-    name: keyof RecordTypeWithExtra; /** The label of this column. */
-    label: string; /** The type of this column. */
-    type: string; /** Metadata of this column. */
-    metadata: Record<string, any>;
-  }[];
+  /** Toggles selection for the given record. */
+  toggle: (record: RecordType, force?: boolean) => void;
+  /** Toggles selection for all records. */
+  toggleAll: (force?: boolean) => void;
+  /** Selects selection for the given record. */
+  select: (record: RecordType) => void;
+  /** Deselects selection for the given record. */
+  deselect: (record: RecordType) => void;
+  /** List of inline actions for this table. */
+  inlineActions: Array<UseTableInlineActionItem<RecordType>>;
+  /** List of bulk actions for this table. */
+  bulkActions: Array<UseTableBulkActionItem>;
+  /** Executes the given inline action for the given record. */
+  executeInlineAction: (action: InlineAction | string, options: {
+    record: RecordIdentifier | RecordType;
+  } & Omit<HybridRequestOptions, 'url'>) => UseTableNavigationResponse;
+  /** Executes the given bulk action. */
+  executeBulkAction: (action: BulkAction | string, options?: Omit<HybridRequestOptions, 'url'> & {
+    deselect?: boolean;
+  }) => UseTableNavigationResponse;
+  /** List of columns for this table. */
+  columns: Array<UseTableColumn<RecordType>>;
+  /** List of records for this table. */
   data: RecordType[];
-  records: {
-    /** The actual record. */record: any[]; /** The key of the record. Use this instead of `id`. */
-    key: RecordIdentifier; /** Executes the given inline action. */
-    execute: (action: string | InlineAction) => Promise<index_d_exports.NavigationResponse>; /** Gets the available inline actions. */
-    actions: {
-      /** Executes the action. */execute: () => Promise<index_d_exports.NavigationResponse>; /** The name of this action. */
-      name: string; /** The label of this action. */
-      label: string; /** The type of this action. */
-      type: string; /** Custom metadata for this action. */
-      metadata: any;
-    }[]; /** Selects this record. */
-    select: () => void; /** Deselects this record. */
-    deselect: () => void; /** Toggles the selection for this record. */
-    toggle: (force?: boolean) => void; /** Checks whether this record is selected. */
-    selected: boolean; /** Gets the value of the record for the specified column. */
-    value: (column: string | Column<RecordTypeWithExtra>) => RecordType[string] | RecordType[number] | RecordType[symbol]; /** Gets the extra object of the record for the specified column. */
-    extra: (column: string | Column<RecordTypeWithExtra>, path: string) => any;
-  }[];
-  paginator: PaginatorResult<unknown, Omit<PaginatorKindName extends "cursor" ? CursorPaginator<RecordTypeWithExtra> : PaginatorKindName extends "simple" ? SimplePaginator<RecordTypeWithExtra> : Paginator<RecordTypeWithExtra>, "data">>;
-};
-//#endregion
-//#region src/composables/query-parameters.d.ts
+  /** List of records for this table. */
+  records: Array<UseTableRecordItem<RecordType>>;
+  /** Paginated meta and links. */
+  paginator: PaginatorResult<RecordType, Table<RecordType, PaginatorKind>['paginator']>;
+  /** Available filters. */
+  filters: ExtractRefValue<UseRefinements['filters']>;
+  /** Available sorts. */
+  sorts: ExtractRefValue<UseRefinements['sorts']>;
+  /** The key for the filters. */
+  filtersKey: ExtractRefValue<UseRefinements['filtersKey']>;
+  /** The key for the sorts. */
+  sortsKey: ExtractRefValue<UseRefinements['sortsKey']>;
+}
 /**
- * Access reactive query parameters.
- *
- * @see https://hybridly.dev/api/utils/use-query-parameters.html
+ * Provides utilities for working with tables.
  */
-declare function useQueryParameters<T extends Record<string, any> = Record<string, any>>(): T;
-type RouteParameter = string | number | boolean | null | undefined;
-type TransformFunction<V extends RouteParameter, R> = (val: V) => R;
-type TransformType<T extends RouteParameter, O> = O extends {
-  transform: 'number';
-} ? number : O extends {
-  transform: 'bool';
-} ? boolean : O extends {
-  transform: 'string';
-} ? string : O extends {
-  transform: 'date';
-} ? Date : O extends {
-  transform: TransformFunction<T, infer R>;
-} ? R : T;
-interface UseQueryParameterOptions<V extends RouteParameter, R> {
+declare function useTable<T extends Table<any, any>, RecordType extends Record<string, any> = (T extends Table<infer R, any> ? R : any), PaginatorKind extends 'cursor' | 'length-aware' | 'simple' = (T extends Table<any, infer P> ? P : 'length-aware')>(input: MaybeRefOrGetter<T>, defaultOptions?: TableDefaultOptions): UseTableReturn<T, RecordType, PaginatorKind>;
+//#endregion
+//#region src/composables/validation.d.ts
+/** Accesses all validation errors grouped by bag name. */
+declare function useValidation<T extends Validation = Validation>(): vue.DeepReadonly<vue.UnwrapNestedRefs<T>>;
+/** Accesses validation errors for a single bag. */
+declare function useValidationBag<T extends Errors = Errors>(bag?: string): vue.DeepReadonly<vue.UnwrapNestedRefs<T>>;
+//#endregion
+//#region src/default-layout.d.ts
+type ViewLayout = Component | Component[];
+type DefaultLayout = ViewLayout | (() => ViewLayout);
+//#endregion
+//#region src/plugins/progress.d.ts
+interface ProgressOptions {
   /**
-   * Specifies a default value if the query parameter does not exist.
+   * The delay after which the progress bar will
+   * appear during navigation, in milliseconds.
+   *
+   * @default 250
    */
-  defaultValue?: MaybeRefOrGetter<R>;
+  delay: number;
   /**
-   * Transforms the query parameter.
+   * The color of the progress bar.
+   *
+   * Defaults to #29d.
    */
-  transform?: 'number' | 'bool' | 'string' | 'date' | TransformFunction<V, R>;
+  color: string;
+  /**
+   * Whether to include the default NProgress styles.
+   *
+   * Defaults to true.
+   */
+  includeCSS: boolean;
+  /**
+   * Whether the NProgress spinner will be shown.
+   *
+   * Defaults to false.
+   */
+  spinner: boolean;
 }
-/**
- * Makes the specified query parameter reactive.
- *
- * @see https://hybridly.dev/api/utils/use-query-parameter.html
- */
-declare function useQueryParameter<ParameterType extends RouteParameter = RouteParameter, Options extends UseQueryParameterOptions<ParameterType, any> = UseQueryParameterOptions<ParameterType, ParameterType>>(name: string, options?: Options): Ref<TransformType<ParameterType, Options>>;
 //#endregion
 //#region src/initialize.d.ts
 /**
@@ -790,8 +1339,8 @@ interface InitializeOptions {
   setup?: (options: SetupArguments) => any;
   /** List of Hybridly plugins. */
   plugins?: Plugin$1[];
-  /** Custom Axios instance. */
-  axios?: Axios;
+  /** Custom HTTP client instance. */
+  http?: HttpClient;
   /**
    * Enables the View Transition API, if supported.
    * @see https://developer.mozilla.org/en-US/docs/Web/API/ViewTransition
@@ -799,6 +1348,8 @@ interface InitializeOptions {
   viewTransition?: boolean;
   /** Options that will apply to all forms by default. Specific forms' options will override them. */
   defaultFormOptions?: DefaultFormOptions;
+  /** Default layout applied to views that do not define one. */
+  layout?: DefaultLayout;
 }
 interface SetupArguments {
   /** DOM element to mount Vue on. */
@@ -817,20 +1368,4 @@ interface SetupArguments {
   payload: Record<string, any>;
 }
 //#endregion
-//#region src/components/link.d.ts
-interface RouterLinkProps {
-  href?: string;
-  as?: string | object;
-  method?: Method | Lowercase<Method>;
-  data?: RequestData;
-  external?: boolean;
-  disabled?: boolean;
-  options?: Omit<HybridRequestOptions, 'url' | 'data' | 'method'>;
-  text?: string;
-  preload?: boolean | 'hover' | 'mount';
-  preserveScroll?: boolean;
-  preserveState?: boolean;
-}
-declare const RouterLink: DefineComponent<RouterLinkProps>;
-//#endregion
-export { Action, AvailableHybridRequestOptions, BindFilterOptions, BulkAction, BulkSelection, Column, DefaultFormOptions, FormReturn, type InitializeOptions, InlineAction, InternalProperties, MaybeWithData, PaginatorResult, RecordIdentifier, RouterLink, SortDirection, TableDefaultOptions, ToggleSortOptions, can, createPaginator, initializeHybridly, registerHook, route, router, setProperty, useBackForward, useBulkSelect, useDialog, useForm, useHistoryState, useProperties, useProperty, useQueryParameter, useQueryParameters, useRefinements, useRoute, useTable };
+export { Action, AvailableHybridRequestOptions, AvailableHybridRequestOptionsForFilters, BaseFilterRefinement, BindFilterOptions, BooleanFilterRefinement, BoundBooleanFilterRefinement, BoundCallbackFilterRefinement, BoundDateFilterRefinement, BoundFilterRefinement, BoundSelectFilterRefinement, BoundSortRefinement, BoundTernaryFilterRefinement, BoundTextFilterRefinement, BoundTrashedFilterRefinement, BulkAction, BulkSelection, CallbackFilterRefinement, Column, DateFilterRefinement, DefaultFormOptions, Deferred, FilterOperator, FilterRefinement, Form, type FormProps, FormReturn, type FormSlotProps, type FormSubmitOptions, type InitializeOptions, InlineAction, InternalProperties, MaybeWithData, NumericFilterRefinement, PaginatorResult, RecordIdentifier, Refinements, RouterLink, SelectFilterRefinement, SortDirection, SortRefinement, Table, TableCell, TableCellRow, TableDefaultOptions, TernaryFilterRefinement, TextFilterRefinement, TimeSuggestion, TimeframeSuggestion, ToggleSortOptions, TrashedFilterRefinement, UseRefinements, UseTableBulkActionItem, UseTableColumn, UseTableInlineActionItem, UseTableRecordItem, UseTableReturn, WhenVisible, createPaginator, getBulkSelectionRange, initializeHybridly, isBooleanFilter, isCallbackFilter, isDateFilter, isSelectFilter, isTernaryFilter, isTextFilter, isTrashedFilter, registerHook, route, router, setProperty, useBackForward, useBulkSelect, useDialog, useForm, useHistoryState, useProperties, useProperty, useQueryParameter, useQueryParameters, useRefinements, useRoute, useTable, useValidation, useValidationBag };