@zeyos/zx 4.1.1 → 4.3.0

package/dist/types/zeyos/legacy-saved-views.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @typedef {Object} SavedViewScope
+ * @property {string|number} userId Client identity used by the controller; never sent to the legacy endpoint.
+ * @property {string|number|null} workspaceId ZeyOS fork/workspace id.
+ * @property {string} resource ZeyOS resource whose record views are being saved.
+ */
+export type SavedViewScope = {
+    /**
+     * Client identity used by the controller; never sent to the legacy endpoint.
+     */
+    userId: string | number;
+    /**
+     * ZeyOS fork/workspace id.
+     */
+    workspaceId: string | number | null;
+    /**
+     * ZeyOS resource whose record views are being saved.
+     */
+    resource: string;
+};
+export type LegacySavedViewTransportOptions = {
+    /**
+     * Reserved `userfields.name` value.
+     */
+    recordName?: string;
+    /**
+     * Namespace prepended to `userfields.view`.
+     */
+    viewPrefix?: string;
+    /**
+     * Legacy UMI/module value.
+     */
+    module?: string;
+};
+/**
+ * @typedef {Object} LegacySavedViewTransportOptions
+ * @property {string} [recordName='__zx_record_views_v1__'] Reserved `userfields.name` value.
+ * @property {string} [viewPrefix='zx.record-views:'] Namespace prepended to `userfields.view`.
+ * @property {string} [module=''] Legacy UMI/module value.
+ */
+/**
+ * Converts the callback form of `PG.load` into the promise request consumed by
+ * `createLegacySavedViewTransport`. Pass a bound method (`PG.load.bind(PG)`) so legacy receivers
+ * that depend on `this` remain intact.
+ * @param {(params:Record<string,unknown>,onLoad:(data:unknown)=>void,onCatch:(message:unknown,type?:unknown,info?:unknown)=>boolean)=>unknown} load Legacy loader.
+ * @returns {(params:Record<string,unknown>)=>Promise<unknown>}
+ */
+export declare function legacySavedViewRequest(load: (params: Record<string, unknown>, onLoad: (data: unknown) => void, onCatch: (message: unknown, type?: unknown, info?: unknown) => boolean) => unknown): (params: Record<string, unknown>) => Promise<unknown>;
+/**
+ * Adapts ZeyOS's existing `fields`, `fields_save`, and `fields_remove` endpoints to the atomic
+ * document transport used by saved record views. The endpoint derives the user from the
+ * authenticated session; accepting `userId` in the scope prevents accidental controller reuse but
+ * deliberately does not turn a client-supplied identity into an authorization input.
+ *
+ * `request` is injected because Zx supports both the legacy `PG.load` bridge and modern hosts. It
+ * receives the familiar plain endpoint parameters and returns a promise for the decoded response.
+ *
+ * @param {(params:Record<string,unknown>)=>Promise<unknown>} request Promise-based legacy request bridge.
+ * @param {LegacySavedViewTransportOptions} [options={}] Endpoint namespace options.
+ * @returns {{load:(scope:SavedViewScope)=>Promise<Record<string,unknown>|null>,save:(scope:SavedViewScope,document:Record<string,unknown>)=>Promise<Record<string,unknown>>,remove:(scope:SavedViewScope)=>Promise<void>}}
+ */
+export declare function createLegacySavedViewTransport(request: (params: Record<string, unknown>) => Promise<unknown>, options?: LegacySavedViewTransportOptions): {
+    load: (scope: SavedViewScope) => Promise<Record<string, unknown> | null>;
+    save: (scope: SavedViewScope, document: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    remove: (scope: SavedViewScope) => Promise<void>;
+};

package/dist/types/zeyos/saved-views.d.ts

@@ -0,0 +1,331 @@
+/** Current persisted saved-view document version. */
+export declare const SAVED_VIEWS_VERSION = 1;
+export type SavedViewType = 'table' | 'card' | 'kanban';
+export type SavedViewDuplicatePolicy = 'reject' | 'replace';
+export type SavedViewScope = {
+    /**
+     * Authenticated user identifier.
+     */
+    userId: string;
+    /**
+     * Workspace/fork identifier; null identifies the base workspace.
+     */
+    workspaceId: string | null;
+    /**
+     * ZeyOS resource/view identifier.
+     */
+    resource: string;
+};
+export type SavedViewEntry = {
+    /**
+     * Stable saved-view identifier.
+     */
+    id: string;
+    /**
+     * User-facing unique name.
+     */
+    name: string;
+    /**
+     * Presentation type.
+     */
+    type: SavedViewType;
+    /**
+     * Versioned RecordView configuration.
+     */
+    state: Record<string, unknown>;
+    /**
+     * JSON-safe query/filter configuration.
+     */
+    filters: Record<string, unknown>;
+    /**
+     * Full-text query.
+     */
+    search: string;
+    /**
+     * ISO-8601 creation timestamp.
+     */
+    createdAt: string;
+    /**
+     * ISO-8601 update timestamp.
+     */
+    updatedAt: string;
+};
+export type SavedViewDocument = {
+    /**
+     * Persisted document schema version.
+     */
+    version: 1;
+    /**
+     * Scope duplicated in the document to detect transport mix-ups.
+     */
+    scope: SavedViewScope;
+    /**
+     * Default saved-view id.
+     */
+    defaultId: string | null;
+    /**
+     * Deterministically ordered saved views.
+     */
+    views: SavedViewEntry[];
+};
+export type SavedViewTransport = {
+    /**
+     * Loads the one document for scope.
+     */
+    load: (scope: SavedViewScope) => unknown | Promise<unknown>;
+    /**
+     * Atomically replaces the one document for scope.
+     */
+    save: (scope: SavedViewScope, document: SavedViewDocument) => unknown | Promise<unknown>;
+    /**
+     * Removes the scope document.
+     */
+    remove?: (scope: SavedViewScope) => unknown | Promise<unknown>;
+};
+export type SavedViewRegistryOptions = {
+    /**
+     * Duplicate-name policy.
+     */
+    duplicateNames?: SavedViewDuplicatePolicy;
+    /**
+     * Timestamp source; defaults to the current time.
+     */
+    clock?: () => string | Date | number;
+    /**
+     * Stable-id factory. A deterministic dependency-free id is used when omitted.
+     */
+    idFactory?: (context: {
+        scope: SavedViewScope;
+        name: string;
+        type: SavedViewType;
+        createdAt: string;
+    }) => string;
+    /**
+     * Optional migrations keyed by their source version. Version 0 has a built-in migration.
+     */
+    migrations?: Record<number, (document: Record<string, unknown>) => Record<string, unknown>>;
+};
+export type SavedViewInput = {
+    /**
+     * Stable id for an update or import.
+     */
+    id?: string;
+    /**
+     * Unique display name.
+     */
+    name: string;
+    /**
+     * Presentation type; required for a new view.
+     */
+    type?: SavedViewType;
+    /**
+     * RecordView state; required for a new view.
+     */
+    state?: Record<string, unknown>;
+    /**
+     * Query/filter state.
+     */
+    filters?: Record<string, unknown>;
+    /**
+     * Full-text query.
+     */
+    search?: string;
+};
+export type SavedViewApplyResult = {
+    /**
+     * Result status.
+     */
+    status: 'applied' | 'missing' | 'type-mismatch';
+    /**
+     * Whether state was applied.
+     */
+    applied: boolean;
+    /**
+     * Resolved saved entry.
+     */
+    entry: SavedViewEntry | null;
+    /**
+     * Saved presentation required by the entry on a mismatch.
+     */
+    expectedType?: SavedViewType;
+    /**
+     * Current/requested renderer presentation on a mismatch.
+     */
+    currentType?: SavedViewType;
+};
+/** Duplicate saved-view name. */
+export declare class SavedViewDuplicateNameError extends Error {
+    /** @param {string} name Duplicate display name. */
+    constructor(name: string);
+}
+/** A transport returned a document belonging to another scope. */
+export declare class SavedViewScopeMismatchError extends Error {
+    expected: {
+        userId: string;
+        workspaceId: string | null;
+        resource: string;
+    };
+    actual: {
+        userId: string;
+        workspaceId: string | null;
+        resource: string;
+    };
+    /** @param {SavedViewScope} expected Expected scope. @param {SavedViewScope} actual Stored scope. */
+    constructor(expected: SavedViewScope, actual: SavedViewScope);
+}
+/**
+ * Dependency-free named saved-view registry with an injected, scope-atomic transport.
+ */
+export declare class SavedViewRegistry {
+    transport: SavedViewTransport;
+    scope: SavedViewScope;
+    options: Required<Pick<SavedViewRegistryOptions, "clock" | "duplicateNames">> & SavedViewRegistryOptions;
+    _document: SavedViewDocument;
+    _loaded: boolean;
+    _loading: Promise<void>;
+    _loadSequence: number;
+    _mutation: Promise<void>;
+    _destroyed: boolean;
+    /**
+     * @param {SavedViewTransport} transport Persistence adapter.
+     * @param {SavedViewScope} scope User/workspace/resource scope.
+     * @param {SavedViewRegistryOptions} [options={}] Registry policy and deterministic test hooks.
+     */
+    constructor(transport: SavedViewTransport, scope: SavedViewScope, options?: SavedViewRegistryOptions);
+    /** Loads the scope once and returns this registry. @returns {Promise<this>} */
+    ready(): Promise<this>;
+    /**
+     * Loads and normalizes the persisted document. Repeated calls use the in-memory snapshot unless
+     * `force` is true.
+     * @param {{force?:boolean}} [options={}] Load behavior.
+     * @returns {Promise<this>}
+     */
+    load(options?: {
+        force?: boolean;
+    }): Promise<this>;
+    /** Returns all entries in deterministic name/id order. @returns {Promise<SavedViewEntry[]>} */
+    list(): Promise<SavedViewEntry[]>;
+    /** Resolves an entry by exact id or normalized name. @param {string} idOrName @returns {Promise<SavedViewEntry|null>} */
+    get(idOrName: string): Promise<SavedViewEntry | null>;
+    /** Returns the default entry, or null. @returns {Promise<SavedViewEntry|null>} */
+    getDefault(): Promise<SavedViewEntry | null>;
+    /**
+     * Creates or updates one named entry and persists the whole scope in one transport write.
+     * @param {SavedViewInput} input Saved-view values.
+     * @param {{onDuplicate?:SavedViewDuplicatePolicy,setDefault?:boolean}} [options={}] Write policy.
+     * @returns {Promise<SavedViewEntry>} Saved entry.
+     */
+    save(input: SavedViewInput, options?: {
+        onDuplicate?: SavedViewDuplicatePolicy;
+        setDefault?: boolean;
+    }): Promise<SavedViewEntry>;
+    /**
+     * Renames an entry without changing its stable id or creation time.
+     * @param {string} idOrName Entry id or name.
+     * @param {string} name New display name.
+     * @param {{onDuplicate?:SavedViewDuplicatePolicy}} [options={}] Duplicate policy.
+     * @returns {Promise<SavedViewEntry|null>} Updated entry, or null when absent.
+     */
+    rename(idOrName: string, name: string, options?: {
+        onDuplicate?: SavedViewDuplicatePolicy;
+    }): Promise<SavedViewEntry | null>;
+    /**
+     * Removes one named entry. The optional transport `remove(scope)` is used when the document
+     * becomes empty; otherwise the empty document is saved normally.
+     * @param {string} idOrName Entry id or name.
+     * @returns {Promise<boolean>} Whether an entry was removed.
+     */
+    remove(idOrName: string): Promise<boolean>;
+    /**
+     * Sets or clears the default view.
+     * @param {string|null} idOrName Entry id/name or null.
+     * @returns {Promise<SavedViewEntry|null>} New default, or null when cleared/absent.
+     */
+    setDefault(idOrName: string | null): Promise<SavedViewEntry | null>;
+    /**
+     * Captures `view.getViewState()`, persists it through `save()`, and returns the saved entry.
+     * Records and selection are never read from the view.
+     * @param {{getViewState:()=>Record<string,unknown>}} view RecordView-compatible instance.
+     * @param {Omit<SavedViewInput,'state'>} input Entry metadata/query state.
+     * @param {{onDuplicate?:SavedViewDuplicatePolicy,setDefault?:boolean}} [options={}] Write policy.
+     * @returns {Promise<SavedViewEntry>} Captured entry.
+     */
+    capture(view: {
+        getViewState: () => Record<string, unknown>;
+    }, input: Omit<SavedViewInput, 'state'>, options?: {
+        onDuplicate?: SavedViewDuplicatePolicy;
+        setDefault?: boolean;
+    }): Promise<SavedViewEntry>;
+    /**
+     * Applies one entry to a RecordView-compatible target. An expected type mismatch is reported
+     * without touching the target. Query state is handed to one optional combined callback so a
+     * server-backed binding can perform one reload rather than separate filter/search reloads.
+     * @param {string} idOrName Entry id or name.
+     * @param {{setViewState:(state:Record<string,unknown>)=>unknown}} view RecordView target.
+     * @param {{type?:SavedViewType,onQuery?:(query:{filters:Record<string,unknown>,search:string,entry:SavedViewEntry})=>unknown|Promise<unknown>}} [options={}] Apply behavior.
+     * @returns {Promise<SavedViewApplyResult>} Explicit apply result.
+     */
+    apply(idOrName: string, view: {
+        setViewState: (state: Record<string, unknown>) => unknown;
+    }, options?: {
+        type?: SavedViewType;
+        onQuery?: (query: {
+            filters: Record<string, unknown>;
+            search: string;
+            entry: SavedViewEntry;
+        }) => unknown | Promise<unknown>;
+    }): Promise<SavedViewApplyResult>;
+    /** Prevents later operations; it never removes persisted user data. @returns {void} */
+    destroy(): void;
+    /** @private @returns {void} */
+    private _assertActive;
+    /** @private @returns {string} */
+    private _now;
+    /**
+     * @private
+     * @param {SavedViewDocument} document
+     * @param {{name:string,type:SavedViewType,createdAt:string}} values
+     * @returns {string}
+     */
+    private _createId;
+    /**
+     * Serializes mutations inside one registry so concurrent calls cannot overwrite each other.
+     * @private
+     * @template T
+     * @param {(document:SavedViewDocument)=>Promise<{changed:boolean,result:T,removeDocument?:boolean}>} mutate
+     * @returns {Promise<T>}
+     */
+    private _mutate;
+}
+/**
+ * Factory useful to adapters that do not need to subclass the registry.
+ * @param {SavedViewTransport} transport Persistence adapter.
+ * @param {SavedViewScope} scope Scope.
+ * @param {SavedViewRegistryOptions} [options={}] Options.
+ * @returns {SavedViewRegistry}
+ */
+export declare function createSavedViewRegistry(transport: SavedViewTransport, scope: SavedViewScope, options?: SavedViewRegistryOptions): SavedViewRegistry;
+/**
+ * Validates and canonicalizes a transport scope. String/number identifiers are intentionally
+ * accepted so a ZeyOS fork id can bridge directly to `workspaceId`; null is the base fork.
+ * @param {SavedViewScope|Record<string,unknown>} scope Scope.
+ * @returns {SavedViewScope} Normalized scope.
+ */
+export declare function normalizeSavedViewScope(scope: SavedViewScope | Record<string, unknown>): SavedViewScope;
+/**
+ * Migrates and normalizes a persisted document without touching transport state.
+ * @param {unknown} value Persisted value, null, or a legacy version-0 value.
+ * @param {SavedViewScope} scope Expected scope.
+ * @param {SavedViewRegistryOptions} [options={}] Migration hooks.
+ * @returns {SavedViewDocument} Current normalized document.
+ */
+export declare function normalizeSavedViewDocument(value: unknown, scope: SavedViewScope, options?: SavedViewRegistryOptions): SavedViewDocument;
+/**
+ * Migrates old documents to the current structural version. Version 0 accepts an array or an
+ * object using `savedViews`/`entries`, `presentation`, `viewState`, `filter`, and `defaultView`.
+ * @param {unknown} value Persisted value.
+ * @param {Record<number,(document:Record<string,unknown>)=>Record<string,unknown>>} [migrations={}]
+ * Additional migrations keyed by source version.
+ * @returns {Record<string,unknown>} Migrated current-version document.
+ */
+export declare function migrateSavedViewDocument(value: unknown, migrations?: Record<number, (document: Record<string, unknown>) => Record<string, unknown>>): Record<string, unknown>;

package/dist/types/zeyos/view.d.ts

@@ -0,0 +1,305 @@
+export type ViewField = import('../components/view/record-view.js').ViewField;
+export type ViewSort = import('../components/view/record-view.js').ViewSort;
+export type SavedViewEntry = import('./saved-views.js').SavedViewEntry;
+export type SavedViewApplyResult = import('./saved-views.js').SavedViewApplyResult;
+export type ZeyosSavedViewsOptions = {
+    /**
+     * Existing saved-view registry. It remains caller-owned.
+     */
+    controller?: Record<string, any>;
+    /**
+     * Alias for `controller`.
+     */
+    registry?: Record<string, any>;
+    /**
+     * Injected persistence transport used to construct a registry.
+     */
+    transport?: Record<string, any>;
+    /**
+     * Saved-view isolation scope; null workspace identifies ZeyOS's base workspace.
+     * resource defaults to the bound ZeyOS resource.
+     */
+    scope?: {
+        userId: string | number;
+        workspaceId: string | number | null;
+        resource?: string;
+    };
+    /**
+     * Options passed to `createSavedViewRegistry`.
+     */
+    options?: Record<string, unknown>;
+    /**
+     * Presentation identity; normally derived from the View.
+     */
+    type?: 'table' | 'card' | 'kanban';
+};
+export type ZeyosViewOptions = {
+    /**
+     * Curated ordered schema field allow-list.
+     */
+    fields?: string[];
+    /**
+     * Schema fields to omit.
+     */
+    exclude?: string[];
+    /**
+     * Per-field label overrides.
+     */
+    labels?: Record<string, string>;
+    /**
+     * View descriptor overrides.
+     */
+    fieldOverrides?: Record<string, Partial<ViewField>>;
+    /**
+     * Record id accessor.
+     */
+    recordId?: string | ((record: Record<string, unknown>) => unknown);
+    /**
+     * Server page size.
+     */
+    pageSize?: number;
+    /**
+     * Initial server sort.
+     */
+    sort?: ViewSort | null;
+    /**
+     * Initial ZeyOS predicates.
+     */
+    filters?: Record<string, unknown>;
+    /**
+     * Initial full-text query.
+     */
+    search?: string;
+    /**
+     * Server full-text fields where supported.
+     */
+    searchFields?: string[];
+    /**
+     * Options passed to the concrete view.
+     */
+    viewOptions?: Record<string, unknown>;
+    /**
+     * Concrete view target.
+     */
+    target?: Element | string | null;
+    /**
+     * Card title field included in the projection.
+     */
+    titleField?: string;
+    /**
+     * Card subtitle field included in the projection.
+     */
+    subtitleField?: string;
+    /**
+     * Preview field or resolver.
+     */
+    preview?: string | Function;
+    /**
+     * Card grouping field or resolver.
+     */
+    groupBy?: string | Function;
+    /**
+     * Kanban column field or resolver.
+     */
+    columnBy?: string | Function;
+    /**
+     * Kanban swim-lane field or resolver.
+     */
+    swimlaneBy?: string | Function;
+    /**
+     * Existing registry or
+     * injected transport/scope configuration for named saved views.
+     */
+    savedViews?: false | Record<string, any> | ZeyosSavedViewsOptions | null;
+    onRecordClick?: (record: Record<string, unknown>, event: CustomEvent<Record<string, unknown>>) => void;
+};
+export type ZeyosViewConfig = {
+    /**
+     * Ordered normalized schema metadata.
+     */
+    fieldMeta: Record<string, any>[];
+    /**
+     * Common view fields.
+     */
+    fields: ViewField[];
+    /**
+     * Complete server projection.
+     */
+    projection: Record<string, string>;
+    /**
+     * Concrete view options.
+     */
+    viewOptions: Record<string, any>;
+};
+export type ZeyosViewLoadOptions = {
+    /**
+     * Replacement full-text query.
+     */
+    search?: string;
+    /**
+     * Replacement predicates.
+     */
+    filters?: Record<string, unknown>;
+    /**
+     * Zero-based page; pages above zero append.
+     */
+    page?: number;
+};
+export type ZeyosViewLoadResult = {
+    /**
+     * Loaded records.
+     */
+    data: Record<string, unknown>[];
+    /**
+     * Server count when supplied.
+     */
+    count: number | null;
+    /**
+     * Loaded page.
+     */
+    page: number;
+    /**
+     * Whether another page is available.
+     */
+    hasMore: boolean;
+    /**
+     * Request sent to the list operation.
+     */
+    query: Record<string, unknown>;
+};
+export type ZeyosSavedViewCapture = {
+    /**
+     * Existing saved-view id.
+     */
+    id?: string;
+    /**
+     * Saved-view name.
+     */
+    name: string;
+    /**
+     * Concrete presentation.
+     */
+    type: 'table' | 'card' | 'kanban';
+    /**
+     * JSON-safe component view state.
+     */
+    state: Record<string, unknown>;
+    /**
+     * Current server filters.
+     */
+    filters: Record<string, unknown>;
+    /**
+     * Current full-text query.
+     */
+    search: string;
+};
+export type ZeyosSaveViewOptions = {
+    /**
+     * Existing saved-view id to replace.
+     */
+    id?: string;
+    /**
+     * Saved-view name.
+     */
+    name: string;
+    /**
+     * Duplicate-name behavior.
+     */
+    onDuplicate?: 'reject' | 'replace';
+    /**
+     * Make the saved entry the default.
+     */
+    setDefault?: boolean;
+};
+export type ZeyosApplyViewOptions = {
+    /**
+     * Reload the first server page after an applied view.
+     */
+    load?: boolean;
+};
+export type ZeyosViewBinding = {
+    /**
+     * Generated RecordView-compatible instance.
+     */
+    view: Record<string, any>;
+    /**
+     * Loads a page.
+     */
+    load: (options?: ZeyosViewLoadOptions) => Promise<ZeyosViewLoadResult>;
+    /**
+     * Replaces search and reloads.
+     */
+    setSearch: (search: string) => Promise<ZeyosViewLoadResult>;
+    /**
+     * Replaces filters and reloads.
+     */
+    setFilters: (filters: Record<string, unknown>) => Promise<ZeyosViewLoadResult>;
+    /**
+     * Loads the next page when available.
+     */
+    loadMore: () => Promise<ZeyosViewLoadResult>;
+    /**
+     * Current server count.
+     */
+    count: number | null;
+    /**
+     * Current zero-based page.
+     */
+    page: number;
+    /**
+     * Whether another page is available.
+     */
+    hasMore: boolean;
+    /**
+     * Saved-view registry when configured.
+     */
+    savedViews: Record<string, any> | null;
+    /**
+     * Default restoration completed before loads.
+     */
+    ready: Promise<SavedViewApplyResult | null>;
+    /**
+     * Restores the current default.
+     */
+    restoreDefault: (options?: ZeyosApplyViewOptions) => Promise<SavedViewApplyResult | null>;
+    /**
+     * Captures current query/view state without persistence.
+     */
+    captureView: (details: {
+        id?: string;
+        name: string;
+    }) => ZeyosSavedViewCapture;
+    /**
+     * Captures and persists the current view.
+     */
+    saveView: (details: ZeyosSaveViewOptions) => Promise<SavedViewEntry>;
+    /**
+     * Applies a compatible named view.
+     */
+    applyView: (idOrName: string, options?: ZeyosApplyViewOptions) => Promise<SavedViewApplyResult>;
+    /**
+     * Destroys the generated view.
+     */
+    destroy: () => void;
+};
+/**
+ * Produces common view fields and a complete ZeyOS projection without touching the DOM. It reuses
+ * the established table schema conversion so entity labels, enums, amounts, currencies, and Unix
+ * dates render identically in TableView, CardView, and KanbanView.
+ * @param {Record<string, any>} client Injected ZeyOS client.
+ * @param {string} resource Schema resource.
+ * @param {ZeyosViewOptions} [opts={}] Schema and view options.
+ * @returns {ZeyosViewConfig} DOM-free configuration.
+ */
+export declare function buildZeyosViewConfig(client: Record<string, any>, resource: string, opts?: ZeyosViewOptions): ZeyosViewConfig;
+/**
+ * Creates and binds any RecordView-compatible constructor to server paging. The caller supplies the
+ * constructor, so this adapter has no dependency on one concrete presentation and remains simple
+ * to unit test or wrap from a framework.
+ * @param {Record<string, any>} client Injected ZeyOS client.
+ * @param {string} resource Schema resource.
+ * @param {new(target:Element|string|null,options:Record<string,unknown>)=>Record<string,any>} View Concrete view class.
+ * @param {ZeyosViewOptions} [opts={}] Binding options.
+ * @returns {ZeyosViewBinding} View and server-state methods.
+ */
+export declare function zeyosView(client: Record<string, any>, resource: string, View: new (target: Element | string | null, options: Record<string, unknown>) => Record<string, any>, opts?: ZeyosViewOptions): ZeyosViewBinding;