@xh/hoist 82.0.1 → 82.0.3

package/build/types/svc/EnvironmentService.d.ts

@@ -0,0 +1,50 @@
+import { HoistService } from '@xh/hoist/core';
+/**
+ * Load and report on the client and server environment, including software versions, timezones, and
+ * other technical information.
+ */
+export declare class EnvironmentService extends HoistService {
+    static instance: EnvironmentService;
+    /**
+     * Version of this application currently running on the Hoist UI server.
+     * Unlike most other EnvironmentService state, this is refreshed on a timer and observable.
+     */
+    serverVersion: string;
+    /**
+     * Build of this application currently running on the Hoist UI server.
+     * Unlike most other EnvironmentService state, this is refreshed on a timer and observable.
+     */
+    serverBuild: string;
+    /**
+     * Instance of Hoist UI server currently delivering content to this client.
+     * Unlike most other EnvironmentService state, this is refreshed on a timer and observable.
+     */
+    serverInstance: string;
+    private data;
+    private pollConfig;
+    private pollTimer;
+    initAsync(): Promise<void>;
+    get(key: string): any;
+    get appEnvironment(): AppEnvironment;
+    isProduction(): boolean;
+    isTest(): boolean;
+    /**
+     * Update critical environment information from server, including current app version + build,
+     * upgrade prompt mode, and alert banner.
+     *
+     * @internal - not for app use. Called by `pollTimer` and as needed by Hoist code.
+     */
+    pollServerAsync(): Promise<void>;
+    constructor();
+    private ensureVersionRunnable;
+    private startPolling;
+    private setServerInfo;
+    private get pollIntervalMs();
+}
+/**
+ * Available application deployment environments, as defined by Hoist Core `AppEnvironment.groovy`.
+ *
+ * Note that this is distinct from node's `process.env.NODE_ENV`, which will be "production" at
+ * runtime on any built/deployed instances of the app, including on Dev/UAT servers.
+ */
+export type AppEnvironment = 'Production' | 'Beta' | 'Staging' | 'Development' | 'Test' | 'UAT' | 'BCP';

package/build/types/svc/FetchService.d.ts

@@ -0,0 +1,269 @@
+import { Awaitable, HoistService, LoadSpec, LoadSpecConfig, PlainObject, TrackOptions } from '@xh/hoist/core';
+import { HoistException } from '@xh/hoist/exception';
+import { PromiseTimeoutSpec } from '@xh/hoist/promise';
+import { StatusCodes } from 'http-status-codes';
+import { IStringifyOptions } from 'qs';
+/**
+ * Service for making managed HTTP requests, both to the app's own Hoist server and to remote APIs.
+ *
+ * Wrapper around the standard Fetch API with some enhancements to streamline the process for
+ * the most common use-cases. The Fetch API will be called with CORS enabled, credentials
+ * included, and redirects followed.
+ *
+ * Set {@link FetchService.autoGenCorrelationIds} to enable auto-generation of Correlation IDs
+ * for requests issued by this service. Best configured in the app's `Bootstrap` module to ensure
+ * coverage of early hoist core init requests. Can also be set on a per-request basis via
+ * {@link FetchOptions.correlationId}.
+ *
+ * Custom headers can be set on a request via {@link FetchOptions.headers}. Default headers for all
+ * requests can be set / customized using {@link addDefaultHeaders}.
+ *
+ * Also see the {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API | Fetch API Docs}.
+ *
+ * Note that the convenience methods `fetchJson`, `postJson`, `putJson` all accept the same options
+ * as the main entry point `fetch`, as they delegate to fetch after setting additional defaults.
+ */
+export declare class FetchService extends HoistService {
+    static instance: FetchService;
+    NO_JSON_RESPONSES: StatusCodes[];
+    /**
+     * Regex applied during failed response handling to determine if contentType indicates JSON.
+     * Matches `application/json` as well as variants such as `application/problem+json`
+     */
+    JSON_CONTENT_TYPE_RE: RegExp;
+    private autoAborters;
+    private _defaultHeaders;
+    private _interceptors;
+    /**
+     * Should hoist auto-generate a Correlation ID for a request when not otherwise specified?
+     * Set to `true` or a dynamic per-request function to enable. Default false.
+     *
+     * Static property — best configured in the app's `Bootstrap` module to ensure correlation
+     * IDs are active from the very first request.
+     */
+    static autoGenCorrelationIds: boolean | ((opts: FetchOptions) => boolean);
+    /**
+     * Method for generating Correlation IDs. Defaults to a 16 character random string with
+     * an extremely low probability of collisions. Applications may customize to improve
+     * readability or provide a stronger uniqueness guarantee.
+     *
+     * Static property — best configured in the app's `Bootstrap` module.
+     */
+    static genCorrelationId: () => string;
+    /**
+     * Request header name to be used for Correlation ID tracking.
+     *
+     * Static property — best configured in the app's `Bootstrap` module.
+     */
+    static correlationIdHeaderKey: string;
+    /** Default timeout to be used for all requests made via this service */
+    defaultTimeout: PromiseTimeoutSpec;
+    /** Default headers to be sent with all subsequent requests. */
+    get defaultHeaders(): DefaultHeaders[];
+    /**
+     * Promise handlers to be executed before fufilling or rejecting returned Promise.
+     *
+     * Use the `onRejected` handler for apps requiring common handling for particular exceptions.
+     * Useful for recognizing 401s (i.e. session end), or wrapping, logging, or enhancing exceptions.
+     * The simplest onRejected handler will simply rethrow the passed exception, or a wrapped version of it.
+     * Such handlers may also return `never()` to prevent further processing of the request -- this
+     * is useful, i.e. if the handler is going to redirect the entire app, or otherwise end normal
+     * app processing.  Rejected handlers may also be able to retry and return valid results via
+     * another call to fetch.
+     *
+     * Use the `onFulfilled` hander for enhancing, tracking, or even rejecting "successful" returns.
+     * For example, a handler of this form could be used to transform a 200 response returned by
+     * an API with an "error" flag into a proper client-side exception.
+     */
+    addInterceptor(handler: FetchInterceptor): void;
+    /**
+     * Add default headers to be sent with all subsequent requests.
+     * @param headers - to be sent with all fetch requests, or a function to generate.
+     */
+    addDefaultHeaders(headers: DefaultHeaders): void;
+    /**
+     * Send a request via the underlying fetch API.
+     *
+     * This is the main entry point for this API, and can be used to satisfy all
+     * requests.  Other shortcut variants will delegate to this method, after setting
+     * default options and pre-processing content.
+     *
+     *  Set `asJson` to true return a parsed JSON result, rather than the raw Response.
+     *  Note that shortcut variant of this method (e.g. `fetchJson`, `postJson`) will set this
+     *  flag for you.
+     *
+     * @returns Promise which resolves to a Response or JSON.
+     */
+    fetch(opts: FetchOptions): Promise<any>;
+    /**
+     * Send an HTTP request and decode the response as JSON.
+     * @returns the decoded JSON object, or null if the response has status in {@link NO_JSON_RESPONSES}.
+     */
+    fetchJson(opts: FetchOptions): Promise<any>;
+    /**
+     * Send a GET request and decode the response as JSON.
+     * @returns the decoded JSON object, or null if the response status is in {@link NO_JSON_RESPONSES}.
+     */
+    getJson(opts: FetchOptions): Promise<any>;
+    /**
+     * Send a POST request with a JSON body and decode the response as JSON.
+     * @returns the decoded JSON object, or null if the response status is in {@link NO_JSON_RESPONSES}.
+     */
+    postJson(opts: FetchOptions): Promise<any>;
+    /**
+     * Send a PUT request with a JSON body and decode the response as JSON.
+     * @returns the decoded JSON object, or null if the response status is in {@link NO_JSON_RESPONSES}.
+     */
+    putJson(opts: FetchOptions): Promise<any>;
+    /**
+     * Send a PATCH request with a JSON body and decode the response as JSON.
+     * @returns the decoded JSON object, or null if the response status is in {@link NO_JSON_RESPONSES}.
+     */
+    patchJson(opts: FetchOptions): Promise<any>;
+    /**
+     * Send a DELETE request with optional JSON body and decode the optional response as JSON.
+     * @returns the decoded JSON object, or null if the response status is in {@link NO_JSON_RESPONSES}.
+     */
+    deleteJson(opts: FetchOptions): Promise<any>;
+    /**
+     * Manually abort any pending request for a given autoAbortKey.
+     * @returns false if no request pending for the given key.
+     */
+    abort(autoAbortKey: string): boolean;
+    private fetchInternalAsync;
+    private sendJsonInternalAsync;
+    private withCorrelationId;
+    private withDefaultHeadersAsync;
+    private managedFetchAsync;
+    private abortableFetchAsync;
+    private parseJsonAsync;
+    private safeResponseTextAsync;
+    private qsFilterFn;
+    /**
+     * Create an Error to throw when a fetch call returns a !ok response.
+     * @param fetchOptions - original options passed to FetchService.
+     * @param response - return value of native fetch.
+     * @param responseText - optional additional details from the server.
+     */
+    private exceptionFromResponse;
+    /**
+     * Create an Error to throw when a fetchJson call encounters a SyntaxError.
+     * @param fetchOptions - original options passed to FetchService.
+     * @param cause - object thrown by native {@link response.json}.
+     */
+    private jsonParseException;
+    /**
+     * Create an Error to throw when a fetch call is aborted.
+     * @param fetchOptions - original options passed to FetchService.
+     * @param cause - object thrown by native fetch
+     */
+    private abortedException;
+    /**
+     * Create an Error to throw when a fetch call times out.
+     * @param fetchOptions - original options the app passed when calling FetchService.
+     * @param cause - underlying timeout exception
+     * @param message - optional custom message
+     *
+     * @returns an exception that is both a TimeoutException, and a FetchException, with the
+     *      underlying TimeoutException as its cause.
+     */
+    private timeoutException;
+    /**
+     * Create an Error for when the server called by fetch does not respond
+     * @param fetchOptions - original options the app passed to FetchService.fetch
+     * @param cause - object thrown by native fetch
+     */
+    private serverUnavailableException;
+    private createException;
+    private safeParseJson;
+    private extractMessage;
+}
+/** Headers to be applied to all requests.  Specified as object, or dynamic function to create. */
+export type DefaultHeaders = PlainObject | ((opts: FetchOptions) => Awaitable<PlainObject>);
+/** Handlers to be executed before fufilling or rejecting any exception to caller. */
+export interface FetchInterceptor {
+    onFulfilled: (opts: FetchOptions, value: any) => Promise<any>;
+    onRejected: (opts: FetchOptions, cause: unknown) => Promise<any>;
+}
+/**
+ * Standard options to pass through to fetch, with some additions.
+ * See MDN for available options - {@link https://developer.mozilla.org/en-US/docs/Web/API/Request}.
+ */
+export interface FetchOptions {
+    /** URL for the request. Relative urls will be appended to XH.baseUrl. */
+    url: string;
+    /**
+     * Data to send in the request body (for POSTs/PUTs of JSON).
+     * When using `fetch`, provide a string. Otherwise, provide a JSON Serializable object
+     */
+    body?: any;
+    /**
+     * Unique identifier for this request, used for tracking and logging. If `false`, no
+     * `correlationId` will be set. If `true`, one will be auto-generated.
+     */
+    correlationId?: string | boolean;
+    /**
+     * Parameters to encode and append as a query string, or send with the request body
+     * (for POSTs/PUTs sending form-url-encoded).
+     */
+    params?: PlainObject;
+    /**
+     * HTTP Request method to use for the request. If not specified, the method will be set to POST
+     * if there are params, otherwise GET.
+     */
+    method?: string;
+    /**
+     * Headers to send with this request. A Content-Type header will be set if not provided by
+     * the caller directly or via one of the xxxJson convenience methods.
+     */
+    headers?: PlainObject;
+    /**
+     * MS to wait for response before rejecting with a timeout exception. Defaults to 30 seconds,
+     * but may be specified as null to specify no timeout.
+     */
+    timeout?: PromiseTimeoutSpec;
+    /**
+     * Optional metadata about the underlying request. Passed through for downstream processing by
+     * utils such as {@link ExceptionHandler}.
+     */
+    loadSpec?: LoadSpec | LoadSpecConfig;
+    /**
+     * Options to pass to the underlying fetch request.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch
+     */
+    fetchOpts?: PlainObject;
+    /**
+     * Options for qs, the library used to encode query strings.
+     */
+    qsOpts?: Partial<IStringifyOptions>;
+    /**
+     * If set, any pending requests made with the same autoAbortKey will be immediately
+     * aborted in favor of the new request.
+     */
+    autoAbortKey?: string;
+    /**
+     * True to decode the HTTP response as JSON. Default false.
+     */
+    asJson?: boolean;
+    /**
+     * If set, the request will be tracked via Hoist activity tracking. (Do not set `correlationId`
+     * here - use the top-level `correlationId` property instead.)
+     */
+    track?: string | TrackOptions;
+}
+/**
+ * Exception thrown to indicate an HTTP error resulting from a call to FetchService.
+ */
+export interface FetchException extends HoistException {
+    /** Http Status code associated with exception. 0 if no response received. */
+    httpStatus: number;
+    /** Rich object or string containing details about the exception as sent by server. */
+    serverDetails: string | PlainObject;
+    /** Options of underlying fetch call. */
+    fetchOptions: FetchOptions;
+    /**
+     * True if exception resulted from the fetch being aborted by fetchService, or the application.
+     * @see FetchService.abort and FetchOptions.autoAbortKey.
+     */
+    isFetchAborted: boolean;
+}

package/build/types/svc/GridAutosizeService.d.ts

@@ -0,0 +1,35 @@
+import { GridAutosizeOptions, GridModel } from '@xh/hoist/cmp/grid';
+import { HoistService } from '@xh/hoist/core';
+/**
+ * Sets appropriate column widths for a grid based on its contents. Generally seeks to make columns
+ * at least as wide as all of their contents, including headers.
+ *
+ * Unlike the native ag-Grid autosizing, this service will compute a size based on all data in the
+ * grid, including off-screen rows and columns and (if requested) collapsed rows.
+ *
+ * In order to do this efficiently, this service uses heuristics and generally assumes each
+ * column consists of similarly formatted strings.
+ *
+ * @see GridAutosizeOptions
+ */
+export declare class GridAutosizeService extends HoistService {
+    xhImpl: boolean;
+    static instance: GridAutosizeService;
+    private _columnWidthCalculator;
+    /**
+     * Calculate and apply autosized column widths.
+     *
+     * @param gridModel - GridModel to autosize.
+     * @param colIds - array of columns in model to compute sizing for.
+     * @param options - options to use for this autosize.
+     */
+    autosizeAsync(gridModel: GridModel, colIds: string[], options: Omit<GridAutosizeOptions, 'columns'>): Promise<void>;
+    private calcRequiredWidthsAsync;
+    private gatherRecordsToBeSized;
+    private calcFillWidths;
+    private fillEvenly;
+    private fillSequentially;
+    private getFillState;
+    private getColFillSpec;
+    private getTotalColumnWidth;
+}

package/build/types/svc/GridExportService.d.ts

@@ -0,0 +1,56 @@
+import { HoistService, TrackOptions } from '@xh/hoist/core';
+import { GridModel, Column } from '@xh/hoist/cmp/grid';
+import { StoreRecord } from '@xh/hoist/data';
+/**
+ * Exports Grid data to either Excel or CSV via Hoist's server-side export capabilities.
+ * See the Column API for options to control exported values and formats.
+ */
+export declare class GridExportService extends HoistService {
+    xhImpl: boolean;
+    static instance: GridExportService;
+    /**
+     * Export the data within a GridModel to a file. Typically called via `GridModel.exportAsync()`.
+     */
+    exportAsync(gridModel: GridModel, { filename, type, columns, track, timeout }?: ExportOptions): Promise<void>;
+    /**
+     * Get the exportable value for a given cell.
+     * Used internally by this service + public to support Grid's "copy cell" context menu action.
+     */
+    getExportableValueForCell({ gridModel, record, column, node, forExcel }: {
+        gridModel: GridModel;
+        record: StoreRecord;
+        column: Column;
+        node?: any;
+        forExcel?: boolean;
+    }): any;
+    private showFailToast;
+    private getExportableColumns;
+    private getExportFieldType;
+    private getColumnMetadata;
+    private getHeaderRow;
+    private getRecordRowsRecursive;
+    private getRecordRow;
+    private getContentType;
+    private getFileExtension;
+    private minWait;
+    private getCellSpecificType;
+}
+export interface ExportOptions {
+    /**
+     * Name for export file, or closure to generate.
+     * Do not include the file extension - that will be appended based on the specified type.
+     */
+    filename?: string | ((g: GridModel) => string);
+    /** Type of export. */
+    type?: 'excel' | 'excelTable' | 'csv';
+    /**
+     *  Columns to include in export. Supports tokens 'VISIBLE' (default - all currently visible cols),
+     *  'ALL', or specific column IDs to include (can be used in conjunction with VISIBLE to export
+     *  all visible and enumerated columns). Also supports a function returning column IDs to include.
+     */
+    columns?: 'VISIBLE' | 'ALL' | string[] | ((g: GridModel) => string[]);
+    /** True to enable activity tracking of exports (default false). */
+    track?: boolean | Partial<TrackOptions>;
+    /** Timeout (in ms) for export request - defaults to 30 seconds. */
+    timeout?: number;
+}

package/build/types/svc/IdentityService.d.ts

@@ -0,0 +1,58 @@
+import { HoistService, HoistUser, IdentityInfo } from '@xh/hoist/core';
+/**
+ * Provides basic information related to the authenticated user, including application roles.
+ * This service loads its data from Hoist Core's server-side identity service.
+ *
+ * Also provides support for recognizing impersonation and distinguishing between the apparent and
+ * actual underlying user.
+ */
+export declare class IdentityService extends HoistService {
+    static instance: IdentityService;
+    private identity;
+    /** @returns current acting user (see authUser for notes on impersonation) */
+    get user(): HoistUser;
+    /** @returns current acting user's username. */
+    get username(): string;
+    /** @returns current acting user's initials, based on displayName. */
+    get userInitials(): string;
+    /**
+     * Actual user who authenticated to the web application.
+     * This will be the same as the user except when an administrator is impersonation another
+     * user for troubleshooting or testing. In those cases, this getter will return the actual
+     * administrator, whereas `this.user` will return the user they are impersonating.
+     */
+    get authUser(): HoistUser;
+    get authUsername(): string;
+    /** Is an impersonation session currently active? */
+    get isImpersonating(): boolean;
+    /**
+     * Can the user impersonate other users?
+     *
+     * See also canAuthUserImpersonate() which should be consulted before actually
+     * triggering any impersonation attempts.
+     */
+    get canImpersonate(): boolean;
+    /**
+     * Can the underlying authenticated user impersonate other users?
+     *
+     * Use this getter to determine if Hoist should allow the client to show impersonation
+     * affordances and to trigger impersonation actions.
+     */
+    get canAuthUserImpersonate(): boolean;
+    /**
+     * Begin an impersonation session to act as another user. The UI server will allow this only
+     * if the actual authenticated user has the rights to do, and is attempting to impersonate
+     * a known user who has permission to and has accessed the app themselves. If successful,
+     * the application will reload and the admin will now be acting as the other user.
+     *
+     * @param username - the end-user to impersonate
+     */
+    impersonateAsync(username: string): Promise<void>;
+    /** Exit any active impersonation, reloading the app to resume accessing it as yourself. */
+    endImpersonateAsync(): Promise<void>;
+    /**
+     * @internal -- for framework use onlu.
+     */
+    initIdentity(identity: IdentityInfo): void;
+    private canUserImpersonate;
+}

package/build/types/svc/IdleService.d.ts

@@ -0,0 +1,21 @@
+import { HoistService } from '@xh/hoist/core';
+/**
+ * Manage the idling/suspension of this application after a certain period of user inactivity
+ * to cancel background tasks and prompt the user to reload the page when they wish to resume
+ * using the app. This approach is typically employed to reduce potential load on back-end
+ * system from unattended clients and/or as a "belt-and-suspenders" defence against memory
+ * leaks or other performance issues that can arise with long-running sessions.
+ *
+ * This service consults the `xhIdleConfig` soft-config and the `xhIdleDetectionDisabled`
+ * user preference to determine if and when it should suspend the app.
+ */
+export declare class IdleService extends HoistService {
+    xhImpl: boolean;
+    static instance: IdleService;
+    private timer;
+    private timeout;
+    constructor();
+    private startMonitoring;
+    private createTimer;
+    private checkInactivityTimeout;
+}

package/build/types/svc/InspectorService.d.ts

@@ -0,0 +1,75 @@
+import { HoistService } from '@xh/hoist/core';
+import { Timer } from '@xh/hoist/utils/async';
+/**
+ * Developer/Admin focused service to provide additional processing and stats related to the
+ * running application, specifically its current HoistModel, HoistService, and Store instances.
+ *
+ * Activating this service will cause it to maintain an observable array of summary data synced
+ * (with a minimal throttle) on each change to the Hoist registry, as well as an array of model
+ * count / memory usage stats, also updated on model changes and periodically in the background.
+ *
+ * When running in a Desktop application, activating this service will trigger the display of the
+ * Hoist Inspector UI - {@link inspectorPanel}. A built-in control to activate/deactivate this
+ * service is provided within the Desktop versionBar component.
+ *
+ * This service may be completely disabled via an optional `xhInspectorConfig` appConfig, although
+ * note that this config does *not* disable the backing registry within XH. Access to Inspector can
+ * also be limited to users with a particular app role, using the same config.
+ */
+export declare class InspectorService extends HoistService {
+    xhImpl: boolean;
+    static instance: InspectorService;
+    persistWith: {
+        localStorageKey: string;
+    };
+    /**
+     * True if Inspector is generally enabled via config.
+     * If enabled but !active, this service won't do any work, but can be activated on demand.
+     */
+    get enabled(): boolean;
+    /** True to start processing model stats and show the Inspector UI. */
+    active: boolean;
+    /** Info on current services/models/stores (when active). */
+    activeInstances: InspectorInstanceData[];
+    /** Timestamped model counts w/memory usage (when active). */
+    stats: InspectorStat[];
+    statsUpdateTimer: Timer;
+    private _syncRun;
+    private _idToSyncRun;
+    constructor();
+    initAsync(): Promise<void>;
+    toggleActive(): void;
+    activate(): void;
+    deactivate(): void;
+    updateStats(): void;
+    clearStats(): void;
+    restoreDefaultsAsync(): Promise<void>;
+    private sync;
+    setActiveInstances(ai: InspectorInstanceData[]): void;
+    _prevModelCount: number;
+    get conf(): any;
+}
+interface InspectorInstanceData {
+    className: string;
+    created: number;
+    isHoistModel: boolean;
+    isHoistService: boolean;
+    isStore: boolean;
+    isLinked: boolean;
+    isXhImpl: boolean;
+    hasLoadSupport: boolean;
+    lastLoadCompleted: Date;
+    lastLoadException: any;
+    syncRun: number;
+}
+interface InspectorStat {
+    id: number;
+    timestamp: number;
+    modelCount: number;
+    modelCountChange: number;
+    totalJSHeapSize: number;
+    usedJSHeapSize: number;
+    jsHeapSizeLimit: number;
+    syncRun: number;
+}
+export {};

package/build/types/svc/JsonBlobService.d.ts

@@ -0,0 +1,60 @@
+import { HoistService, LoadSpec, PlainObject } from '@xh/hoist/core';
+export interface JsonBlob {
+    /** Either null for private blobs or special token "*" for globally shared blobs. */
+    acl: '*';
+    /** True if this blob has been archived (soft-deleted). */
+    archived: boolean;
+    /** Timestamp indicating when this blob was archived, or special value `0` if not archived. */
+    archivedDate: number;
+    dateCreated: number;
+    description: string;
+    /** @internal database ID for this blob. Favor token instead. */
+    id: number;
+    lastUpdated: number;
+    lastUpdatedBy: string;
+    /** Optional application-specific metadata. */
+    meta: PlainObject | unknown[];
+    name: string;
+    /** Username of the blob's creator / owner. */
+    owner: string;
+    /** Primary unique identifier for getting, updating, and archiving blobs. */
+    token: string;
+    /**
+     * Application defined type for this blob. Used as a discriminator when querying blobs related
+     * to a particular use-case within an application.
+     */
+    type: string;
+    /**
+     * Current JSON value of this blob - its contents or data. Will be undefined for blob stubs
+     * returned by `listAsync` if `includeValue` was false.
+     */
+    value?: any;
+}
+/**
+ * Service to read and set chunks of user-specific JSON persisted via Hoist Core's JSONBlob class.
+ *
+ * This service is intended as a general, lightweight utility for persisting small bundles of
+ * unstructured data that might not warrant a full-blown domain object, but which still need to be
+ * persisted back to the database.
+ */
+export declare class JsonBlobService extends HoistService {
+    static instance: JsonBlobService;
+    /** Retrieve a single JSONBlob by its unique token. */
+    getAsync(token: string): Promise<JsonBlob>;
+    /** Retrieve all blobs of a particular type that are visible to the current user. */
+    listAsync(spec: {
+        type: string;
+        includeValue?: boolean;
+        loadSpec?: LoadSpec;
+    }): Promise<JsonBlob[]>;
+    /** Persist a new JSONBlob back to the server. */
+    createAsync({ acl, description, type, meta, name, value }: Partial<JsonBlob>): Promise<JsonBlob>;
+    /** Modify mutable properties of an existing JSONBlob, as identified by its unique token. */
+    updateAsync(token: string, update: Partial<JsonBlob>): Promise<JsonBlob>;
+    /** Create or update a blob for a user with the existing type and name. */
+    createOrUpdateAsync(type: string, name: string, data: Partial<JsonBlob>): Promise<JsonBlob>;
+    /** Find a blob owned by this user with a specific type and name.  If none exists, return null.  */
+    findAsync(type: string, name: string): Promise<JsonBlob>;
+    /** Archive (soft-delete) an existing JSONBlob, as identified by its unique token. */
+    archiveAsync(token: string): Promise<JsonBlob>;
+}