@saasicat/ui-vue 0.24.2 → 0.26.0

package/dist/client/index.d.ts

@@ -1,19 +1,406 @@
-import { H as HttpClient, K as KvStore, S as SaLocale, w as SaNavMessages } from '../catalog-DJcfm5N2.js';
-export { f as ActionDefNotInManifestError, A as ActionHandler, e as ActionRegistry, D as DEFAULT_SA_LOCALE, g as HttpResponse, M as MessageTree, h as MissingHandlerError, P as PartialMessages, R as ResolvedAction, i as SA_INTL_LOCALES, j as SA_LOCALES, k as SA_LOCALE_LABELS, l as SA_MESSAGES, m as SaBuiltinLocale, n as SaCatalog, o as SaCatalogOptions, c as SaLocaleDefinition, b as SaLocaleOption, a as SaMessages, d as SaMessagesOverrides, T as TranslationOf, p as createSaCatalog, q as defaultHttpClient, r as defaultKvStore, s as defineMessages, t as isSaBuiltinLocale, u as mergeMessages, v as resolveMessages } from '../catalog-DJcfm5N2.js';
+import { H as HttpClient, a as SaMessages, K as KvStore, S as SaLocale, a9 as SaNavMessages } from '../catalog-Dch1Ryw0.js';
+export { i as ActionDefNotInManifestError, A as ActionHandler, h as ActionRegistry, j as AuditListFilter, B as Bound, D as DEFAULT_SA_LOCALE, k as DefineResourceOptions, l as HttpResponse, L as LIST_FIRST_PAGE, m as LIST_PAGE_SIZE_DEFAULT, n as LIST_PAGE_SIZE_MAX, o as LIST_PAGINATION_PARAMS, q as ListFilterOf, r as ListOp, s as ListQuery, M as MessageTree, t as MissingHandlerError, u as PartialMessages, P as PlatformResources, v as PublishPlanVersionOptions, w as ResolvedAction, f as ResourceContext, R as ResourceDef, g as ResourceListPage, x as ResourceOp, e as ResourceOps, y as SA_INTL_LOCALES, z as SA_LOCALES, C as SA_LOCALE_LABELS, E as SA_MESSAGES, F as SaBuiltinLocale, G as SaCatalog, I as SaCatalogOptions, c as SaLocaleDefinition, b as SaLocaleOption, d as SaMessagesOverrides, T as TenantsListFilter, J as TranslationOf, N as auditResource, O as bindResource, Q as clampListPage, U as clampListPageSize, V as createSaCatalog, W as defaultHttpClient, X as defaultKvStore, Y as defineListOp, Z as defineMessages, _ as defineResource, $ as filterQueryString, a0 as isSaBuiltinLocale, a1 as isSentInQuery, a2 as listUrl, a3 as mergeMessages, a4 as planVersionsResource, a5 as plansResource, p as platformResources, a6 as readListPage, a7 as resolveMessages, a8 as tenantsResource } from '../catalog-Dch1Ryw0.js';
 import { PublicBootResponse, AdminManifest, StandardPageKey, TenantColumnDef, PromoCodeRecord, AdminTenantDetail, AdminUserListFilter, AdminUserListRow, AdminAuditListFilter, AuditEntry, AdminSubscriptionListRow } from '@saasicat/types';
 
 declare const ADMIN_UI_VERSION = "1.2.0";
 
+interface FetchHttpClientOptions {
+    /**
+     * Prefix for relative URLs, e.g. `'https://api.example.com'`. Absolute
+     * URLs are passed through untouched.
+     *
+     * Note that an app configures its API prefix twice if it also passes a
+     * fully-qualified `apiBase` to the shell — the two would concatenate. Pick
+     * one; a doubled prefix 404s on the first request rather than degrading
+     * quietly, which is the reason this does not try to detect it.
+     */
+    baseUrl?: string;
+    /**
+     * Headers to add to every request, read per request so a token that
+     * changes between calls is picked up without rebuilding the client. May
+     * return a promise for a token that has to be refreshed first.
+     *
+     * Headers passed by the caller win, so a request that sets its own
+     * `Content-Type` keeps it.
+     */
+    headers?: () => Record<string, string> | Promise<Record<string, string>>;
+}
+/**
+ * Builds an `HttpClient` over `fetch`.
+ *
+ * With no options it is a bare passthrough plus an `Accept: application/json`
+ * header — the platform speaks JSON everywhere, and saying so is what stops a
+ * content-negotiating gateway from answering with HTML.
+ */
+declare function createFetchHttpClient(options?: FetchHttpClientOptions): HttpClient;
+
+/**
+ * The part of the merged request config axios echoes back on every response —
+ * on the one it resolves with and on the one it attaches to a rejection. These
+ * three fields say whether `data` is a decoded value or the body as it arrived,
+ * for as long as axios's own response transform is the one that produced it;
+ * see `bodyIsRaw`.
+ *
+ * They are `unknown` rather than their axios types so that a real
+ * `AxiosResponse` stays structurally assignable without this package taking a
+ * dependency on axios to name them.
+ */
+interface AxiosLikeResponseConfig {
+    transformResponse?: unknown;
+    responseType?: unknown;
+    transitional?: unknown;
+}
+interface AxiosLikeResponse {
+    status: number;
+    data: unknown;
+    headers: unknown;
+    config?: AxiosLikeResponseConfig;
+}
+interface AxiosLikeConfig {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    data?: unknown;
+}
+/** The part of an axios instance this adapter uses. */
+interface AxiosLike {
+    request(config: AxiosLikeConfig): Promise<AxiosLikeResponse>;
+}
+/**
+ * What an instance leaves in `response.data`, for the one case the response
+ * cannot describe: an instance that replaced `transformResponse` with a
+ * non-empty pipeline of its own.
+ *
+ * - `'auto'` — read it off the config axios echoes on the response. Correct for
+ *   an instance that still runs axios's own transform, and for every way of
+ *   switching that transform's parsing off: `responseType: 'text'`,
+ *   `transitional: { forcedJSONParsing: false }`, and a `transformResponse`
+ *   that runs nothing (`[]` or `null`).
+ * - `'raw'` — `data` is the body as it arrived, and `json()` parses it.
+ * - `'decoded'` — `data` is a value the pipeline already produced, and `json()`
+ *   hands it over untouched.
+ */
+type AxiosResponseBody = 'auto' | 'raw' | 'decoded';
+interface AxiosHttpClientOptions {
+    /**
+     * Prefix(es) to remove from the start of a URL before handing it to the
+     * instance, for the usual case where the instance already carries them as
+     * its `baseURL`. Tried in order, first match wins — so list the longest
+     * first (`['/api/v1', '/api']`), or `/api/v1/admin/x` loses only `/api`.
+     */
+    stripPrefix?: string | readonly string[];
+    /**
+     * How this instance hands the body over. Defaults to `'auto'`, which needs
+     * no configuration and is right for every instance that leaves axios's own
+     * `transformResponse` in place.
+     *
+     * Set it only if you replaced `transformResponse` with a non-empty pipeline
+     * of your own: `'raw'` if that pipeline hands the body over as it arrived
+     * (`[(data) => data]`), `'decoded'` if it parses. The response cannot be
+     * read for the answer — both echo one opaque function — so `'auto'` would
+     * take your pipeline for axios's; see `bodyIsRaw`.
+     *
+     * The declaration is read before anything else, an empty `data` included:
+     * under `'decoded'` an empty `data` is the empty string the pipeline
+     * produced, and `json()` hands it over; under `'raw'` it is an empty body,
+     * and `json()` throws the way `Response.json()` does.
+     */
+    responseBody?: AxiosResponseBody;
+}
+/**
+ * Adapts an axios instance to `HttpClient`.
+ *
+ * Two decisions are worth knowing about, because five of the six shims this
+ * replaces made them differently:
+ *
+ * **No status throws — but the instance still decides.** A 402, a 404 and a
+ * 500 all arrive as responses, because the platform reads statuses itself (a
+ * 304 is a cache hit, a 402 carries a limit payload) and can only do that for
+ * statuses it is handed. That is achieved by adapting the rejection rather
+ * than by overriding `validateStatus`: an override would make axios resolve
+ * everything, and a config that never rejects makes the **rejection half of
+ * the instance's own response interceptors unreachable** — the conventional
+ * place a consumer puts token refresh and retry. Their session would expire
+ * silently instead of refreshing.
+ *
+ * **`json()` decodes only what axios left undecoded.** Which of the two it is
+ * cannot be guessed from the value. The response says it for every instance
+ * that still runs axios's own `transformResponse`; an instance that replaced it
+ * says it with the `responseBody` option, because at that point the response no
+ * longer can. See `bodyIsRaw`.
+ *
+ * Nothing here overrides the instance's own configuration — not
+ * `validateStatus`, and not `transformResponse` either. Forcing the transform
+ * off would make the answer knowable, at the price of handing the consumer's
+ * own response interceptors a string where they had an object.
+ */
+declare function createAxiosHttpClient(instance: AxiosLike, options?: AxiosHttpClientOptions): HttpClient;
+
+interface ResourceRequestInit {
+    /** Default `GET`. */
+    method?: string;
+    /** Serialised here — the `HttpClient` contract only carries strings. */
+    body?: unknown;
+    /** Merged over the defaults, so a caller's header wins. */
+    headers?: Record<string, string>;
+}
+/**
+ * Sends a request and returns the parsed body, or `null` when there was none.
+ *
+ * `null` covers both a `204` and a 2xx whose body would not parse. The two are
+ * deliberately not distinguished: every caller treats them the same way — a
+ * list turns `null` into `[]`, a mutation turns it into a failure — and no
+ * endpoint in this family answers a mutation with an empty 200 on purpose.
+ *
+ * A non-2xx throws an `AdminError` carrying the parsed body, so a caller can
+ * still branch on `status` and `body.code` the way the pages do today.
+ *
+ * A client that resolved without an HTTP status throws before any of that: no
+ * status means the request never reached the server, which is a transport
+ * failure and not an answer this function may read.
+ */
+declare function requestJson<T>(http: HttpClient, url: string, init?: ResourceRequestInit): Promise<T | null>;
+/**
+ * Reads the body of a request that must answer with one.
+ *
+ * The empty case is a failure rather than a `null` the caller has to re-check:
+ * a create that returns nothing has not told us what it created. Raised with
+ * `status: 0`, because no HTTP status went wrong — the response was a 2xx.
+ */
+declare function requestJsonBody<T>(http: HttpClient, url: string, what: string, init?: ResourceRequestInit): Promise<T>;
+
+/**
+ * Marks an error as one this package raised. Called by the package's own error
+ * classes in their constructors; nothing else should call it.
+ */
+declare function markPlatformError(error: Error): void;
+/** Whether an error came from this package, across bundle copies. */
+declare function isPlatformError(value: unknown): boolean;
+/**
+ * Marks an error as the empty-body sentinel: the call reached the server, the
+ * server answered, and the body the caller needed was not in it. Returns the
+ * error so a throw site stays one expression.
+ *
+ * Called at those throw sites only — never in a constructor, because the class
+ * is also raised for calls that failed outright.
+ */
+declare function markEmptyResponse<E extends Error>(error: E): E;
+/** Whether an error is that sentinel, across bundle copies. */
+declare function isEmptyResponse(value: unknown): boolean;
 /**
- * Error for non-2xx responses. `code` is the machine-readable error code
- * from the JSON body (`{ code }`), if present — callers map it to
- * a message (e.g. via `SETUP_ERROR_CODES`).
+ * Marks an error as one the request did not survive: no connection, DNS
+ * failure, CORS rejection, abort, or a client that reported the same by
+ * resolving without an HTTP status. Returns the error so a throw site stays one
+ * expression.
  */
-declare class HttpJsonError extends Error {
+declare function markTransportFailure<E>(error: E): E;
+/** Whether an error is a declared transport failure, across bundle copies. */
+declare function isTransportFailure(value: unknown): boolean;
+interface AdminErrorInit {
+    /** HTTP status. `0` means the request never produced one. */
+    status?: number;
+    /** Machine-readable code from the response body (`{ code }`). */
+    code?: string;
+    /** Parsed response body, when there was one. */
+    body?: unknown;
+    /** Requested URL, when known. */
+    url?: string;
+    /** Request method, when known. */
+    method?: string;
+    /**
+     * Text the failing side supplied. Never invent one — its absence is the
+     * signal that only a translated fallback can be shown.
+     */
+    detail?: string;
+    /**
+     * The request completed and the answer was unusable — a 2xx that carried
+     * no body where one was required.
+     *
+     * Its own state because the model could not otherwise tell it from a
+     * transport failure: both have no HTTP status to report, and both were
+     * therefore `status: 0`. They need opposite words. A request that never
+     * left says "check your connection"; one the server accepted and answered
+     * with nothing says "check whether the change was applied", because it may
+     * well have been.
+     */
+    emptyResponse?: boolean;
+    /**
+     * The request never reached the server.
+     *
+     * Its own state for the same reason as `emptyResponse`: neither has an HTTP
+     * status to reason from, so a status of `0` cannot tell them apart — and
+     * neither can it tell either of them from an error that simply carries no
+     * status, such as a bug in page code. Only the seam that made the request
+     * knows, and it says so with `markTransportFailure`.
+     */
+    transportFailure?: boolean;
+    /** Diagnostic message. Derived from the fields above when omitted. */
+    message?: string;
+    /** The error this one was built from. */
+    cause?: unknown;
+}
+/** A failed admin API call, in the one shape the package works with. */
+declare class AdminError extends Error {
+    /** HTTP status. `0` means the request never produced one. */
     readonly status: number;
-    readonly code?: string | undefined;
-    constructor(status: number, code?: string | undefined);
+    /** Machine-readable code from the response body, when it carried one. */
+    readonly code?: string;
+    /** Parsed response body, when there was one. */
+    readonly body?: unknown;
+    /** Requested URL, when known. */
+    readonly url?: string;
+    /** Request method, when known. */
+    readonly method?: string;
+    /**
+     * Text the failing side supplied — the only candidate for user-facing
+     * output. `undefined` when nothing was supplied.
+     */
+    readonly detail?: string;
+    /** The request completed but the answer was unusable. See `AdminErrorInit`. */
+    readonly emptyResponse: boolean;
+    /** The request never reached the server. See `AdminErrorInit`. */
+    readonly transportFailure: boolean;
+    constructor(init?: AdminErrorInit);
 }
+/** Whether `err` is an `AdminError`, including one from another bundle copy. */
+declare function isAdminError(err: unknown): err is AdminError;
+/**
+ * Whether an error is axios saying, in its own words, that the request was made
+ * and no response ever arrived.
+ *
+ * This is the one transport failure read rather than branded, because a library
+ * cannot be asked to mark itself. What it reads is axios's own three-way split,
+ * documented under "Handling errors" in its README and visible in the
+ * `AxiosError` constructor: `response` is set only when the server answered,
+ * `request` only once one was actually made, and an error with neither happened
+ * while the request was still being set up.
+ *
+ * Measured against axios 1.18.1 driven at a real `node:http` server, and the
+ * groups came out disjoint:
+ *
+ * | rejection                                       | `isAxiosError` | `request` | `response` |
+ * | ----------------------------------------------- | -------------- | --------- | ---------- |
+ * | connection refused / reset, DNS, timeout, abort  | `true`         | yes       | no         |
+ * | the same, rethrown by a rejection interceptor    | `true`         | yes       | no         |
+ * | a 401 or 500 the server really sent              | `true`         | yes       | yes        |
+ * | interceptor rejects with `new Error(…)`          | absent         | no        | no         |
+ * | …the same, but copying `error.config` across     | absent         | no        | no         |
+ * | …the same, copying `config` and `request`        | absent         | yes       | no         |
+ * | unsupported protocol, signal aborted before call | `true`         | no        | no         |
+ * | request interceptor throws, malformed URL        | absent         | no        | no         |
+ *
+ * Three readings follow from that table, and only the first is free of choice:
+ *
+ * - `response` present means the server answered, whatever else is set.
+ * - `request` present without it is axios's "made, nothing came back". The
+ *   browser and `fetch` adapters attach it too — an `XMLHttpRequest` and a
+ *   `Request` respectively — so the reading is not Node-only.
+ * - Requiring `isAxiosError` on top of that is the decision. It removes the
+ *   ordinary interceptor that copies `config` and `request` onto a hand-built
+ *   `new Error`, which is shape-wise axios's no-response form after the server
+ *   had answered.
+ *
+ * The previous reading was `config` without `response`, which is not axios's
+ * statement about anything: `config` is echoed on every axios error including
+ * the ones carrying a 401, and it is the field an interceptor is most likely to
+ * carry over when it replaces the rejection. It matched three rows above that
+ * mean the opposite of a transport failure.
+ *
+ * ## What this cannot decide, and which way it errs
+ *
+ * This is read *after* the consumer's interceptors have run — after the one
+ * place that can set or delete any field on the rejection. Both readings are
+ * therefore forgeable, in both directions, and each was reproduced:
+ *
+ * - An interceptor that **drops** `request` — `AxiosError.from(err, code,
+ *   config)` without its fourth argument, `err.toJSON()`, or a `delete
+ *   err.request` before logging — leaves a genuine `ECONNREFUSED` unbranded.
+ *   The operator then reads `connect ECONNREFUSED 127.0.0.1:44947` instead of
+ *   the localized sentence.
+ * - An interceptor that **builds** one — `AxiosError.from(msg, code,
+ *   error.config, error.request)` after an answered 401 — is branded. Nothing
+ *   distinguishes it: `AxiosError.from` is public API, so `isAxiosError` is
+ *   available to user code as well.
+ *
+ * Neither is closable by a better predicate; the fields simply do not carry the
+ * fact by then. So the reading errs deliberately toward *not* branding, because
+ * the two mistakes do not cost the same: an unbranded transport failure shows a
+ * true sentence in the wrong register, while a branded application failure tells
+ * the operator to check a connection that is fine. Saying less beats saying
+ * something false.
+ *
+ * An interceptor that rewrites rejections should say what it means with
+ * `markTransportFailure`, which is exported for exactly this. It is checked
+ * first and settles the case.
+ */
+declare function isAxiosNoResponseError(value: unknown): boolean;
+/**
+ * Reads the human-readable message out of a response body.
+ *
+ * Covers the two shapes the platform and its host produce: a coded platform
+ * error (`{ code, message }`) carries a string, while a NestJS
+ * `ValidationPipe` rejection carries `message: string[]` — one entry per
+ * failed constraint. Joining them is what keeps a validation error readable
+ * instead of rendering as `[object Object]`.
+ *
+ * Exported because every place that builds an `AdminError` from a response
+ * needs the same answer. It had two implementations for one release and they
+ * disagreed: the one in `http-json.ts` accepted only a string, so a validation
+ * rejection arriving through `getJson`/`postJson` lost its constraints
+ * entirely and the operator was shown the generic fallback.
+ */
+declare function readErrorDetail(body: unknown): string | undefined;
+/** Reads the machine-readable code out of a response body, if it carries one. */
+declare function readErrorCode(body: unknown): string | undefined;
+/**
+ * Turns anything that was caught into an `AdminError`.
+ *
+ * Recognises, in order: an `AdminError` (from any bundle copy), an axios-style
+ * rejection, an error carrying a numeric `status` — which is every one of the
+ * package's own `*ApiError` classes — and finally any `Error`, string or
+ * unknown value.
+ */
+declare function toAdminError(err: unknown): AdminError;
+/**
+ * Turns anything that was caught into text for a user.
+ *
+ * What the failing side said outranks anything this package could guess, so a
+ * `detail` wins whenever there is one. After that come the two facts a seam
+ * declared about a request with no HTTP status — they need opposite sentences
+ * and no number can tell them apart — and only then the status.
+ *
+ * The last line is the honest one. An error with no status, no text and no
+ * declaration is an error nothing knows anything about; "check your connection"
+ * used to be the answer, and it sent an operator after their router for a null
+ * dereference in a page. Whoever knows better says so with
+ * `markTransportFailure` or `markEmptyResponse`.
+ *
+ * Pages do not call this — `useAsyncAction` and the error banner do.
+ */
+declare function adminErrorMessage(err: unknown, msgs: SaMessages['errors']): string;
+
+/**
+ * Fails, at the seam that can still tell, when the client resolved without an
+ * HTTP status: the request never reached the server.
+ *
+ * Every caller below then knows that an absent body means the server answered
+ * without one, which is the precondition the empty-response sentinel needs and
+ * did not have — `if (!data)` was true for both facts, and the mutation
+ * sentinel told the operator of a request that never left the machine to go
+ * check whether their change had been applied.
+ *
+ * `raise` builds the error class of the calling seam from the diagnostic, so
+ * the caught error keeps saying which API it came from.
+ */
+declare function requireServerAnswer(status: number, method: string, url: string, raise: (diagnostic: string) => Error): void;
+/**
+ * @deprecated Renamed to {@link AdminError}, which is the same class: an
+ * `instanceof HttpJsonError` check keeps working and now also matches errors
+ * raised elsewhere in the package. Construction changed — `AdminError` takes
+ * one options object instead of `(status, code)`.
+ */
+declare const HttpJsonError: typeof AdminError;
+type HttpJsonError = AdminError;
 /**
  * Removes trailing slashes so an API prefix can be concatenated with paths
  * that start with `/`. Deliberately index-based instead of
@@ -65,6 +452,11 @@ interface ManifestLoaderOptions {
      */
     getAuthToken?: () => string | null;
 }
+/**
+ * The manifest could not be loaded. Its `message` is a diagnostic for the log,
+ * never text for a screen — `markPlatformError` is what tells `toAdminError`
+ * so, and it is a promise this class has to keep at every throw site.
+ */
 declare class ManifestLoadError extends Error {
     readonly status: number;
     constructor(status: number, message: string);
@@ -84,8 +476,21 @@ declare class ManifestLoader {
     /**
      * Loads the current manifest. On a cache hit (304) the cached
      * body is returned — otherwise the fresh server body.
+     *
+     * A 304 with no usable cached body is not a failure to report but one to
+     * undo: the request only carried `If-None-Match` because this loader put
+     * the ETag there, and the cache it validated against is this loader's own.
+     * So it drops the pair and asks once more without the header, which is the
+     * same recovery a person would have had to trigger by hand — except that
+     * the person reading an admin screen has neither this loader nor a
+     * console. Exactly one retry: a 304 to a request that asked nothing
+     * conditional is a server fault, and no repetition fixes it.
      */
     load(): Promise<AdminManifest>;
+    /** Sends the manifest GET, conditional when an ETag is supplied. */
+    private request;
+    /** Takes a non-304 response as the current manifest and caches it. */
+    private acceptFresh;
     /** Reads the cached manifest body from storage; null if absent. */
     readCachedBody(): CachedManifestEntry | null;
     /** Clears the cache — e.g. on logout or after `manifest reload`. */
@@ -458,4 +863,4 @@ declare function identityAccentFor(key: string, overrides?: Readonly<Record<stri
  */
 declare function identityChipStyle(accent: string): Record<string, string>;
 
-export { ADMIN_UI_VERSION, type AdminPromoListFilter, type AdminPromoListRow, type AdminResourceClientOptions, type BatchColumnData, BatchColumnDriftError, BatchColumnFetcher, type BatchColumnFetcherOptions, type BatchColumnRow, type BatchColumnValue, BootLoadError, BootLoader, type BootLoaderOptions, type BuildRouteEntry, type CachedManifestEntry, DEFAULT_STANDARD_PAGE_ROUTES, HttpClient, HttpJsonError, IDENTITY_ACCENTS, IDENTITY_ACCENT_VALUES, IDENTITY_NEUTRAL, IDENTITY_NEUTRAL_VALUE, KvStore, type LoginBootProject, type LoginBrandFallback, type LoginBranding, ManifestLoadError, ManifestLoader, type ManifestLoaderOptions, type MessageParams, type NavBuilderOptions, type ParamStyle, type PlanCounts, type PlanRowLike, type PlanVersionLike, type ResolvePlansInput, type ResolvedPlan, SaLocale, type SidebarItem, type SidebarSection, buildRoutes, buildSidebar, countPlans, createAdminResourceClient, defaultSectionOrder, formatCurrency, formatMessage, getJson, identityAccentAt, identityAccentFor, identityChipStyle, isCurrentlyValid, isExpired, isFutureScheduled, isProductionBoot, postJson, resolveExtension, resolveLoginBranding, resolvePlans, todayIsoDate, trimTrailingSlashes };
+export { ADMIN_UI_VERSION, AdminError, type AdminErrorInit, type AdminPromoListFilter, type AdminPromoListRow, type AdminResourceClientOptions, type AxiosHttpClientOptions, type AxiosLike, type AxiosLikeConfig, type AxiosLikeResponse, type AxiosLikeResponseConfig, type AxiosResponseBody, type BatchColumnData, BatchColumnDriftError, BatchColumnFetcher, type BatchColumnFetcherOptions, type BatchColumnRow, type BatchColumnValue, BootLoadError, BootLoader, type BootLoaderOptions, type BuildRouteEntry, type CachedManifestEntry, DEFAULT_STANDARD_PAGE_ROUTES, type FetchHttpClientOptions, HttpClient, HttpJsonError, IDENTITY_ACCENTS, IDENTITY_ACCENT_VALUES, IDENTITY_NEUTRAL, IDENTITY_NEUTRAL_VALUE, KvStore, type LoginBootProject, type LoginBrandFallback, type LoginBranding, ManifestLoadError, ManifestLoader, type ManifestLoaderOptions, type MessageParams, type NavBuilderOptions, type ParamStyle, type PlanCounts, type PlanRowLike, type PlanVersionLike, type ResolvePlansInput, type ResolvedPlan, type ResourceRequestInit, SaLocale, SaMessages, type SidebarItem, type SidebarSection, adminErrorMessage, buildRoutes, buildSidebar, countPlans, createAdminResourceClient, createAxiosHttpClient, createFetchHttpClient, defaultSectionOrder, formatCurrency, formatMessage, getJson, identityAccentAt, identityAccentFor, identityChipStyle, isAdminError, isAxiosNoResponseError, isCurrentlyValid, isEmptyResponse, isExpired, isFutureScheduled, isPlatformError, isProductionBoot, isTransportFailure, markEmptyResponse, markPlatformError, markTransportFailure, postJson, readErrorCode, readErrorDetail, requestJson, requestJsonBody, requireServerAnswer, resolveExtension, resolveLoginBranding, resolvePlans, toAdminError, todayIsoDate, trimTrailingSlashes };

package/dist/client/index.js

@@ -4,23 +4,18 @@ import {
   ActionRegistry,
   BatchColumnDriftError,
   BatchColumnFetcher,
-  BootLoadError,
-  BootLoader,
   DEFAULT_STANDARD_PAGE_ROUTES,
-  HttpJsonError,
   IDENTITY_ACCENTS,
   IDENTITY_ACCENT_VALUES,
   IDENTITY_NEUTRAL,
   IDENTITY_NEUTRAL_VALUE,
-  ManifestLoadError,
-  ManifestLoader,
   MissingHandlerError,
   buildRoutes,
   buildSidebar,
   countPlans,
   createAdminResourceClient,
+  createAxiosHttpClient,
   defaultSectionOrder,
-  getJson,
   identityAccentAt,
   identityAccentFor,
   identityChipStyle,
@@ -28,33 +23,75 @@ import {
   isExpired,
   isFutureScheduled,
   isProductionBoot,
-  postJson,
   resolveExtension,
   resolveLoginBranding,
   resolvePlans,
-  todayIsoDate,
-  trimTrailingSlashes
-} from "../chunk-D74FFCCP.js";
+  todayIsoDate
+} from "../chunk-NEXTZZRQ.js";
 import {
+  AdminError,
+  BootLoadError,
+  BootLoader,
   DEFAULT_SA_LOCALE,
+  HttpJsonError,
+  LIST_FIRST_PAGE,
+  LIST_PAGE_SIZE_DEFAULT,
+  LIST_PAGE_SIZE_MAX,
+  LIST_PAGINATION_PARAMS,
+  ManifestLoadError,
+  ManifestLoader,
   SA_INTL_LOCALES,
   SA_LOCALES,
   SA_LOCALE_LABELS,
   SA_MESSAGES,
+  adminErrorMessage,
+  auditResource,
+  bindResource,
+  clampListPage,
+  clampListPageSize,
+  createFetchHttpClient,
   createSaCatalog,
   defaultHttpClient,
   defaultKvStore,
+  defineListOp,
   defineMessages,
+  defineResource,
+  filterQueryString,
   formatCurrency,
   formatMessage,
+  getJson,
+  isAdminError,
+  isAxiosNoResponseError,
+  isEmptyResponse,
+  isPlatformError,
   isSaBuiltinLocale,
+  isSentInQuery,
+  isTransportFailure,
+  listUrl,
+  markEmptyResponse,
+  markPlatformError,
+  markTransportFailure,
   mergeMessages,
-  resolveMessages
-} from "../chunk-F7NRM6KI.js";
+  planVersionsResource,
+  plansResource,
+  platformResources,
+  postJson,
+  readErrorCode,
+  readErrorDetail,
+  readListPage,
+  requestJson,
+  requestJsonBody,
+  requireServerAnswer,
+  resolveMessages,
+  tenantsResource,
+  toAdminError,
+  trimTrailingSlashes
+} from "../chunk-BPF2BMCQ.js";
 export {
   ADMIN_UI_VERSION,
   ActionDefNotInManifestError,
   ActionRegistry,
+  AdminError,
   BatchColumnDriftError,
   BatchColumnFetcher,
   BootLoadError,
@@ -66,6 +103,10 @@ export {
   IDENTITY_ACCENT_VALUES,
   IDENTITY_NEUTRAL,
   IDENTITY_NEUTRAL_VALUE,
+  LIST_FIRST_PAGE,
+  LIST_PAGE_SIZE_DEFAULT,
+  LIST_PAGE_SIZE_MAX,
+  LIST_PAGINATION_PARAMS,
   ManifestLoadError,
   ManifestLoader,
   MissingHandlerError,
@@ -73,32 +114,63 @@ export {
   SA_LOCALES,
   SA_LOCALE_LABELS,
   SA_MESSAGES,
+  adminErrorMessage,
+  auditResource,
+  bindResource,
   buildRoutes,
   buildSidebar,
+  clampListPage,
+  clampListPageSize,
   countPlans,
   createAdminResourceClient,
+  createAxiosHttpClient,
+  createFetchHttpClient,
   createSaCatalog,
   defaultHttpClient,
   defaultKvStore,
   defaultSectionOrder,
+  defineListOp,
   defineMessages,
+  defineResource,
+  filterQueryString,
   formatCurrency,
   formatMessage,
   getJson,
   identityAccentAt,
   identityAccentFor,
   identityChipStyle,
+  isAdminError,
+  isAxiosNoResponseError,
   isCurrentlyValid,
+  isEmptyResponse,
   isExpired,
   isFutureScheduled,
+  isPlatformError,
   isProductionBoot,
   isSaBuiltinLocale,
+  isSentInQuery,
+  isTransportFailure,
+  listUrl,
+  markEmptyResponse,
+  markPlatformError,
+  markTransportFailure,
   mergeMessages,
+  planVersionsResource,
+  plansResource,
+  platformResources,
   postJson,
+  readErrorCode,
+  readErrorDetail,
+  readListPage,
+  requestJson,
+  requestJsonBody,
+  requireServerAnswer,
   resolveExtension,
   resolveLoginBranding,
   resolveMessages,
   resolvePlans,
+  tenantsResource,
+  toAdminError,
   todayIsoDate,
   trimTrailingSlashes
 };