@bg-dev/nuxt-zenstack 0.0.2 → 0.0.4

package/dist/module.d.mts

@@ -1,7 +1,9 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { FetchPolicy } from '../dist/runtime/composables/common.js';
 
 interface ModuleOptions {
     apiPath: string;
+    fetchPolicy: FetchPolicy;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "configKey": "zenstack",
   "builder": {
     "@nuxt/module-builder": "1.0.2",

package/dist/module.mjs

@@ -1,9 +1,9 @@
-import { defineNuxtModule, createResolver, addServerImports, addTemplate, addServerTemplate, addTypeTemplate, addServerHandler, addImportsDir } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addTemplate, addServerTemplate, addTypeTemplate, addServerHandler, addImportsDir } from '@nuxt/kit';
 import { joinURL } from 'ufo';
 import { defu } from 'defu';
 
 const name = "@bg-dev/nuxt-zenstack";
-const version = "0.0.2";
+const version = "0.0.4";
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -13,20 +13,17 @@ const module$1 = defineNuxtModule({
   },
   // Default configuration options of the Nuxt module
   defaults: {
-    apiPath: "/api/_zenstack"
+    apiPath: "/api/_zenstack",
+    fetchPolicy: "cache-first"
   },
   setup(_options, _nuxt) {
     _nuxt.options.runtimeConfig.public = defu(_nuxt.options.runtimeConfig.public, {
       zenstack: {
-        apiPath: _options.apiPath
+        apiPath: _options.apiPath,
+        fetchPolicy: _options.fetchPolicy
       }
     });
     const resolver = createResolver(import.meta.url);
-    addServerImports({
-      from: resolver.resolve("./runtime/server/utils"),
-      name: "provideClient",
-      as: "provideZenstackClient"
-    });
     addTemplate({
       write: true,
       filename: "nuxt-zenstack.mjs",
@@ -43,9 +40,11 @@ export { schema as zenstackSchema } from '~~/zenstack/schema'
     addTypeTemplate({
       filename: "types/nuxt-zenstack.d.ts",
       getContents: () => `
-import type { ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, SimplifiedPlainResult, SelectIncludeOmit, QueryOptions, CreateArgs, UpdateArgs } from '@zenstackhq/orm'
+import type { ClientContract, ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, SimplifiedPlainResult, SelectIncludeOmit, QueryOptions, CreateArgs, UpdateArgs } from '@zenstackhq/orm'
 import type { SchemaType } from '~~/zenstack/schema'
 import type { ModelDef } from '@zenstackhq/orm/schema'
+import type { H3Error } from 'h3'
+import { ORMError, RejectedByPolicyReason, ORMErrorReason } from '@zenstackhq/orm'
 
 type ItemGetPayload<Zmodel extends $Zmodel, Args extends SelectIncludeOmit<SchemaType, Zmodel, true>, Options extends QueryOptions<SchemaType> = QueryOptions<SchemaType>> = SimplifiedPlainResult<SchemaType, Zmodel, Args, Options>
 
@@ -54,12 +53,28 @@ export type $Zmodel = keyof SchemaType['models']
 export type $Zdef = ModelDef
 export type $Zoperations<Zmodel extends $Zmodel> = ModelOperations<SchemaType, Zmodel>
 export type $Zid<Zmodel extends $Zmodel> = ModelResult<SchemaType, Zmodel> extends { id: infer Id } ? Id : never
-export type $Zinclude<Zmodel extends $Zmodel> = IncludeInput<SchemaType, Zmodel>
-export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel> = never> = ItemGetPayload<Zmodel, { include: Zinclude }>
-export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel>
-export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy']
+export type $Zinclude<Zmodel extends $Zmodel> = IncludeInput<SchemaType, Zmodel> | undefined
+export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude = undefined> = ItemGetPayload<Zmodel, { include: Zinclude }>
+export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel> | undefined
+export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy'] | undefined
 export type $ZcreateData<Zmodel extends $Zmodel> = CreateArgs<SchemaType, Zmodel>['data']
 export type $ZupdateData<Zmodel extends $Zmodel> = UpdateArgs<SchemaType, Zmodel>['data']
+export type $ZormError = ORMError
+export type $Zerror = H3Error<{
+  ormErrorReason: ORMErrorReason
+  dbErrorCode?: unknown
+  dbErrorMessage?: string
+  model?: string
+  rejectedByPolicyReason?: RejectedByPolicyReason
+}>
+
+declare module 'h3' {
+  interface H3EventContext {
+    zenstack: {
+      client: ClientContract<SchemaType>
+    }
+  }
+}
 `
     });
     addServerHandler({

package/dist/runtime/composables/common.d.ts

@@ -1,13 +1,11 @@
 export type Status = 'idle' | 'pending' | 'success' | 'error';
 export type FetchPolicy = 'cache-first' | 'fetch-only' | 'cache-only' | 'cache-and-fetch';
-export type Error = {
-    error: boolean;
-    url: string;
-    statusCode: number;
-    statusMessage: string;
-    message: string;
-    stack?: string[];
-};
 export declare function getConfig(): {
     apiPath: string;
+    fetchPolicy: FetchPolicy;
 };
+/**
+ * @param instance a custom fetch method created by `$fetch.create`
+ */
+export declare function provideFetch(instance: typeof $fetch): void;
+export declare function getFetch(): import("nitropack/types").$Fetch<unknown, import("nitropack/types").NitroFetchRequest>;

package/dist/runtime/composables/common.js

@@ -3,3 +3,10 @@ export function getConfig() {
   const config = useRuntimeConfig();
   return config.public.zenstack;
 }
+let _fetch = $fetch;
+export function provideFetch(instance) {
+  _fetch = instance;
+}
+export function getFetch() {
+  return _fetch;
+}

package/dist/runtime/composables/index.d.ts

@@ -3,3 +3,4 @@ export { useZenstackReadMany } from './useZenstackReadMany/index.js';
 export { useZenstackRead } from './useZenstackRead/index.js';
 export { useZenstackDelete } from './useZenstackDelete/index.js';
 export { useZenstackUpdate } from './useZenstackUpdate/index.js';
+export { provideFetch as provideZenstackFetch } from './common.js';

package/dist/runtime/composables/index.js

@@ -3,3 +3,4 @@ export { useZenstackReadMany } from "./useZenstackReadMany/index.js";
 export { useZenstackRead } from "./useZenstackRead/index.js";
 export { useZenstackDelete } from "./useZenstackDelete/index.js";
 export { useZenstackUpdate } from "./useZenstackUpdate/index.js";
+export { provideFetch as provideZenstackFetch } from "./common.js";

package/dist/runtime/composables/useZenstackCreate/index.d.ts

@@ -1,9 +1,9 @@
-import type { $Zmodel, $Zitem, $ZcreateData } from '#build/types/nuxt-zenstack';
-import type { Status, Error } from '../common.js';
+import type { $Zmodel, $Zitem, $ZcreateData, $Zerror } from '#build/types/nuxt-zenstack';
+import type { Status } from '../common.js';
 import { type Ref } from '#imports';
 export declare function useZenstackCreate<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;
-    error: Ref<Error | null>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     mutate: (input: $ZcreateData<Zmodel>) => Promise<void>;
     reset: () => void;

package/dist/runtime/composables/useZenstackCreate/index.js

@@ -1,4 +1,4 @@
-import { getConfig } from "../common.js";
+import { getConfig, getFetch } from "../common.js";
 import { ref } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
@@ -14,17 +14,19 @@ export function useZenstackCreate(model) {
     status.value = "idle";
   }
   async function mutate(input) {
+    const _fetch = getFetch();
     const url = joinURL(config.apiPath, `/models/${model.toString()}`);
+    const method = "POST";
+    const body = { data: input };
+    store.addToFetchHistory({
+      model: model.toString(),
+      method,
+      body: JSON.stringify(body)
+    });
     reset();
     status.value = "pending";
     try {
-      const res = await $fetch(url, {
-        method: "POST",
-        body: {
-          data: input
-          // TODO: maybe include relations
-        }
-      });
+      const res = await _fetch(url, { method, body });
       if (res.data)
         store.setOne(model, res.data);
       data.value = res.data;

package/dist/runtime/composables/useZenstackDelete/index.d.ts

@@ -1,9 +1,9 @@
-import type { $Zmodel, $Zitem, $Zid } from '#build/types/nuxt-zenstack';
-import type { Status, Error } from '../common.js';
+import type { $Zmodel, $Zitem, $Zid, $Zerror } from '#build/types/nuxt-zenstack';
+import type { Status } from '../common.js';
 import { type Ref } from '#imports';
 export declare function useZenstackDelete<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;
-    error: Ref<Error | null>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     mutate: (id: $Zid<Zmodel>) => Promise<void>;
     reset: () => void;

package/dist/runtime/composables/useZenstackDelete/index.js

@@ -1,7 +1,7 @@
 import { ref } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
-import { getConfig } from "../common.js";
+import { getConfig, getFetch } from "../common.js";
 export function useZenstackDelete(model) {
   const data = ref(null);
   const error = ref(null);
@@ -14,13 +14,18 @@ export function useZenstackDelete(model) {
     status.value = "idle";
   }
   async function mutate(id) {
+    const _fetch = getFetch();
     const url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
+    const method = "DELETE";
+    store.addToFetchHistory({
+      model: model.toString(),
+      id,
+      method
+    });
     reset();
     status.value = "pending";
     try {
-      const res = await $fetch(url, {
-        method: "DELETE"
-      });
+      const res = await _fetch(url, { method });
       store.deleteOne(model, id);
       data.value = res.data;
       status.value = "success";

package/dist/runtime/composables/useZenstackRead/index.d.ts

@@ -1,7 +1,7 @@
-import type { $Zmodel, $Zitem, $Zid, $Zinclude } from '#build/types/nuxt-zenstack';
+import type { $Zmodel, $Zitem, $Zid, $Zinclude, $Zerror } from '#build/types/nuxt-zenstack';
 import type { Status, FetchPolicy } from '../common.js';
-import type { Ref, MaybeRefOrGetter } from '#imports';
-type Options<Zmodel extends $Zmodel> = {
+import type { Ref } from '#imports';
+type Options<Zinclude> = {
     /**
      * - `cache-first` means that the query will first try to fetch the data from the store. If the data is not found in the store, it will fetch the data from the server and update the store.
      * - `cache-and-fetch` means that the query will first try to fetch the data from the cache. It will then fetch the data from the server and update the cache.
@@ -19,12 +19,12 @@ type Options<Zmodel extends $Zmodel> = {
      * The relations to include in the query.
      * @default undefined
      */
-    include?: MaybeRefOrGetter<$Zinclude<Zmodel>>;
+    include?: Zinclude;
 };
-export declare function useZenstackRead<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel, id: $Zid<Zmodel>, opts?: Options<Zmodel>): {
+export declare function useZenstackRead<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>, Zitem extends $Zitem<Zmodel, Zinclude>>(model: Zmodel, id: $Zid<Zmodel>, opts?: Options<Zinclude>): Promise<{
     data: Ref<Zitem | null>;
-    error: Ref<Error | null>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     refetch: () => Promise<void>;
-};
+}>;
 export {};

package/dist/runtime/composables/useZenstackRead/index.js

@@ -1,57 +1,66 @@
-import { ref, toValue, watch, isRef } from "#imports";
+import { ref, watch, useNuxtApp } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
 import { stringify } from "superjson";
-import { getConfig } from "../common.js";
-export function useZenstackRead(model, id, opts = {}) {
+import { getConfig, getFetch } from "../common.js";
+export async function useZenstackRead(model, id, opts = {}) {
   const data = ref(null);
   const error = ref(null);
   const status = ref("idle");
   const store = useZenstackStore();
   const config = getConfig();
-  opts.fetchPolicy ??= "cache-first";
+  const nuxtApp = useNuxtApp();
+  const method = "GET";
+  opts.fetchPolicy ??= config.fetchPolicy;
   opts.immediate ??= true;
-  switch (opts.fetchPolicy) {
-    case "cache-first":
-      updateData();
-      if (data.value) opts.immediate = false;
-      break;
-    case "cache-and-fetch":
-      updateData();
-      break;
-    case "cache-only":
-      updateData();
-      opts.immediate = false;
-      break;
-  }
-  const watchedOptions = [opts.include].filter((option) => isRef(option) || typeof option === "function");
+  if (opts.fetchPolicy !== "fetch-only")
+    updateData();
   watch(store.state, () => updateData());
-  watch(watchedOptions, () => refetch());
-  if (opts.immediate)
-    refetch();
+  if (shouldFetchInitially())
+    await refetch();
+  function canFetchAutomatically() {
+    const entry = store.fetchHistory.value.find((entry2) => entry2.model === model && entry2.id === id && entry2.method === method && entry2.query === JSON.stringify(getQuery()));
+    if (entry?.ssr && nuxtApp.isHydrating)
+      return false;
+    if (opts.fetchPolicy === "cache-first" && entry)
+      return false;
+    return true;
+  }
+  function shouldFetchInitially() {
+    if (opts.immediate === false)
+      return false;
+    return canFetchAutomatically();
+  }
   function updateData() {
     data.value = store.getOne(model, id);
   }
+  function getQuery() {
+    const json = stringify({
+      include: opts.include
+    });
+    return { q: json };
+  }
   async function refetch() {
     if (opts.fetchPolicy === "cache-only")
       return;
+    const _fetch = getFetch();
     const url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
-    const json = stringify({
-      include: toValue(opts.include)
+    const query = getQuery();
+    store.addToFetchHistory({
+      model: model.toString(),
+      id,
+      method,
+      query: JSON.stringify(query)
     });
     error.value = null;
     status.value = "pending";
     try {
-      const res = await $fetch(url, {
-        method: "GET",
-        query: {
-          q: json
-        }
-      });
+      const res = await _fetch(url, { method, query });
       if (res.data)
         store.setOne(model, res.data);
       else
         store.deleteOne(model, id);
+      updateData();
       status.value = "success";
     } catch (err) {
       error.value = err.data;

package/dist/runtime/composables/useZenstackReadMany/index.d.ts

@@ -1,7 +1,7 @@
-import type { $Zmodel, $Zitem, $Zinclude, $Zwhere, $ZorderBy } from '#build/types/nuxt-zenstack';
+import type { $Zmodel, $Zitem, $Zinclude, $Zwhere, $ZorderBy, $Zerror } from '#build/types/nuxt-zenstack';
 import type { Status, FetchPolicy } from '../common.js';
 import type { MaybeRefOrGetter, Ref } from '#imports';
-type Options<Zmodel extends $Zmodel> = {
+type Options<Zinclude, Zwhere, ZorderBy> = {
     /**
      * - `cache-first` means that the query will first try to fetch the data from the store. If the data is not found in the store, it will fetch the data from the server and update the store.
      * - `cache-and-fetch` means that the query will first try to fetch the data from the cache. It will then fetch the data from the server and update the cache.
@@ -19,17 +19,17 @@ type Options<Zmodel extends $Zmodel> = {
      * The relations to include in the query.
      * @default undefined
      */
-    include?: MaybeRefOrGetter<$Zinclude<Zmodel>>;
+    include?: Zinclude;
     /**
      * The filter to apply to the query.
      * @default undefined
      */
-    where?: MaybeRefOrGetter<$Zwhere<Zmodel>>;
+    where?: MaybeRefOrGetter<Zwhere>;
     /**
      * The order to apply to the query.
      * @default undefined
      */
-    orderBy?: MaybeRefOrGetter<$ZorderBy<Zmodel>>;
+    orderBy?: MaybeRefOrGetter<ZorderBy>;
     /**
      * The number of items to skip.
      * @default 0
@@ -41,10 +41,11 @@ type Options<Zmodel extends $Zmodel> = {
      */
     take?: MaybeRefOrGetter<number>;
 };
-export declare function useZenstackReadMany<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel, opts?: Options<Zmodel>): {
+export declare function useZenstackReadMany<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>, Zitem extends $Zitem<Zmodel, Zinclude>, Zwhere extends $Zwhere<Zmodel>, ZorderBy extends $ZorderBy<Zmodel>>(model: Zmodel, opts?: Options<Zinclude, Zwhere, ZorderBy>): Promise<{
     data: Ref<Zitem[] | null>;
-    error: Ref<Error | null>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
+    canFetchMore: Ref<boolean>;
     refetch: () => Promise<void>;
-};
+}>;
 export {};

package/dist/runtime/composables/useZenstackReadMany/index.js

@@ -1,68 +1,88 @@
-import { ref, toValue, watch, isRef } from "#imports";
+import { ref, toValue, watch, isRef, useNuxtApp } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
 import { stringify } from "superjson";
-import { getConfig } from "../common.js";
-export function useZenstackReadMany(model, opts = {}) {
+import { getConfig, getFetch } from "../common.js";
+import { sort } from "./orderBy.js";
+import { matchesWhere } from "./where.js";
+export async function useZenstackReadMany(model, opts = {}) {
   const data = ref(null);
   const error = ref(null);
   const status = ref("idle");
+  const canFetchMore = ref(true);
   const store = useZenstackStore();
   const config = getConfig();
-  opts.fetchPolicy ??= "cache-first";
+  const nuxtApp = useNuxtApp();
+  const watchedOptions = [opts.where, opts.orderBy, opts.skip, opts.take].filter((option) => isRef(option) || typeof option === "function");
+  const method = "GET";
+  opts.fetchPolicy ??= config.fetchPolicy;
   opts.immediate ??= true;
   opts.skip ??= 0;
   opts.take ??= 1e3;
-  switch (opts.fetchPolicy) {
-    case "cache-first":
-      updateData();
-      if (data.value?.length) opts.immediate = false;
-      break;
-    case "cache-and-fetch":
-      updateData();
-      break;
-    case "cache-only":
-      updateData();
-      opts.immediate = false;
-      break;
-  }
-  const watchedOptions = [opts.include, opts.where, opts.orderBy, opts.skip, opts.take].filter((option) => isRef(option) || typeof option === "function");
+  if (opts.fetchPolicy !== "fetch-only")
+    updateData();
   watch(store.state, () => updateData());
   watch(watchedOptions, () => {
     updateData();
-    refetch();
+    if (canFetchAutomatically())
+      refetch();
   });
-  if (opts.immediate)
-    refetch();
+  if (shouldFetchInitially())
+    await refetch();
+  function canFetchAutomatically() {
+    const entry = store.fetchHistory.value.find((entry2) => entry2.model === model && entry2.method === method && entry2.query === JSON.stringify(getQuery()));
+    if (entry?.ssr && nuxtApp.isHydrating)
+      return false;
+    if (opts.fetchPolicy === "cache-first" && entry)
+      return false;
+    return true;
+  }
+  function shouldFetchInitially() {
+    if (opts.immediate === false)
+      return false;
+    return canFetchAutomatically();
+  }
   function updateData() {
-    data.value = store.getMany(model);
+    const items = store.getMany(model);
+    const filteredItems = items.filter((el) => matchesWhere(el, toValue(opts.where)));
+    const orderedFilteredItems = sort(filteredItems, toValue(opts.orderBy));
+    data.value = orderedFilteredItems;
   }
-  async function refetch() {
-    if (opts.fetchPolicy === "cache-only")
-      return;
-    const url = joinURL(config.apiPath, `/models/${model.toString()}`);
+  function getQuery() {
     const json = stringify({
-      include: toValue(opts.include),
+      include: opts.include,
       where: toValue(opts.where),
       orderBy: toValue(opts.orderBy),
       skip: toValue(opts.skip),
       take: toValue(opts.take)
     });
+    return { q: json };
+  }
+  async function refetch() {
+    if (opts.fetchPolicy === "cache-only")
+      return;
+    const _fetch = getFetch();
+    const url = joinURL(config.apiPath, `/models/${model.toString()}`);
+    const query = getQuery();
+    store.addToFetchHistory({
+      model: model.toString(),
+      method,
+      query: JSON.stringify(query)
+    });
     error.value = null;
     status.value = "pending";
+    canFetchMore.value = false;
     try {
-      const res = await $fetch(url, {
-        method: "GET",
-        query: {
-          q: json
-        }
-      });
+      const res = await _fetch(url, { method, query });
       store.setMany(model, res.data);
+      updateData();
       status.value = "success";
+      canFetchMore.value = res.data.length === toValue(opts.take);
     } catch (err) {
       error.value = err.data;
       status.value = "error";
+      canFetchMore.value = true;
     }
   }
-  return { data, error, status, refetch };
+  return { data, error, status, canFetchMore, refetch };
 }

package/dist/runtime/composables/useZenstackReadMany/orderBy.d.ts

@@ -0,0 +1,5 @@
+import type { $Zitem, $ZorderBy, $Zinclude, $Zmodel } from '#build/types/nuxt-zenstack';
+/**
+ * @note Sort by relational fields not supported
+ */
+export declare function sort<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>, Zitem extends $Zitem<Zmodel, Zinclude>>(items: Zitem[], orderBy: $ZorderBy<Zmodel>): Zitem[];

package/dist/runtime/composables/useZenstackReadMany/orderBy.js

@@ -0,0 +1,25 @@
+export function sort(items, orderBy) {
+  if (!items.length || !orderBy)
+    return items;
+  return items.sort((a, b) => {
+    const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+    for (const orderByObj of orderByArray) {
+      const orderByEntries = Object.entries(orderByObj);
+      for (const [field, direction] of orderByEntries) {
+        if (direction !== "asc" && direction !== "desc") continue;
+        const aValue = a[field];
+        const bValue = b[field];
+        if (aValue == null && bValue == null) continue;
+        if (aValue == null) return 1;
+        if (bValue == null) return -1;
+        let comparison = 0;
+        if (aValue < bValue) comparison = -1;
+        else if (aValue > bValue) comparison = 1;
+        if (comparison !== 0) {
+          return direction === "asc" ? comparison : -comparison;
+        }
+      }
+    }
+    return 0;
+  });
+}

package/dist/runtime/composables/useZenstackReadMany/where.d.ts

@@ -0,0 +1,2 @@
+import type { $Zitem, $Zwhere, $Zinclude, $Zmodel } from '#build/types/nuxt-zenstack';
+export declare function matchesWhere<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>>(item: $Zitem<Zmodel, Zinclude>, where: $Zwhere<Zmodel>): boolean;