@anzusystems/common-admin 1.47.0-beta.dev-1788935859 → 1.47.0-beta.dev-1789894877

package/dist/labs.d.ts

@@ -10,6 +10,7 @@ import { MaybeRefOrGetter } from 'vue';
 import { Method } from 'axios';
 import { PublicProps } from 'vue';
 import { Ref } from 'vue';
+import { RouteLocationRaw } from 'vue-router';
 import { ShallowRef } from 'vue';
 import { ShallowUnwrapRef } from 'vue';
 import { UseDebounceFnReturn } from '@vueuse/shared';
@@ -36,8 +37,8 @@ declare const __VLS_base: DefineComponent<__VLS_PublicProps, {
     client: () => AxiosInstance;
     enableTop: boolean;
     hideButtons: boolean;
-    formName: string;
     store: FilterStoreIdentifier | boolean;
+    formName: string;
     alwaysVisible: boolean;
     hideMore: boolean;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
@@ -70,9 +71,9 @@ declare const __VLS_base_3: DefineComponent<__VLS_PublicProps_2, {
     userId: IntegerIdNullable;
     client: () => AxiosInstance;
     hideButtons: boolean;
+    store: FilterStoreIdentifier | boolean;
     formName: string;
     disableFilterUrlSync: boolean;
-    store: FilterStoreIdentifier | boolean;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
 declare const __VLS_base_4: DefineComponent<__VLS_Props_9, {
@@ -453,6 +454,10 @@ declare const __VLS_export_21: DefineComponent<__VLS_PublicProps_5, {}, {}, {},
     dirtyLabels: string[];
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
+declare const __VLS_export_22: DefineComponent<__VLS_Props_15, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_15> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_export_23: DefineComponent<__VLS_Props_16, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_16> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
 declare const __VLS_export_3: __VLS_WithSlots_3<typeof __VLS_base_3, __VLS_Slots_3>;
 
 declare const __VLS_export_4: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
@@ -634,6 +639,34 @@ declare type __VLS_Props_13 = {
 
 declare type __VLS_Props_14 = Props_4;
 
+declare type __VLS_Props_15 = {
+    /** Which backend to ask. */
+    client: AxiosClientFn;
+    /** Identity used for api naming and error reporting -- `coreDam`, not `dam`, where they differ. */
+    system: string;
+    /** From the route, never component state: it picks the endpoint and has to survive a filter reset. */
+    type: LogTypeType;
+    /** Whole paths per type. Comes from the route-side descriptor, which the guard reads too. */
+    logPaths: LogPaths;
+    /** Where a row goes. The library cannot know an app's typed route names, so the app maps it. */
+    detailRoute: (log: Log) => RouteLocationRaw;
+    /** Where the app/audit dropdown goes. Same reason. */
+    typeRoute: (type: LogTypeType) => RouteLocationRaw;
+    /** Mandatory time bound, as admin-dam has today. Omitted means no bound at all. */
+    defaultTimeWindow?: LogTimeWindow | undefined;
+    /** `allowed` for the interval filter. Omitted means the library's full preset list. */
+    allowedTimeIntervals?: TimeIntervalToolsValue[] | undefined;
+};
+
+declare type __VLS_Props_16 = {
+    client: AxiosClientFn;
+    system: string;
+    /** From the route. A log id means nothing without the store it came from. */
+    type: LogTypeType;
+    id: string;
+    logPaths: LogPaths;
+};
+
 declare type __VLS_Props_2 = {
     formName?: string;
 };
@@ -836,6 +869,10 @@ export declare const AListEditor: typeof __VLS_export_18;
 
 declare type AllowedFilterValues = number | number[] | string | string[] | null | undefined | boolean;
 
+export declare const ALogDetailView: typeof __VLS_export_23;
+
+export declare const ALogListView: typeof __VLS_export_22;
+
 export declare const ANestedSortableListEditor: typeof __VLS_export_20;
 
 declare interface AnzuUserAndTimeTrackingAware extends CreatedByAware {
@@ -848,6 +885,42 @@ declare interface AnzuUserMinimal extends BaseUser {
     id: IntegerId;
 }
 
+export declare type ApiErrorContext = {
+    system: string;
+    entity: string;
+    /** The url actually requested, parameters substituted and query included -- not the template. */
+    url?: string;
+    /**
+     * The status the backend answered with, when it answered at all. Absent for a transport failure,
+     * where there is no response.
+     *
+     * It is here so an application can decide what is worth writing down without the call sites having
+     * to: a 404 that a caller probes for, for instance. Those used to be silenced per call, which made
+     * whether a failure was recorded depend on which call made it. The switch is the application's now,
+     * and this is what it needs to use it.
+     *
+     * Two statuses are not the application's to decide, and the library keeps them: 401 and 403. They
+     * are not an endpoint failing its contract, they are the session -- nobody is logged in, or this
+     * user may not -- and every admin in the fleet already branches on them and acts. Everything else
+     * reaches the logger and is filtered here, on this field.
+     */
+    status?: number;
+};
+
+export declare type ApiErrorLogger = (error: Error, context: ApiErrorContext) => void;
+
+/**
+ * Called on every mount, not only when the type changes. The registry hands back the same
+ * `filterConfig` the previous visit left behind, so these flags still describe whichever type was
+ * open last. Landing straight on an `app` url after an audit visit -- a link, a bookmark, F5 --
+ * would otherwise send that visit's `resourceName` to the app endpoint.
+ *
+ * Three flags, not two -- `FiltersSelected` hides a chip on `render.selected`, so without the
+ * third one the bar would advertise a filter that is not being applied, and its close button
+ * would destroy the very value this approach exists to keep.
+ */
+export declare const applyLogTypeVisibility: (filter: LogFilter, type: LogTypeType) => void;
+
 export declare const ASortableListEditor: typeof __VLS_export_19;
 
 export declare const ASubjectSelect: typeof __VLS_export_17;
@@ -1005,6 +1078,11 @@ declare interface DecoratedViewItem_2<T> extends ListViewItem<T> {
     canMoveDown: boolean;
 }
 
+export declare const DEFAULT_LOG_PATHS: LogPaths;
+
+/** What reporting does until an application says otherwise; exported so a test can put it back. */
+export declare const defaultApiErrorLogger: ApiErrorLogger;
+
 /**
  * UUID v4 as string.
  */
@@ -1034,10 +1112,12 @@ declare interface EmptySlotProps_3 {
     };
 }
 
-declare type ExecuteRequestParams<T> = {
+export declare type ExecuteRequestParams<B> = {
     urlTemplate?: string;
     urlParams?: UrlParams;
-    object?: T;
+    body?: B;
+    /** Stops this one call, leaving the instance's other calls alone. */
+    signal?: AbortSignal;
 };
 
 /**
@@ -1063,9 +1143,11 @@ export declare type ExposedNestedListEditorHandle<TItem extends Record<string, a
     hasUnsavedChanges: boolean;
 };
 
-declare type FetchByIdsParams = {
+export declare type FetchByIdsParams = {
     urlTemplate?: string;
     urlParams?: UrlParams;
+    /** Stops this one call, leaving the instance's other calls alone. */
+    signal?: AbortSignal;
 };
 
 declare type FetchItemsMinimalByIdsType = ((ids: IntegerId[]) => Promise<any[]>) | ((ids: DocId[]) => Promise<any[]>);
@@ -1074,7 +1156,16 @@ declare type FetchItemsMinimalType = (pagination: Ref<Pagination>, filterData: F
 
 declare type FetchItemsMinimalType_2 = (pagination: Ref<Pagination>, filterData: FilterData, filterConfig: FilterConfig) => Promise<any[]>;
 
-declare type FetchListBatchParams = {
+export declare type FetchItemsParams = {
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    /** Stops this one call, leaving the instance's other calls alone. */
+    signal?: AbortSignal;
+};
+
+export declare type FetchListBatchParams = {
+    /** Stops this one call, leaving the instance's other calls alone. */
+    signal?: AbortSignal;
     urlTemplate?: string;
     urlParams?: UrlParams;
     sortBy?: string;
@@ -1083,10 +1174,12 @@ declare type FetchListBatchParams = {
     forceElastic?: boolean;
 };
 
-declare type FetchListParams = {
+export declare type FetchListParams = {
     urlTemplate?: string;
     urlParams?: UrlParams;
     forceElastic?: boolean;
+    /** Stops this one call, leaving the instance's other calls alone. */
+    signal?: AbortSignal;
 };
 
 declare interface FilerRenderOptions {
@@ -1159,6 +1252,12 @@ declare type FilterVariant = 'search' | 'lt' | 'in' | 'notIn' | 'endsWith' | 'st
 
 declare type FilterVariant_2 = 'search' | 'lt' | 'in' | 'notIn' | 'endsWith' | 'startsWith' | 'memberOf' | 'contains' | 'neq' | 'gte' | 'gt' | 'eq' | 'lte' | 'custom';
 
+/**
+ * Pretty-prints a JSON string, and hands back whatever it was given when that is not what it is.
+ * Log context carries request and response bodies that are usually but not always JSON.
+ */
+export declare const formatJson: (data: string) => string;
+
 declare interface GeneralFilterOptions {
     system?: string;
     subject?: string;
@@ -1192,6 +1291,8 @@ declare type IntegerId = number;
  */
 declare type IntegerIdNullable = number | null;
 
+export declare const isLogType: (value: unknown) => value is LogTypeType;
+
 /** Whether `router.push({ hash })` would leave the hash intact — see `buildFilterHash`. */
 export declare const isRouterSafeHash: (hash: string) => boolean;
 
@@ -1361,6 +1462,215 @@ export declare interface ListViewItem<TItem> {
     validationState?: ListEditorValidationState;
 }
 
+declare interface Log {
+    id: string;
+    message: string;
+    datetime: DatetimeUTC;
+    levelName: LogLevelType;
+    context: {
+        appVersion: string;
+        appSystem: string;
+        requestOriginAppVersion: string;
+        path: string;
+        method: string;
+        contextId: string;
+        userId: IntegerIdNullable;
+        resourceName: string;
+        resourceIds: string[];
+        ip: string;
+        response: string;
+        content?: string;
+        params: string;
+        httpStatus: number;
+    };
+    _resourceName: string;
+    _system: string;
+    _type: string;
+}
+
+export declare const LOG_ENTITY = "log";
+
+declare interface LogActionsParams {
+    client: AxiosClientFn;
+    system: string;
+    logPaths: LogPaths;
+    type: LogTypeType;
+    /**
+     * Lets an ancestor own the flag, the way `usePagination` takes an external pagination ref --
+     * the card that shows the spinner sits above the table that does the fetching.
+     */
+    loading?: Ref<boolean>;
+}
+
+declare interface LogApiParams {
+    client: AxiosClientFn;
+    system: string;
+    logPaths: LogPaths;
+    type: LogTypeType;
+}
+
+export declare interface LogFilter {
+    filterConfig: FilterConfig<LogFilterFields>;
+    filterData: FilterData<LogFilterFields>;
+}
+
+declare type LogFilterFields = ReturnType<typeof logFilterFields>;
+
+/**
+ * A factory rather than a constant, because `defaultTimeWindow` cannot be expressed as a seeded
+ * value: what makes the window always reach the query is `mandatory` plus `default` on the two
+ * interval fields, and both are read out of this array when `createFilter` runs.
+ */
+declare const logFilterFields: (window: LogTimeWindow | undefined) => ({
+    name: "levelName";
+    variant: "in";
+    default: never[];
+    type?: undefined;
+    apiName?: undefined;
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "id";
+    default: null;
+    type: "string";
+    variant?: undefined;
+    apiName?: undefined;
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "contextId";
+    apiName: string;
+    default: null;
+    type: "string";
+    render: {
+        skip: true;
+    };
+    variant?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "message";
+    variant: "startsWith";
+    default: null;
+    type: "string";
+    render: {
+        skip: true;
+    };
+    apiName?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "appVersion";
+    variant: "startsWith";
+    apiName: string;
+    default: null;
+    type: "string";
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "userId";
+    apiName: string;
+    default: null;
+    type: "integer";
+    variant?: undefined;
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "resourceName";
+    apiName: string;
+    default: null;
+    type: "string";
+    variant?: undefined;
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "resourceIds";
+    apiName: string;
+    variant: "in";
+    default: never[];
+    type: "string";
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "datetimeFrom";
+    apiName: string;
+    type: "timeInterval";
+    related: string;
+    default: string | null;
+    mandatory: boolean;
+    render: {
+        skip: true;
+    };
+    variant?: undefined;
+    exclude?: undefined;
+} | {
+    name: "datetimeTo";
+    apiName: string;
+    type: "timeInterval";
+    exclude: true;
+    default: string | null;
+    mandatory: boolean;
+    render: {
+        skip: true;
+    };
+    variant?: undefined;
+    related?: undefined;
+})[];
+
+declare const LogLevel: {
+    readonly Debug: "DEBUG";
+    readonly Info: "INFO";
+    readonly Notice: "NOTICE";
+    readonly Warning: "WARNING";
+    readonly Error: "ERROR";
+    readonly Critical: "CRITICAL";
+    readonly Alert: "ALERT";
+    readonly Emergency: "EMERGENCY";
+};
+
+declare type LogLevelType = (typeof LogLevel)[keyof typeof LogLevel];
+
+/**
+ * Full paths per type, not a segment appended to a shared prefix: brick exposes its app log at
+ * `/adm/v1/log/journal` rather than `/adm/v1/log/app`, and nothing says the next backend will
+ * differ in the same place.
+ */
+export declare type LogPaths = Record<LogTypeType, string>;
+
+export declare interface LogTimeWindow {
+    from: DatetimeUTC;
+    to: DatetimeUTC;
+}
+
+/**
+ * The two log stores every anzu backend exposes. This is a runtime value on purpose: the router
+ * guard validates the `:type` path segment before any component mounts, and a bare TypeScript
+ * type is erased by then. It is the single source of the valid set -- the dropdown iterates the
+ * same object the guard checks against, so the two cannot drift apart.
+ */
+export declare const LogType: {
+    readonly App: "app";
+    readonly Audit: "audit";
+};
+
+export declare const LogTypeDefault: "app";
+
+export declare type LogTypeType = (typeof LogType)[keyof typeof LogType];
+
 export declare interface MakeFilterOption<TName extends string = string> {
     name: TName;
     default: AllowedFilterValues;
@@ -1642,7 +1952,12 @@ declare interface Props<TItem extends Record<string, any>> {
     disabled?: boolean;
     loading?: boolean;
     error?: string | null;
+    /** Heading above the list. A ready translated string, like every text prop here. */
     title?: string | null;
+    /**
+     * Field shown in a collapsed row when no `#item-compact` slot is given. A dotted path reads
+     * through nested objects (`texts.title`); a path that runs into nothing renders empty.
+     */
     compactField?: string | null;
     statusField?: string | null;
     twoRows?: 'never' | 'mobile' | 'always';
@@ -1651,7 +1966,9 @@ declare interface Props<TItem extends Record<string, any>> {
     showDeleteButton?: boolean;
     showEditButton?: boolean;
     showAddAfterAction?: boolean;
+    /** Label of the add button. A ready translated string; omit it for the library's own wording. */
     addLabel?: string | null;
+    /** Heading of the empty state. A ready translated string. */
     emptyTitle?: string | null;
     disableRowClick?: boolean;
     disableDeleteConfirm?: boolean;
@@ -1745,7 +2062,12 @@ declare interface Props_2<TItem extends Record<string, any>> {
     disabled?: boolean;
     loading?: boolean;
     error?: string | null;
+    /** Heading above the list. A ready translated string, like every text prop here. */
     title?: string | null;
+    /**
+     * Field shown in a collapsed row when no `#item-compact` slot is given. A dotted path reads
+     * through nested objects (`texts.title`); a path that runs into nothing renders empty.
+     */
     compactField?: string | null;
     statusField?: string | null;
     twoRows?: 'never' | 'mobile' | 'always';
@@ -1754,10 +2076,18 @@ declare interface Props_2<TItem extends Record<string, any>> {
     showDeleteButton?: boolean;
     showEditButton?: boolean;
     showAddAfterAction?: boolean;
+    /** Label of the add button. A ready translated string; omit it for the library's own wording. */
     addLabel?: string | null;
+    /** Heading of the empty state. A ready translated string. */
     emptyTitle?: string | null;
     disableRowClick?: boolean;
     disableDeleteConfirm?: boolean;
+    /**
+     * Disable unsaved-state tracking — no dirty markers, never reads as unsaved. For a list that is a
+     * VIEW of data owned elsewhere (a display cache rebuilt from a parent's field, say): nothing in
+     * such a component can ever clear an amber row, so it must not raise one. Mirrors `AListEditor`.
+     */
+    disableUnsaved?: boolean;
     deleteConfirmTitle?: string | null;
     deleteConfirmText?: string | null;
     /**
@@ -1853,7 +2183,12 @@ declare interface Props_3<TItem extends Record<string, any>> {
     disabled?: boolean;
     loading?: boolean;
     error?: string | null;
+    /** Heading above the list. A ready translated string, like every text prop here. */
     title?: string | null;
+    /**
+     * Field shown in a collapsed row when no `#item-compact` slot is given. A dotted path reads
+     * through nested objects (`texts.title`); a path that runs into nothing renders empty.
+     */
     compactField?: string | null;
     statusField?: string | null;
     showAddButton?: boolean;
@@ -1864,10 +2199,18 @@ declare interface Props_3<TItem extends Record<string, any>> {
     showMoveToPosition?: boolean;
     showChangeParent?: boolean;
     showExpandToggle?: boolean;
+    /** Label of the add button. A ready translated string; omit it for the library's own wording. */
     addLabel?: string | null;
+    /** Heading of the empty state. A ready translated string. */
     emptyTitle?: string | null;
     disableRowClick?: boolean;
     disableDeleteConfirm?: boolean;
+    /**
+     * Disable unsaved-state tracking — no dirty markers, never reads as unsaved. For a list that is a
+     * VIEW of data owned elsewhere (a display cache rebuilt from a parent's field, say): nothing in
+     * such a component can ever clear an amber row, so it must not raise one. Mirrors `AListEditor`.
+     */
+    disableUnsaved?: boolean;
     deleteConfirmTitle?: string | null;
     deleteConfirmText?: string | null;
     /**
@@ -2081,6 +2424,19 @@ declare interface RowSlotProps_3<TItem extends Record<string, any>> {
     actions: RowActions_3<TItem>;
 }
 
+/**
+ * Replaces the logger the api helpers report unexpected failures through, or turns reporting off
+ * with `null`.
+ *
+ * It is one switch for the whole family rather than a flag on each instance, which is what it
+ * replaces: whether a failure was written down used to depend on which helper made the call and how
+ * that instance happened to be constructed.
+ *
+ * An application that wants these where it can see them passes its own:
+ * `setApiErrorLogger((e, ctx) => Sentry.captureException(e, { extra: ctx }))`.
+ */
+export declare const setApiErrorLogger: (fn: ApiErrorLogger | null) => void;
+
 export declare interface SharedReorderRegistry {
     register: (id: symbol, movedCount: ComputedRef<number>, hasPendingChanges: ComputedRef<boolean>, validateAll: () => boolean) => void;
     unregister: (id: symbol) => void;
@@ -2197,62 +2553,146 @@ declare type UrlParams = {
     [key: string]: number | string;
 };
 
-declare type UseApiAnyRequestReturnType<R, T = R> = {
-    executeRequest: (params?: ExecuteRequestParams<T>) => Promise<R>;
-    abortRequest: () => void;
-};
+/**
+ * A request that asks the backend to do something and reads nothing back -- a delete, or a call that
+ * only starts work and answers 202. Any successful status resolves; a body, if one arrives, is
+ * ignored rather than typed.
+ */
+export declare const useApiCommand: <B = never>(params: UseApiRequestParams) => UseApiRequestReturnType<void, B>;
 
-export declare const useApiFetchByIds: <R>(params: UseApiFetchByIdsParams) => UseApiFetchByIdsReturnType<R>;
+export declare const useApiFetchByIds: <T>(params: UseApiFetchByIdsParams) => UseApiFetchByIdsReturnType<T>;
 
-declare type UseApiFetchByIdsParams = {
+export declare type UseApiFetchByIdsParams = {
     client: AxiosClientFn;
     system: string;
     entity: string;
     urlTemplate?: string;
     urlParams?: UrlParams;
-    options?: AxiosRequestConfig;
+    /** Anything axios takes except what this helper decides: the method, the url, the body and the signal. */
+    options?: Omit<AxiosRequestConfig, 'method' | 'url' | 'data' | 'signal'>;
     isSearchApi?: boolean;
     field?: string;
-    silentConsoleError?: boolean;
+    cancelPrevious?: boolean;
+};
+
+export declare type UseApiFetchByIdsReturnType<T> = {
+    execute: (ids: DocId[] | IntegerId[], params?: FetchByIdsParams) => Promise<T[]>;
+    abort: () => void;
+    /**
+     * True while this instance has a request in flight, false once the last one settles.
+     *
+     * It is here so a caller does not have to keep its own: the hand-rolled version is a ref cleared
+     * in a `finally`, and that `finally` belongs to whichever call ended -- including one that
+     * `cancelPrevious` just superseded, which turns the spinner off while the call the user is waiting
+     * for is still running. This one never dips between a superseded call and the one that replaced it.
+     */
+    loading: Ref<boolean>;
+};
+
+/**
+ * A list read from an endpoint the caller has already written the query for, with no pagination.
+ *
+ * It exists because the fleet kept doing this through `useApiRequest<ApiResponseList<T[]>>`: build a
+ * query by hand -- an order, a limit, a fixed filter -- bake it into the url, and read `.data` off
+ * the envelope that comes back. That is a list fetch with the list part missing: nothing checks that
+ * `data` is an array, so a malformed answer still hands back `undefined` typed as `T[]`, which is
+ * the bug this whole family was built to end.
+ *
+ * `useApiFetchList` cannot serve them: it asks for a pagination ref, a `filterData` and a
+ * `filterConfig`, and these calls have none -- their filters are decided at the call site and are
+ * not the user's to change. So this is that helper with the pagination taken out: same core, same
+ * error mapping, same list-body check, and it answers with the items rather than the envelope.
+ *
+ * It writes no metadata. An endpoint whose paging the user drives is `useApiFetchList`; a list read
+ * page by page to the end is `useApiFetchListBatch`.
+ */
+export declare const useApiFetchItems: <T>(params: UseApiFetchItemsParams) => UseApiFetchItemsReturnType<T>;
+
+export declare type UseApiFetchItemsParams = {
+    client: AxiosClientFn;
+    system: string;
+    entity: string;
+    /**
+     * The url, query and all: whatever built the query has already run by the time it gets here.
+     *
+     * `urlParams` are substituted into the PATH only -- `/article/:id/routes?locale=:locale` fills in
+     * `:id` and sends `:locale` as it stands. This is the helper written for hand-made queries, so it
+     * is the one place someone would reach for a placeholder in the query; put the value in the query
+     * when building it, or pass it through `options.params` and let axios serialise it.
+     */
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    /** Anything axios takes except what this helper decides: the method, the url, the body and the signal. */
+    options?: Omit<AxiosRequestConfig, 'method' | 'url' | 'data' | 'signal'>;
+    cancelPrevious?: boolean;
 };
 
-declare type UseApiFetchByIdsReturnType<R> = {
-    executeFetch: (ids: DocId[] | IntegerId[], params?: FetchByIdsParams) => Promise<R>;
-    abortFetch: () => void;
+export declare type UseApiFetchItemsReturnType<T> = {
+    execute: (params?: FetchItemsParams) => Promise<T[]>;
+    abort: () => void;
+    /**
+     * True while this instance has a request in flight, false once the last one settles.
+     *
+     * It is here so a caller does not have to keep its own: the hand-rolled version is a ref cleared
+     * in a `finally`, and that `finally` belongs to whichever call ended -- including one that
+     * `cancelPrevious` just superseded, which turns the spinner off while the call the user is waiting
+     * for is still running. This one never dips between a superseded call and the one that replaced it.
+     */
+    loading: Ref<boolean>;
 };
 
-export declare const useApiFetchList: <R>(params: UseApiFetchListParams) => UseApiFetchListReturnType<R>;
+export declare const useApiFetchList: <T>(params: UseApiFetchListParams) => UseApiFetchListReturnType<T>;
 
-export declare const useApiFetchListBatch: <R>(params: UseApiFetchListBatchParams) => UseApiFetchListBatchReturnType<R>;
+export declare const useApiFetchListBatch: <T>(params: UseApiFetchListBatchParams) => UseApiFetchListBatchReturnType<T>;
 
-declare type UseApiFetchListBatchParams = {
+export declare type UseApiFetchListBatchParams = {
     client: AxiosClientFn;
     system: string;
     entity: string;
     urlTemplate?: string;
     urlParams?: UrlParams;
-    options?: AxiosRequestConfig;
-    silentConsoleError?: boolean;
+    /** Anything axios takes except what this helper decides: the method, the url, the body and the signal. */
+    options?: Omit<AxiosRequestConfig, 'method' | 'url' | 'data' | 'signal'>;
+    cancelPrevious?: boolean;
 };
 
-declare type UseApiFetchListBatchReturnType<R> = {
-    executeFetch: (filterData: FilterData<any>, filterConfig: FilterConfig<any>, params?: FetchListBatchParams) => Promise<R>;
-    abortFetch: () => void;
+export declare type UseApiFetchListBatchReturnType<T> = {
+    execute: (filterData: FilterData<any>, filterConfig: FilterConfig<any>, params?: FetchListBatchParams) => Promise<T[]>;
+    abort: () => void;
+    /**
+     * True while this instance has a request in flight, false once the last one settles.
+     *
+     * It is here so a caller does not have to keep its own: the hand-rolled version is a ref cleared
+     * in a `finally`, and that `finally` belongs to whichever call ended -- including one that
+     * `cancelPrevious` just superseded, which turns the spinner off while the call the user is waiting
+     * for is still running. This one never dips between a superseded call and the one that replaced it.
+     */
+    loading: Ref<boolean>;
 };
 
-declare type UseApiFetchListParams = {
+export declare type UseApiFetchListParams = {
     client: AxiosClientFn;
     system: string;
     entity: string;
     urlTemplate?: string;
     urlParams?: UrlParams;
-    options?: AxiosRequestConfig;
-    silentConsoleError?: boolean;
+    /** Anything axios takes except what this helper decides: the method, the url, the body and the signal. */
+    options?: Omit<AxiosRequestConfig, 'method' | 'url' | 'data' | 'signal'>;
+    cancelPrevious?: boolean;
 };
 
-declare type UseApiFetchListReturnType<R> = {
-    executeFetch: (pagination: Ref<Pagination>, filterData: FilterData<any>, filterConfig: FilterConfig<any>, params?: FetchListParams) => Promise<R>;
-    abortFetch: () => void;
+export declare type UseApiFetchListReturnType<T> = {
+    execute: (pagination: Ref<Pagination>, filterData: FilterData<any>, filterConfig: FilterConfig<any>, params?: FetchListParams) => Promise<T[]>;
+    abort: () => void;
+    /**
+     * True while this instance has a request in flight, false once the last one settles.
+     *
+     * It is here so a caller does not have to keep its own: the hand-rolled version is a ref cleared
+     * in a `finally`, and that `finally` belongs to whichever call ended -- including one that
+     * `cancelPrevious` just superseded, which turns the spinner off while the call the user is waiting
+     * for is still running. This one never dips between a superseded call and the one that replaced it.
+     */
+    loading: Ref<boolean>;
 };
 
 /**
@@ -2273,17 +2713,54 @@ export declare function useApiQueryBuilder(): {
     q: Ref<string[], string[]>;
 };
 
-export declare const useApiRequest: <R, T = R>(params: UseApiRequestParams) => UseApiAnyRequestReturnType<R, T>;
+/**
+ * A request to an endpoint that always answers with a body.
+ *
+ * A response without one is the endpoint breaking its own contract, not an empty answer, so it fails
+ * like any other error rather than handing back a value the declared type does not admit. An
+ * endpoint that answers nothing is `useApiCommand`; one that may answer either is `optionalBody`.
+ *
+ * `R` excludes `null`, `undefined` and `void` on purpose: those are ways of saying "no body", and a
+ * caller saying that has chosen the wrong helper. It is also what makes the migration visible --
+ * every `useApiRequest<void, …>` in the fleet stops compiling and names itself.
+ */
+export declare function useApiRequest<R extends NonNullable<unknown>, B = never>(params: UseApiRequestParams & {
+    optionalBody?: false;
+}): UseApiRequestReturnType<R, B>;
+
+/**
+ * The same, for an endpoint where a body is optional and its absence is a legitimate answer. The
+ * caller narrows, which is the point -- use it only where the endpoint really is documented that way.
+ */
+export declare function useApiRequest<R extends NonNullable<unknown>, B = never>(params: UseApiRequestParams & {
+    optionalBody: true;
+}): UseApiRequestReturnType<R | undefined, B>;
 
-declare type UseApiRequestParams = {
+export declare type UseApiRequestParams = {
     client: AxiosClientFn;
     method: Method;
     system: string;
     entity: string;
     urlTemplate?: string;
     urlParams?: UrlParams;
-    options?: AxiosRequestConfig;
-    silentConsoleError?: boolean;
+    /** Anything axios takes except what this helper decides: the method, the url, the body and the signal. */
+    options?: Omit<AxiosRequestConfig, 'method' | 'url' | 'data' | 'signal'>;
+    /** Each call supersedes the one before it -- the autocomplete shape. */
+    cancelPrevious?: boolean;
+};
+
+export declare type UseApiRequestReturnType<R, B> = {
+    execute: (params?: ExecuteRequestParams<B>) => Promise<R>;
+    abort: () => void;
+    /**
+     * True while this instance has a request in flight, false once the last one settles.
+     *
+     * It is here so a caller does not have to keep its own: the hand-rolled version is a ref cleared
+     * in a `finally`, and that `finally` belongs to whichever call ended -- including one that
+     * `cancelPrevious` just superseded, which turns the spinner off while the call the user is waiting
+     * for is still running. This one never dips between a superseded call and the one that replaced it.
+     */
+    loading: Ref<boolean>;
 };
 
 declare type UseCachedType = () => {
@@ -2292,6 +2769,15 @@ declare type UseCachedType = () => {
     addManualMinimal: any;
 };
 
+export declare const useFetchLog: ({ client, system, logPaths, type }: LogApiParams) => UseApiRequestReturnType<Log, null>;
+
+/**
+ * The backend and the endpoint both come from the caller, so these cannot be hoisted the way an
+ * entity fetcher is -- every mount builds its own, which is also what gives each one its own
+ * abort controller set.
+ */
+export declare const useFetchLogList: ({ client, system, logPaths, type }: LogApiParams) => UseApiFetchListReturnType<Log>;
+
 export declare function useFilterHelpers<F extends readonly MakeFilterOption<string>[] = readonly MakeFilterOption<string>[]>(filterData: FilterData<F>, filterConfig: FilterConfig<F>, moreOptions?: Partial<FilterHelpersMoreOptions>): {
     loadStoredFilters: (pagination: Ref<Pagination>, callback?: AnyFn) => boolean;
     resetFilter: (pagination: Ref<Pagination>, callback?: AnyFn) => void;
@@ -2323,10 +2809,10 @@ export declare function useFilterHelpers<F extends readonly MakeFilterOption<str
 export declare function useGuardedDelete<A extends unknown[], R>(guard: Pick<UseUnsavedChangesGuardApi, 'acknowledge' | 'unacknowledge'>, onDelete: (...args: A) => R): (...args: A) => R | Promise<Awaited<R>>;
 
 export declare function useJobApi<JobType extends JobBase = JobBase>(client: () => AxiosInstance, system: string): {
-    useFetchJobList: () => UseApiFetchListReturnType<JobType[]>;
+    useFetchJobList: () => UseApiFetchListReturnType<JobType>;
     fetchJob: (id: number) => Promise<JobType>;
     createJob: (data: JobType) => Promise<JobType>;
-    deleteJob: (id: number) => Promise<JobType>;
+    deleteJob: (id: number) => Promise<void>;
 };
 
 /**
@@ -2398,6 +2884,147 @@ export declare interface UseListEditorOptions {
  */
 export declare function useListEditorStateEntry<TItem extends Record<string, any>>(stateKey: string | undefined, bindings: ListEditorStateBindings<TItem>): ListEditorStateEntry<ListEditorHandle<TItem>> | null;
 
+export declare function useLogDetailActions(params: LogActionsParams): {
+    log: Ref<{
+        id: string;
+        message: string;
+        datetime: DatetimeUTC;
+        levelName: LogLevelType;
+        context: {
+            appVersion: string;
+            appSystem: string;
+            requestOriginAppVersion: string;
+            path: string;
+            method: string;
+            contextId: string;
+            userId: IntegerIdNullable;
+            resourceName: string;
+            resourceIds: string[];
+            ip: string;
+            response: string;
+            content?: string | undefined;
+            params: string;
+            httpStatus: number;
+        };
+        _resourceName: string;
+        _system: string;
+        _type: string;
+    } | null, Log | {
+        id: string;
+        message: string;
+        datetime: DatetimeUTC;
+        levelName: LogLevelType;
+        context: {
+            appVersion: string;
+            appSystem: string;
+            requestOriginAppVersion: string;
+            path: string;
+            method: string;
+            contextId: string;
+            userId: IntegerIdNullable;
+            resourceName: string;
+            resourceIds: string[];
+            ip: string;
+            response: string;
+            content?: string | undefined;
+            params: string;
+            httpStatus: number;
+        };
+        _resourceName: string;
+        _system: string;
+        _type: string;
+    } | null>;
+    detailLoading: Ref<boolean, boolean>;
+    fetchData: (id: string) => Promise<void>;
+    cancel: () => void;
+};
+
+export declare function useLogFilter(system: string, window: LogTimeWindow | undefined): LogFilter;
+
+/**
+ * Everything here is per instance, unlike the module-level refs the admins used to keep: the
+ * views are remounted on every system/type change, and a `finally` belonging to the instance
+ * that just went away would otherwise clear the new one's loading flag.
+ */
+export declare function useLogListActions(params: LogActionsParams): {
+    listItems: Ref<{
+        id: string;
+        message: string;
+        datetime: DatetimeUTC;
+        levelName: LogLevelType;
+        context: {
+            appVersion: string;
+            appSystem: string;
+            requestOriginAppVersion: string;
+            path: string;
+            method: string;
+            contextId: string;
+            userId: IntegerIdNullable;
+            resourceName: string;
+            resourceIds: string[];
+            ip: string;
+            response: string;
+            content?: string | undefined;
+            params: string;
+            httpStatus: number;
+        };
+        _resourceName: string;
+        _system: string;
+        _type: string;
+    }[], Log[] | {
+        id: string;
+        message: string;
+        datetime: DatetimeUTC;
+        levelName: LogLevelType;
+        context: {
+            appVersion: string;
+            appSystem: string;
+            requestOriginAppVersion: string;
+            path: string;
+            method: string;
+            contextId: string;
+            userId: IntegerIdNullable;
+            resourceName: string;
+            resourceIds: string[];
+            ip: string;
+            response: string;
+            content?: string | undefined;
+            params: string;
+            httpStatus: number;
+        };
+        _resourceName: string;
+        _system: string;
+        _type: string;
+    }[]>;
+    listLoading: Ref<boolean, boolean>;
+    datatableHiddenColumns: Ref<string[], string[]>;
+    fetchList: (pagination: Ref<Pagination>, filterData: FilterData<any>, filterConfig: FilterConfig<any>) => Promise<void>;
+    cancel: () => void;
+};
+
+export declare function useLogType(): {
+    logTypeOptions: Ref<{
+        value: LogTypeType;
+        title: string;
+        color?: string | undefined;
+        active?: false | undefined;
+        subtitle?: string | undefined;
+    }[], ValueObjectOption<LogTypeType>[] | {
+        value: LogTypeType;
+        title: string;
+        color?: string | undefined;
+        active?: false | undefined;
+        subtitle?: string | undefined;
+    }[]>;
+    getLogTypeOption: (value: LogTypeType) => {
+        value: LogTypeType;
+        title: string;
+        color?: string | undefined;
+        active?: false | undefined;
+        subtitle?: string | undefined;
+    } | undefined;
+};
+
 /**
  * Nested list editor core. Pure data behavior shared by ANestedSortableListEditor.
  * Works on a tree of `{ data, children, meta }` nodes — shape-compatible with the
@@ -2553,7 +3180,7 @@ export declare const UserAdminConfigTypeDefault: "pinnedWidgets";
 
 export declare type UserAdminConfigTypeType = (typeof UserAdminConfigType)[keyof typeof UserAdminConfigType];
 
-export declare function useSubjectSelect<TItem>(datatableConfig: any, datatableHiddenColumns: any, system: string, subject: string, executeFetch: (pagination: Ref<Pagination>, filterData: FilterData<any>, filterConfig: FilterConfig<any>, params?: FetchListParams) => Promise<TItem[]>, filterData: FilterData<any>, filterConfig: FilterConfig<any>, filterSortBy?: DatatableSortBy | null, fetchParams?: FetchListParams | undefined, enableActions?: boolean): {
+export declare function useSubjectSelect<TItem>(datatableConfig: any, datatableHiddenColumns: any, system: string, subject: string, execute: (pagination: Ref<Pagination>, filterData: FilterData<any>, filterConfig: FilterConfig<any>, params?: FetchListParams) => Promise<TItem[]>, filterData: FilterData<any>, filterConfig: FilterConfig<any>, filterSortBy?: DatatableSortBy | null, fetchParams?: FetchListParams | undefined, enableActions?: boolean): {
     items: Ref<TItem[], TItem[]>;
     selected: Ref<TItem[], TItem[]>;
     pagination: Ref<Pagination, Pagination>;
@@ -2667,11 +3294,11 @@ declare interface UseUnsavedChangesGuardOptions {
 export declare function useUnsavedSection(source: UnsavedSectionSource): void;
 
 export declare function useUserAdminConfigApi(client: () => AxiosInstance, system: string, entity?: string, endPoint?: string): {
-    useFetchUserAdminConfigList: () => UseApiFetchListReturnType<UserAdminConfig< UserAdminConfigDataFilterBookmark | UserAdminConfigDataPinnedWidgets<string>>[]>;
+    useFetchUserAdminConfigList: () => UseApiFetchListReturnType<UserAdminConfig< UserAdminConfigDataFilterBookmark | UserAdminConfigDataPinnedWidgets<string>>>;
     fetchUserAdminConfig: (id: IntegerId) => Promise<UserAdminConfig< UserAdminConfigDataFilterBookmark | UserAdminConfigDataPinnedWidgets<string>>>;
     createUserAdminConfig: (data: UserAdminConfig) => Promise<UserAdminConfig< UserAdminConfigDataFilterBookmark | UserAdminConfigDataPinnedWidgets<string>>>;
     updateUserAdminConfig: (id: IntegerId, data: UserAdminConfig) => Promise<UserAdminConfig< UserAdminConfigDataFilterBookmark | UserAdminConfigDataPinnedWidgets<string>>>;
-    deleteUserAdminConfig: (id: IntegerId) => Promise<unknown>;
+    deleteUserAdminConfig: (id: IntegerId) => Promise<void>;
     updateUserAdminConfigPositions: (ids: IntegerId[]) => Promise<{
         userAdminConfigs: IntegerId[];
     }>;
@@ -2699,20 +3326,10 @@ declare interface ViewBodySlotProps<TItem extends Record<string, any>> {
 
 export { }
 
-declare global {
-    interface Window {
-        Sentry?: {
-            captureException(error: Error, context?: Record<string, any>): void;
-            captureMessage(message: string, context?: Record<string, any>): void;
-            setTag(key: string, value: string): void;
-            setUser(user: {
-                id: string;
-                email?: string;
-                username?: string;
-            }): void;
-            [key: string]: any;
-        };
-    }
+
+
+declare module 'vue-i18n' {
+  export interface DefineLocaleMessage extends MessageSchema {}
 }