@directus/api 21.0.0-rc.0 → 21.0.1

package/dist/utils/get-schema.js

@@ -4,7 +4,7 @@ import { systemCollectionRows } from '@directus/system-data';
 import { parseJSON, toArray } from '@directus/utils';
 import { mapValues } from 'lodash-es';
 import { useBus } from '../bus/index.js';
-import { getSchemaCache, setSchemaCache } from '../cache.js';
+import { getLocalSchemaCache, setLocalSchemaCache } from '../cache.js';
 import { ALIAS_TYPES } from '../constants.js';
 import getDatabase from '../database/index.js';
 import { useLock } from '../lock/index.js';
@@ -17,18 +17,18 @@ const logger = useLogger();
 export async function getSchema(options, attempt = 0) {
     const MAX_ATTEMPTS = 3;
     const env = useEnv();
-    if (attempt >= MAX_ATTEMPTS) {
-        throw new Error(`Failed to get Schema information: hit infinite loop`);
-    }
     if (options?.bypassCache || env['CACHE_SCHEMA'] === false) {
         const database = options?.database || getDatabase();
         const schemaInspector = createInspector(database);
         return await getDatabaseSchema(database, schemaInspector);
     }
-    const cached = await getSchemaCache();
+    const cached = await getLocalSchemaCache();
     if (cached) {
         return cached;
     }
+    if (attempt >= MAX_ATTEMPTS) {
+        throw new Error(`Failed to get Schema information: hit infinite loop`);
+    }
     const lock = useLock();
     const bus = useBus();
     const lockKey = 'schemaCache--preparing';
@@ -40,39 +40,34 @@ export async function getSchema(options, attempt = 0) {
     const currentProcessShouldHandleOperation = processId === 1;
     if (currentProcessShouldHandleOperation === false) {
         logger.trace('Schema cache is prepared in another process, waiting for result.');
-        return new Promise((resolve, reject) => {
-            const TIMEOUT = 10000;
-            const timeout = setTimeout(() => {
-                logger.trace('Did not receive schema callback message in time. Pulling schema...');
-                callback().catch(reject);
-            }, TIMEOUT);
-            bus.subscribe(messageKey, callback);
-            async function callback() {
-                try {
-                    if (timeout)
-                        clearTimeout(timeout);
-                    const schema = await getSchema(options, attempt + 1);
-                    resolve(schema);
-                }
-                catch (error) {
-                    reject(error);
-                }
-                finally {
-                    bus.unsubscribe(messageKey, callback);
+        const timeout = new Promise((_, reject) => setTimeout(reject, env['CACHE_SCHEMA_SYNC_TIMEOUT']));
+        const subscription = new Promise((resolve, reject) => {
+            bus.subscribe(messageKey, busListener).catch(reject);
+            function busListener(options) {
+                if (options.schema === null) {
+                    return reject();
                 }
+                cleanup();
+                setLocalSchemaCache(options.schema).catch(reject);
+                resolve(options.schema);
+            }
+            function cleanup() {
+                bus.unsubscribe(messageKey, busListener).catch(reject);
             }
         });
+        return Promise.race([timeout, subscription]).catch(() => getSchema(options, attempt + 1));
     }
+    let schema = null;
     try {
         const database = options?.database || getDatabase();
         const schemaInspector = createInspector(database);
-        const schema = await getDatabaseSchema(database, schemaInspector);
-        await setSchemaCache(schema);
+        schema = await getDatabaseSchema(database, schemaInspector);
+        await setLocalSchemaCache(schema);
         return schema;
     }
     finally {
+        await bus.publish(messageKey, { schema });
         await lock.delete(lockKey);
-        bus.publish(messageKey, { ready: true });
     }
 }
 async function getDatabaseSchema(database, schemaInspector) {

package/dist/utils/get-service.js

@@ -1,13 +1,11 @@
 import { ForbiddenError } from '@directus/errors';
-import { AccessService, ActivityService, DashboardsService, FilesService, FlowsService, FoldersService, ItemsService, NotificationsService, OperationsService, PanelsService, PermissionsService, PoliciesService, PresetsService, RevisionsService, RolesService, SettingsService, SharesService, TranslationsService, UsersService, VersionsService, WebhooksService, } from '../services/index.js';
+import { ActivityService, DashboardsService, FilesService, FlowsService, FoldersService, ItemsService, NotificationsService, OperationsService, PanelsService, PermissionsService, PresetsService, RevisionsService, RolesService, SettingsService, SharesService, TranslationsService, UsersService, VersionsService, WebhooksService, } from '../services/index.js';
 /**
  * Select the correct service for the given collection. This allows the individual services to run
  * their custom checks (f.e. it allows `UsersService` to prevent updating TFA secret from outside).
  */
 export function getService(collection, opts) {
     switch (collection) {
-        case 'directus_access':
-            return new AccessService(opts);
         case 'directus_activity':
             return new ActivityService(opts);
         case 'directus_dashboards':
@@ -28,8 +26,6 @@ export function getService(collection, opts) {
             return new PermissionsService(opts);
         case 'directus_presets':
             return new PresetsService(opts);
-        case 'directus_policies':
-            return new PoliciesService(opts);
         case 'directus_revisions':
             return new RevisionsService(opts);
         case 'directus_roles':

package/dist/utils/merge-permissions-for-share.d.ts

@@ -0,0 +1,4 @@
+import type { Accountability, Filter, Permission, SchemaOverview } from '@directus/types';
+export declare function mergePermissionsForShare(currentPermissions: Permission[], accountability: Accountability, schema: SchemaOverview): Permission[];
+export declare function traverse(schema: SchemaOverview, rootItemPrimaryKeyField: string, rootItemPrimaryKey: string, currentCollection: string, parentCollections?: string[], path?: string[]): Partial<Permission>[];
+export declare function getFilterForPath(type: 'o2m' | 'm2o' | 'a2o', path: string[], rootPrimaryKeyField: string, rootPrimaryKey: string): Filter;

package/dist/utils/merge-permissions-for-share.js

@@ -0,0 +1,109 @@
+import { assign, set, uniq } from 'lodash-es';
+import { schemaPermissions } from '@directus/system-data';
+import { mergePermissions } from './merge-permissions.js';
+import { reduceSchema } from './reduce-schema.js';
+export function mergePermissionsForShare(currentPermissions, accountability, schema) {
+    const defaults = {
+        action: 'read',
+        role: accountability.role,
+        collection: '',
+        permissions: {},
+        validation: null,
+        presets: null,
+        fields: null,
+    };
+    const { collection, item } = accountability.share_scope;
+    const parentPrimaryKeyField = schema.collections[collection].primary;
+    const reducedSchema = reduceSchema(schema, currentPermissions, ['read']);
+    const relationalPermissions = traverse(reducedSchema, parentPrimaryKeyField, item, collection);
+    const parentCollectionPermission = assign({}, defaults, {
+        collection,
+        permissions: {
+            [parentPrimaryKeyField]: {
+                _eq: item,
+            },
+        },
+    });
+    // All permissions that will be merged into the original permissions set
+    const allGeneratedPermissions = [
+        parentCollectionPermission,
+        ...relationalPermissions.map((generated) => assign({}, defaults, generated)),
+        ...schemaPermissions,
+    ];
+    // All the collections that are touched through the relational tree from the current root collection, and the schema collections
+    const allowedCollections = uniq(allGeneratedPermissions.map(({ collection }) => collection));
+    const generatedPermissions = [];
+    // Merge all the permissions that relate to the same collection with an _or (this allows you to properly retrieve)
+    // the items of a collection if you entered that collection from multiple angles
+    for (const collection of allowedCollections) {
+        const permissionsForCollection = allGeneratedPermissions.filter((permission) => permission.collection === collection);
+        if (permissionsForCollection.length > 0) {
+            generatedPermissions.push(...mergePermissions('or', permissionsForCollection));
+        }
+        else {
+            generatedPermissions.push(...permissionsForCollection);
+        }
+    }
+    // Explicitly filter out permissions to collections unrelated to the root parent item.
+    const limitedPermissions = currentPermissions.filter(({ action, collection }) => allowedCollections.includes(collection) && action === 'read');
+    return mergePermissions('and', limitedPermissions, generatedPermissions);
+}
+export function traverse(schema, rootItemPrimaryKeyField, rootItemPrimaryKey, currentCollection, parentCollections = [], path = []) {
+    const permissions = [];
+    // If there's already a permissions rule for the collection we're currently checking, we'll shortcircuit.
+    // This prevents infinite loop in recursive relationships, like articles->related_articles->articles, or
+    // articles.author->users.avatar->files.created_by->users.avatar->files.created_by->🔁
+    if (parentCollections.includes(currentCollection)) {
+        return permissions;
+    }
+    const relationsInCollection = schema.relations.filter((relation) => {
+        return relation.collection === currentCollection || relation.related_collection === currentCollection;
+    });
+    for (const relation of relationsInCollection) {
+        let type;
+        if (relation.related_collection === currentCollection) {
+            type = 'o2m';
+        }
+        else if (!relation.related_collection) {
+            type = 'a2o';
+        }
+        else {
+            type = 'm2o';
+        }
+        if (type === 'o2m') {
+            permissions.push({
+                collection: relation.collection,
+                permissions: getFilterForPath(type, [...path, relation.field], rootItemPrimaryKeyField, rootItemPrimaryKey),
+            });
+            permissions.push(...traverse(schema, rootItemPrimaryKeyField, rootItemPrimaryKey, relation.collection, [...parentCollections, currentCollection], [...path, relation.field]));
+        }
+        if (type === 'a2o' && relation.meta?.one_allowed_collections) {
+            for (const collection of relation.meta.one_allowed_collections) {
+                permissions.push({
+                    collection,
+                    permissions: getFilterForPath(type, [...path, `$FOLLOW(${relation.collection},${relation.field},${relation.meta.one_collection_field})`], rootItemPrimaryKeyField, rootItemPrimaryKey),
+                });
+            }
+        }
+        if (type === 'm2o') {
+            permissions.push({
+                collection: relation.related_collection,
+                permissions: getFilterForPath(type, [...path, `$FOLLOW(${relation.collection},${relation.field})`], rootItemPrimaryKeyField, rootItemPrimaryKey),
+            });
+            if (relation.meta?.one_field) {
+                permissions.push(...traverse(schema, rootItemPrimaryKeyField, rootItemPrimaryKey, relation.related_collection, [...parentCollections, currentCollection], [...path, relation.meta?.one_field]));
+            }
+        }
+    }
+    return permissions;
+}
+export function getFilterForPath(type, path, rootPrimaryKeyField, rootPrimaryKey) {
+    const filter = {};
+    if (type === 'm2o' || type === 'a2o') {
+        set(filter, path.reverse(), { [rootPrimaryKeyField]: { _eq: rootPrimaryKey } });
+    }
+    else {
+        set(filter, path.reverse(), { _eq: rootPrimaryKey });
+    }
+    return filter;
+}

package/dist/utils/merge-permissions.d.ts

@@ -0,0 +1,3 @@
+import type { Permission } from '@directus/types';
+export declare function mergePermissions(strategy: 'and' | 'or', ...permissions: Permission[][]): Permission[];
+export declare function mergePermission(strategy: 'and' | 'or', currentPerm: Permission, newPerm: Permission): Omit<Permission, 'id' | 'system'>;

package/dist/utils/merge-permissions.js

@@ -0,0 +1,95 @@
+import { flatten, intersection, isEqual, merge, omit } from 'lodash-es';
+export function mergePermissions(strategy, ...permissions) {
+    const allPermissions = flatten(permissions);
+    const mergedPermissions = allPermissions
+        .reduce((acc, val) => {
+        const key = `${val.collection}__${val.action}__${val.role || '$PUBLIC'}`;
+        const current = acc.get(key);
+        acc.set(key, current ? mergePermission(strategy, current, val) : val);
+        return acc;
+    }, new Map())
+        .values();
+    return Array.from(mergedPermissions);
+}
+export function mergePermission(strategy, currentPerm, newPerm) {
+    const logicalKey = `_${strategy}`;
+    let permissions = currentPerm.permissions;
+    let validation = currentPerm.validation;
+    let fields = currentPerm.fields;
+    let presets = currentPerm.presets;
+    if (newPerm.permissions) {
+        if (currentPerm.permissions && Object.keys(currentPerm.permissions)[0] === logicalKey) {
+            permissions = {
+                [logicalKey]: [
+                    ...currentPerm.permissions[logicalKey],
+                    newPerm.permissions,
+                ],
+            };
+        }
+        else if (currentPerm.permissions) {
+            // Empty {} supersedes other permissions in _OR merge
+            if (strategy === 'or' && (isEqual(currentPerm.permissions, {}) || isEqual(newPerm.permissions, {}))) {
+                permissions = {};
+            }
+            else {
+                permissions = {
+                    [logicalKey]: [currentPerm.permissions, newPerm.permissions],
+                };
+            }
+        }
+        else {
+            permissions = {
+                [logicalKey]: [newPerm.permissions],
+            };
+        }
+    }
+    if (newPerm.validation) {
+        if (currentPerm.validation && Object.keys(currentPerm.validation)[0] === logicalKey) {
+            validation = {
+                [logicalKey]: [
+                    ...currentPerm.validation[logicalKey],
+                    newPerm.validation,
+                ],
+            };
+        }
+        else if (currentPerm.validation) {
+            // Empty {} supersedes other validations in _OR merge
+            if (strategy === 'or' && (isEqual(currentPerm.validation, {}) || isEqual(newPerm.validation, {}))) {
+                validation = {};
+            }
+            else {
+                validation = {
+                    [logicalKey]: [currentPerm.validation, newPerm.validation],
+                };
+            }
+        }
+        else {
+            validation = {
+                [logicalKey]: [newPerm.validation],
+            };
+        }
+    }
+    if (newPerm.fields) {
+        if (Array.isArray(currentPerm.fields) && strategy === 'or') {
+            fields = [...new Set([...currentPerm.fields, ...newPerm.fields])];
+        }
+        else if (Array.isArray(currentPerm.fields) && strategy === 'and') {
+            fields = intersection(currentPerm.fields, newPerm.fields);
+        }
+        else {
+            fields = newPerm.fields;
+        }
+        if (fields.includes('*'))
+            fields = ['*'];
+    }
+    if (newPerm.presets) {
+        presets = merge({}, presets, newPerm.presets);
+    }
+    return omit({
+        ...currentPerm,
+        permissions,
+        validation,
+        fields,
+        presets,
+    }, ['id', 'system']);
+}

package/dist/utils/reduce-schema.d.ts

@@ -1,7 +1,9 @@
-import type { SchemaOverview } from '@directus/types';
-import type { FieldMap } from '../permissions/modules/fetch-allowed-field-map/fetch-allowed-field-map.js';
+import type { Permission, PermissionsAction, SchemaOverview } from '@directus/types';
 /**
  * Reduces the schema based on the included permissions. The resulting object is the schema structure, but with only
- * the allowed collections/fields/relations included based on the passed field map.
+ * the allowed collections/fields/relations included based on the permissions.
+ * @param schema The full project schema
+ * @param actions Array of permissions actions (crud)
+ * @returns Reduced schema
  */
-export declare function reduceSchema(schema: SchemaOverview, fieldMap: FieldMap): SchemaOverview;
+export declare function reduceSchema(schema: SchemaOverview, permissions: Permission[] | null, actions?: PermissionsAction[]): SchemaOverview;

package/dist/utils/reduce-schema.js

@@ -1,24 +1,40 @@
+import { uniq } from 'lodash-es';
 /**
  * Reduces the schema based on the included permissions. The resulting object is the schema structure, but with only
- * the allowed collections/fields/relations included based on the passed field map.
+ * the allowed collections/fields/relations included based on the permissions.
+ * @param schema The full project schema
+ * @param actions Array of permissions actions (crud)
+ * @returns Reduced schema
  */
-export function reduceSchema(schema, fieldMap) {
+export function reduceSchema(schema, permissions, actions = ['create', 'read', 'update', 'delete']) {
     const reduced = {
         collections: {},
         relations: [],
     };
+    const allowedFieldsInCollection = permissions
+        ?.filter((permission) => actions.includes(permission.action))
+        .reduce((acc, permission) => {
+        if (!acc[permission.collection]) {
+            acc[permission.collection] = [];
+        }
+        if (permission.fields) {
+            acc[permission.collection] = uniq([...acc[permission.collection], ...permission.fields]);
+        }
+        return acc;
+    }, {}) ?? {};
     for (const [collectionName, collection] of Object.entries(schema.collections)) {
-        if (!fieldMap[collectionName]) {
-            // Collection is not allowed at all
+        if (!permissions?.some((permission) => permission.collection === collectionName && actions.includes(permission.action))) {
             continue;
         }
         const fields = {};
         for (const [fieldName, field] of Object.entries(schema.collections[collectionName].fields)) {
-            if (!fieldMap[collectionName]?.includes('*') && !fieldMap[collectionName]?.includes(fieldName)) {
+            if (!allowedFieldsInCollection[collectionName]?.includes('*') &&
+                !allowedFieldsInCollection[collectionName]?.includes(fieldName)) {
                 continue;
             }
             const o2mRelation = schema.relations.find((relation) => relation.related_collection === collectionName && relation.meta?.one_field === fieldName);
-            if (o2mRelation && !fieldMap[collectionName]) {
+            if (o2mRelation &&
+                !permissions?.some((permission) => permission.collection === o2mRelation.collection && actions.includes(permission.action))) {
                 continue;
             }
             fields[fieldName] = field;
@@ -31,29 +47,29 @@ export function reduceSchema(schema, fieldMap) {
     reduced.relations = schema.relations.filter((relation) => {
         let collectionsAllowed = true;
         let fieldsAllowed = true;
-        if (Object.keys(fieldMap).includes(relation.collection) === false) {
+        if (Object.keys(allowedFieldsInCollection).includes(relation.collection) === false) {
             collectionsAllowed = false;
         }
         if (relation.related_collection &&
-            (Object.keys(fieldMap).includes(relation.related_collection) === false ||
+            (Object.keys(allowedFieldsInCollection).includes(relation.related_collection) === false ||
                 // Ignore legacy permissions with an empty fields array
-                fieldMap[relation.related_collection]?.length === 0)) {
+                allowedFieldsInCollection[relation.related_collection]?.length === 0)) {
             collectionsAllowed = false;
         }
         if (relation.meta?.one_allowed_collections &&
-            relation.meta.one_allowed_collections.every((collection) => Object.keys(fieldMap).includes(collection)) === false) {
+            relation.meta.one_allowed_collections.every((collection) => Object.keys(allowedFieldsInCollection).includes(collection)) === false) {
             collectionsAllowed = false;
         }
-        if (!fieldMap[relation.collection] ||
-            (fieldMap[relation.collection]?.includes('*') === false &&
-                fieldMap[relation.collection]?.includes(relation.field) === false)) {
+        if (!allowedFieldsInCollection[relation.collection] ||
+            (allowedFieldsInCollection[relation.collection]?.includes('*') === false &&
+                allowedFieldsInCollection[relation.collection]?.includes(relation.field) === false)) {
             fieldsAllowed = false;
         }
         if (relation.related_collection &&
             relation.meta?.one_field &&
-            (!fieldMap[relation.related_collection] ||
-                (fieldMap[relation.related_collection]?.includes('*') === false &&
-                    fieldMap[relation.related_collection]?.includes(relation.meta?.one_field) === false))) {
+            (!allowedFieldsInCollection[relation.related_collection] ||
+                (allowedFieldsInCollection[relation.related_collection]?.includes('*') === false &&
+                    allowedFieldsInCollection[relation.related_collection]?.includes(relation.meta?.one_field) === false))) {
             fieldsAllowed = false;
         }
         return collectionsAllowed && fieldsAllowed;

package/dist/websocket/authenticate.d.ts

@@ -1,4 +1,6 @@
+import type { Accountability } from '@directus/types';
 import type { BasicAuthMessage } from './messages.js';
 import type { AuthenticationState } from './types.js';
 export declare function authenticateConnection(message: BasicAuthMessage & Record<string, any>): Promise<AuthenticationState>;
+export declare function refreshAccountability(accountability: Accountability | null | undefined): Promise<Accountability>;
 export declare function authenticationSuccess(uid?: string | number, refresh_token?: string): string;

package/dist/websocket/authenticate.js

@@ -1,6 +1,7 @@
 import { DEFAULT_AUTH_PROVIDER } from '../constants.js';
 import { AuthenticationService } from '../services/index.js';
 import { getAccountabilityForToken } from '../utils/get-accountability-for-token.js';
+import { getPermissions } from '../utils/get-permissions.js';
 import { getSchema } from '../utils/get-schema.js';
 import { WebSocketError } from './errors.js';
 import { getExpiresAtForToken } from './utils/get-expires-at-for-token.js';
@@ -32,6 +33,17 @@ export async function authenticateConnection(message) {
         throw new WebSocketError('auth', 'AUTH_FAILED', 'Authentication failed.', message['uid']);
     }
 }
+export async function refreshAccountability(accountability) {
+    accountability = accountability ?? {
+        role: null,
+        user: null,
+        admin: false,
+        app: false,
+    };
+    const schema = await getSchema();
+    const permissions = await getPermissions(accountability, schema);
+    return { ...accountability, permissions };
+}
 export function authenticationSuccess(uid, refresh_token) {
     const message = {
         type: 'auth',

package/dist/websocket/controllers/graphql.js

@@ -4,7 +4,7 @@ import { useLogger } from '../../logger/index.js';
 import { bindPubSub } from '../../services/graphql/subscription.js';
 import { GraphQLService } from '../../services/index.js';
 import { getSchema } from '../../utils/get-schema.js';
-import { authenticateConnection } from '../authenticate.js';
+import { authenticateConnection, refreshAccountability } from '../authenticate.js';
 import { handleWebSocketError } from '../errors.js';
 import { ConnectionParams, WebSocketMessage } from '../messages.js';
 import { getMessageType } from '../utils/message.js';
@@ -64,6 +64,9 @@ export class GraphQLSubscriptionController extends SocketController {
                             client.close(CloseCode.Forbidden, 'Forbidden');
                             return;
                         }
+                        else {
+                            client.accountability = await refreshAccountability(client.accountability);
+                        }
                         await cb(JSON.stringify(message));
                     }
                     catch (error) {

package/dist/websocket/controllers/hooks.js

@@ -7,23 +7,19 @@ export function registerWebSocketEvents() {
     actionsRegistered = true;
     registerActionHooks([
         'items',
-        'access',
         'activity',
         'collections',
         'dashboards',
-        'flows',
         'folders',
         'notifications',
         'operations',
         'panels',
         'permissions',
-        'policies',
         'presets',
         'revisions',
         'roles',
         'settings',
         'shares',
-        'translations',
         'users',
         'versions',
         'webhooks',

package/dist/websocket/controllers/rest.js

@@ -2,6 +2,7 @@ import { useEnv } from '@directus/env';
 import { parseJSON } from '@directus/utils';
 import emitter from '../../emitter.js';
 import { useLogger } from '../../logger/index.js';
+import { refreshAccountability } from '../authenticate.js';
 import { WebSocketError, handleWebSocketError } from '../errors.js';
 import { WebSocketMessage } from '../messages.js';
 import SocketController from './base.js';
@@ -19,6 +20,7 @@ export class WebSocketController extends SocketController {
         client.on('parsed-message', async (message) => {
             try {
                 message = WebSocketMessage.parse(await emitter.emitFilter('websocket.message', message, { client }));
+                client.accountability = await refreshAccountability(client.accountability);
                 emitter.emitAction('websocket.message', { message, client });
             }
             catch (error) {

package/dist/websocket/handlers/subscribe.js

@@ -4,6 +4,7 @@ import { useBus } from '../../bus/index.js';
 import emitter from '../../emitter.js';
 import { getSchema } from '../../utils/get-schema.js';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';
+import { refreshAccountability } from '../authenticate.js';
 import { WebSocketError, handleWebSocketError } from '../errors.js';
 import { WebSocketSubscribeMessage } from '../messages.js';
 import { getPayload } from '../utils/items.js';
@@ -111,6 +112,7 @@ export class SubscribeHandler {
                     continue;
             }
             try {
+                client.accountability = await refreshAccountability(client.accountability);
                 const result = await getPayload(subscription, client.accountability, schema, event);
                 if (Array.isArray(result?.['data']) && result?.['data']?.length === 0)
                     continue;

package/dist/websocket/utils/items.d.ts

@@ -39,5 +39,5 @@ export declare function getFieldsPayload(subscription: PSubscription, accountabi
  * @param event Event data
  * @returns the fetched data
  */
-export declare function getItemsPayload(subscription: PSubscription, accountability: Accountability | null, schema: SchemaOverview, event?: WebSocketEvent): Promise<string | number | (string | number)[] | import("@directus/types").Item | import("@directus/types").Item[]>;
+export declare function getItemsPayload(subscription: PSubscription, accountability: Accountability | null, schema: SchemaOverview, event?: WebSocketEvent): Promise<string | number | import("@directus/types").Item | (string | number)[] | import("@directus/types").Item[]>;
 export {};