@directus/api 16.0.0 → 17.0.1

package/dist/services/permissions.js

@@ -1,7 +1,9 @@
+import { ForbiddenError } from '@directus/errors';
 import { clearSystemCache, getCache } from '../cache.js';
-import { appAccessMinimalPermissions } from '../database/system-data/app-access-permissions/index.js';
-import { ItemsService } from './items.js';
+import { appAccessMinimalPermissions } from '@directus/system-data';
 import { filterItems } from '../utils/filter-items.js';
+import { AuthorizationService } from './authorization.js';
+import { ItemsService } from './items.js';
 export class PermissionsService extends ItemsService {
     systemCache;
     constructor(options) {
@@ -95,4 +97,77 @@ export class PermissionsService extends ItemsService {
         }
         return res;
     }
+    async getItemPermissions(collection, primaryKey) {
+        if (!this.accountability?.user)
+            throw new ForbiddenError();
+        if (this.accountability?.admin) {
+            return {
+                update: { access: true },
+                delete: { access: true },
+                share: { access: true },
+            };
+        }
+        const itemPermissions = {
+            update: { access: false },
+            delete: { access: false },
+            share: { access: false },
+        };
+        let updateAction = 'update';
+        const schema = this.schema.collections[collection];
+        if (schema?.singleton) {
+            const itemsService = new ItemsService(collection, {
+                knex: this.knex,
+                schema: this.schema,
+            });
+            const query = {
+                fields: [schema.primary],
+                limit: 1,
+            };
+            try {
+                const result = await itemsService.readByQuery(query);
+                if (!result[0])
+                    updateAction = 'create';
+            }
+            catch {
+                updateAction = 'create';
+            }
+        }
+        const authorizationService = new AuthorizationService({
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
+        await Promise.all(Object.keys(itemPermissions).map((key) => {
+            const action = key;
+            const checkAction = action === 'update' ? updateAction : action;
+            return authorizationService
+                .checkAccess(checkAction, collection, primaryKey)
+                .then(() => (itemPermissions[action].access = true))
+                .catch(() => { });
+        }));
+        if (schema?.singleton && itemPermissions.update.access) {
+            const query = {
+                filter: {
+                    _and: [
+                        ...(this.accountability?.role ? [{ role: { _eq: this.accountability.role } }] : []),
+                        { collection: { _eq: collection } },
+                        { action: { _eq: updateAction } },
+                    ],
+                },
+                fields: ['presets', 'fields'],
+            };
+            try {
+                const result = await this.readByQuery(query);
+                const permission = result[0];
+                if (permission) {
+                    itemPermissions.update.presets = permission['presets'];
+                    itemPermissions.update.fields = permission['fields'];
+                }
+            }
+            catch {
+                // No permission
+            }
+        }
+        return itemPermissions;
+    }
 }

package/dist/services/relations.js

@@ -4,12 +4,12 @@ import { toArray } from '@directus/utils';
 import { clearSystemCache, getCache } from '../cache.js';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase, { getSchemaInspector } from '../database/index.js';
-import { systemRelationRows } from '../database/system-data/relations/index.js';
 import emitter from '../emitter.js';
 import { getDefaultIndexName } from '../utils/get-default-index-name.js';
 import { getSchema } from '../utils/get-schema.js';
 import { ItemsService } from './items.js';
 import { PermissionsService } from './permissions.js';
+import { systemRelationRows } from '@directus/system-data';
 export class RelationsService {
     knex;
     permissionsService;

package/dist/services/roles.js

@@ -15,7 +15,7 @@ export class RolesService extends ItemsService {
             .whereNotIn('id', excludeKeys)
             .andWhere({ admin_access: true })
             .first();
-        const otherAdminRolesCount = +(otherAdminRoles?.count || 0);
+        const otherAdminRolesCount = Number(otherAdminRoles?.count ?? 0);
         if (otherAdminRolesCount === 0) {
             throw new UnprocessableContentError({ reason: `You can't delete the last admin role` });
         }
@@ -24,30 +24,98 @@ export class RolesService extends ItemsService {
         const role = await this.knex.select('admin_access').from('directus_roles').where('id', '=', key).first();
         if (!role)
             throw new ForbiddenError();
-        // The users that will now be in this new non-admin role
-        let userKeys = [];
+        const usersBefore = (await this.knex.select('id').from('directus_users').where('role', '=', key)).map((user) => user.id);
+        const usersAdded = [];
+        const usersUpdated = [];
+        const usersCreated = [];
+        const usersRemoved = [];
         if (Array.isArray(users)) {
-            userKeys = users.map((user) => (typeof user === 'string' ? user : user['id'])).filter((id) => id);
+            const usersKept = [];
+            for (const user of users) {
+                if (typeof user === 'string') {
+                    if (usersBefore.includes(user)) {
+                        usersKept.push(user);
+                    }
+                    else {
+                        usersAdded.push({ id: user });
+                    }
+                }
+                else if (user.id) {
+                    if (usersBefore.includes(user.id)) {
+                        usersKept.push(user.id);
+                        usersUpdated.push(user);
+                    }
+                    else {
+                        usersAdded.push(user);
+                    }
+                }
+                else {
+                    usersCreated.push(user);
+                }
+            }
+            usersRemoved.push(...usersBefore.filter((user) => !usersKept.includes(user)));
         }
         else {
-            userKeys = users.update.map((user) => user['id']).filter((id) => id);
+            for (const user of users.update) {
+                if (usersBefore.includes(user['id'])) {
+                    usersUpdated.push(user);
+                }
+                else {
+                    usersAdded.push(user);
+                }
+            }
+            usersCreated.push(...users.create);
+            usersRemoved.push(...users.delete);
+        }
+        if (role.admin_access === false || role.admin_access === 0) {
+            // Admin users might have moved in from other role, thus becoming non-admin
+            if (usersAdded.length > 0) {
+                const otherAdminUsers = await this.knex
+                    .count('*', { as: 'count' })
+                    .from('directus_users')
+                    .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
+                    .whereNotIn('directus_users.id', usersAdded)
+                    .andWhere({ 'directus_roles.admin_access': true, status: 'active' })
+                    .first();
+                const otherAdminUsersCount = Number(otherAdminUsers?.count ?? 0);
+                if (otherAdminUsersCount === 0) {
+                    throw new UnprocessableContentError({ reason: `You can't remove the last admin user from the admin role` });
+                }
+            }
+            return;
         }
-        const usersThatWereInRoleBefore = (await this.knex.select('id').from('directus_users').where('role', '=', key)).map((user) => user.id);
-        const usersThatAreRemoved = usersThatWereInRoleBefore.filter((id) => Array.isArray(users) ? userKeys.includes(id) === false : users.delete.includes(id) === true);
-        const usersThatAreAdded = Array.isArray(users) ? users : users.create;
-        // If the role the users are moved to is an admin-role, and there's at least 1 (new) admin
-        // user, we don't have to check for other admin
-        // users
-        if ((role.admin_access === true || role.admin_access === 1) && usersThatAreAdded.length > 0)
+        // Only added or created new users
+        if (usersUpdated.length === 0 && usersRemoved.length === 0)
+            return;
+        // Active admin user(s) about to be created
+        if (usersCreated.some((user) => !('status' in user) || user.status === 'active'))
             return;
+        const usersDeactivated = [...usersAdded, ...usersUpdated]
+            .filter((user) => 'status' in user && user.status !== 'active')
+            .map((user) => user.id);
+        const usersAddedNonDeactivated = usersAdded
+            .filter((user) => !usersDeactivated.includes(user.id))
+            .map((user) => user.id);
+        // Active user(s) about to become admin
+        if (usersAddedNonDeactivated.length > 0) {
+            const userCount = await this.knex
+                .count('*', { as: 'count' })
+                .from('directus_users')
+                .whereIn('id', usersAddedNonDeactivated)
+                .andWhere({ status: 'active' })
+                .first();
+            if (Number(userCount?.count ?? 0) > 0) {
+                return;
+            }
+        }
         const otherAdminUsers = await this.knex
             .count('*', { as: 'count' })
             .from('directus_users')
-            .whereNotIn('directus_users.id', [...userKeys, ...usersThatAreRemoved])
-            .andWhere({ 'directus_roles.admin_access': true })
             .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
+            .whereNotIn('directus_users.id', [...usersDeactivated, ...usersRemoved])
+            .andWhere({ 'directus_roles.admin_access': true, status: 'active' })
             .first();
-        const otherAdminUsersCount = +(otherAdminUsers?.count || 0);
+        const otherAdminUsersCount = Number(otherAdminUsers?.count ?? 0);
         if (otherAdminUsersCount === 0) {
             throw new UnprocessableContentError({ reason: `You can't remove the last admin user from the admin role` });
         }

package/dist/services/server.js

@@ -41,7 +41,8 @@ export class ServerService {
                 'theme_dark_overrides',
                 'default_language',
                 'public_foreground',
-                'public_background',
+                'public_background.id',
+                'public_background.type',
                 'public_favicon',
                 'public_note',
                 'custom_css',

package/dist/services/specifications.js

@@ -8,6 +8,7 @@ import getDatabase from '../database/index.js';
 import { getRelationType } from '../utils/get-relation-type.js';
 import { reduceSchema } from '../utils/reduce-schema.js';
 import { GraphQLService } from './graphql/index.js';
+import { isSystemCollection } from '@directus/system-data';
 const env = useEnv();
 export class SpecificationService {
     accountability;
@@ -77,7 +78,7 @@ class OASSpecsService {
             }
         }
         for (const collection of collections) {
-            const isSystem = collection.collection.startsWith('directus_');
+            const isSystem = isSystemCollection(collection.collection);
             // If the collection is one of the system collections, pull the tag from the static spec
             if (isSystem) {
                 for (const tag of spec.tags) {
@@ -106,7 +107,7 @@ class OASSpecsService {
         if (!tags)
             return paths;
         for (const tag of tags) {
-            const isSystem = 'x-collection' in tag === false || tag['x-collection'].startsWith('directus_');
+            const isSystem = 'x-collection' in tag === false || isSystemCollection(tag['x-collection']);
             if (isSystem) {
                 for (const [path, pathItem] of Object.entries(spec.paths)) {
                     for (const [method, operation] of Object.entries(pathItem)) {
@@ -268,7 +269,7 @@ class OASSpecsService {
             const tag = tags.find((tag) => tag['x-collection'] === collection.collection);
             if (!tag)
                 continue;
-            const isSystem = collection.collection.startsWith('directus_');
+            const isSystem = isSystemCollection(collection.collection);
             const fieldsInCollection = Object.values(collection.fields);
             if (isSystem) {
                 const schemaComponent = cloneDeep(spec.components.schemas[tag.name]);

package/dist/services/utils.js

@@ -1,6 +1,6 @@
 import { flushCaches, getCache } from '../cache.js';
 import getDatabase from '../database/index.js';
-import { systemCollectionRows } from '../database/system-data/collections/index.js';
+import { systemCollectionRows } from '@directus/system-data';
 import emitter from '../emitter.js';
 import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { shouldClearCache } from '../utils/should-clear-cache.js';

package/dist/telemetry/utils/get-user-item-count.js

@@ -1,6 +1,7 @@
 import {} from 'knex';
 import { getSchema } from '../../utils/get-schema.js';
 import { getItemCount } from './get-item-count.js';
+import { isSystemCollection } from '@directus/system-data';
 /**
  * Sum all passed values together. Meant to be used with .reduce()
  */
@@ -10,7 +11,7 @@ export const sum = (acc, val) => (acc += val);
  */
 export const getUserItemCount = async (db) => {
     const schema = await getSchema({ database: db });
-    const userCollections = Object.keys(schema.collections).filter((collection) => collection.startsWith('directus_') === false);
+    const userCollections = Object.keys(schema.collections).filter((collection) => isSystemCollection(collection) === false);
     const counts = await getItemCount(db, userCollections);
     const collections = userCollections.length;
     const items = Object.values(counts).reduce(sum, 0);

package/dist/types/collection.d.ts

@@ -1,20 +1,9 @@
 import type { Field } from '@directus/types';
 import type { Table } from '@directus/schema';
-export type CollectionMeta = {
-    collection: string;
-    note: string | null;
-    hidden: boolean;
-    singleton: boolean;
-    icon: string | null;
-    translations: Record<string, string>;
-    versioning: boolean;
-    item_duplication_fields: string[] | null;
-    accountability: 'all' | 'accountability' | null;
-    group: string | null;
-};
+import type { BaseCollectionMeta } from '@directus/system-data';
 export type Collection = {
     collection: string;
     fields?: Field[];
-    meta: CollectionMeta | null;
+    meta: BaseCollectionMeta | null;
     schema: Table | null;
 };

package/dist/types/items.d.ts

@@ -1,20 +1,12 @@
-/**
- * I know this looks a little silly, but it allows us to explicitly differentiate between when we're
- * expecting an item vs any other generic object.
- */
 import type { DirectusError } from '@directus/errors';
 import type { EventContext } from '@directus/types';
 import type { MutationTracker } from '../services/items.js';
 export type Item = Record<string, any>;
 export type PrimaryKey = string | number;
-export type Alterations = {
-    create: {
-        [key: string]: any;
-    }[];
-    update: {
-        [key: string]: any;
-    }[];
-    delete: (number | string)[];
+export type Alterations<T extends Item = Item, K extends keyof T | undefined = undefined> = {
+    create: Partial<T>[];
+    update: (K extends keyof T ? Partial<T> & Pick<T, K> : Partial<T>)[];
+    delete: (K extends keyof T ? T[K] : PrimaryKey)[];
 };
 export type MutationOptions = {
     /**

package/dist/types/items.js

@@ -1,5 +1 @@
-/**
- * I know this looks a little silly, but it allows us to explicitly differentiate between when we're
- * expecting an item vs any other generic object.
- */
 export {};

package/dist/utils/get-field-system-rows.d.ts

@@ -0,0 +1,2 @@
+import type { FieldMeta } from '@directus/types';
+export declare function getSystemFieldRowsWithAuthProviders(): FieldMeta[];

package/dist/utils/get-field-system-rows.js

@@ -0,0 +1,17 @@
+import { systemFieldRows } from '@directus/system-data';
+import formatTitle from '@directus/format-title';
+import { getAuthProviders } from './get-auth-providers.js';
+// Dynamically populate auth providers field
+export function getSystemFieldRowsWithAuthProviders() {
+    return systemFieldRows.map((systemField) => {
+        if (systemField.collection === 'directus_users' && systemField.field === 'provider') {
+            if (!systemField.options)
+                systemField.options = {};
+            systemField.options['choices'] = getAuthProviders().map(({ name }) => ({
+                text: formatTitle(name),
+                value: name,
+            }));
+        }
+        return systemField;
+    });
+}

package/dist/utils/get-permissions.js

@@ -4,7 +4,7 @@ import { cloneDeep } from 'lodash-es';
 import hash from 'object-hash';
 import { getCache, getCacheValue, getSystemCache, setCacheValue, setSystemCache } from '../cache.js';
 import getDatabase from '../database/index.js';
-import { appAccessMinimalPermissions } from '../database/system-data/app-access-permissions/index.js';
+import { appAccessMinimalPermissions } from '@directus/system-data';
 import { useLogger } from '../logger.js';
 import { RolesService } from '../services/roles.js';
 import { UsersService } from '../services/users.js';

package/dist/utils/get-schema.js

@@ -5,12 +5,12 @@ import { mapValues } from 'lodash-es';
 import { getSchemaCache, setSchemaCache } from '../cache.js';
 import { ALIAS_TYPES } from '../constants.js';
 import getDatabase from '../database/index.js';
-import { systemCollectionRows } from '../database/system-data/collections/index.js';
-import { systemFieldRows } from '../database/system-data/fields/index.js';
 import { useLogger } from '../logger.js';
 import { RelationsService } from '../services/relations.js';
 import getDefaultValue from './get-default-value.js';
 import getLocalType from './get-local-type.js';
+import { systemCollectionRows } from '@directus/system-data';
+import { getSystemFieldRowsWithAuthProviders } from './get-field-system-rows.js';
 const logger = useLogger();
 export async function getSchema(options) {
     const env = useEnv();
@@ -49,6 +49,7 @@ async function getDatabaseSchema(database, schemaInspector) {
         collections: {},
         relations: [],
     };
+    const systemFieldRows = getSystemFieldRowsWithAuthProviders();
     const schemaOverview = await schemaInspector.overview();
     const collections = [
         ...(await database

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

@@ -1,5 +1,5 @@
 import { assign, set, uniq } from 'lodash-es';
-import { schemaPermissions } from '../database/system-data/app-access-permissions/index.js';
+import { schemaPermissions } from '@directus/system-data';
 import { mergePermissions } from './merge-permissions.js';
 import { reduceSchema } from './reduce-schema.js';
 export function mergePermissionsForShare(currentPermissions, accountability, schema) {

package/dist/utils/should-skip-cache.js

@@ -1,7 +1,7 @@
 import { useEnv } from '@directus/env';
-import { getEndpoint } from '@directus/utils';
 import url from 'url';
 import { Url } from './url.js';
+import { getEndpoint } from '@directus/utils';
 /**
  * Whether to skip caching for the current request
  *

package/dist/websocket/handlers/items.js

@@ -1,6 +1,7 @@
 import emitter from '../../emitter.js';
 import { ItemsService, MetaService } from '../../services/index.js';
 import { getSchema } from '../../utils/get-schema.js';
+import { isSystemCollection } from '@directus/system-data';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';
 import { WebSocketError, handleWebSocketError } from '../errors.js';
 import { WebSocketItemsMessage } from '../messages.js';
@@ -26,7 +27,7 @@ export class ItemsHandler {
         const uid = message.uid;
         const accountability = client.accountability;
         const schema = await getSchema();
-        if (!schema.collections[message.collection] || message.collection.startsWith('directus_')) {
+        if (!schema.collections[message.collection] || isSystemCollection(message.collection)) {
             throw new WebSocketError('items', 'INVALID_COLLECTION', 'The provided collection does not exists or is not accessible.', uid);
         }
         const isSingleton = !!schema.collections[message.collection]?.singleton;

package/dist/websocket/messages.d.ts

@@ -163,53 +163,53 @@ export declare const WebSocketSubscribeMessage: z.ZodDiscriminatedUnion<"type",
 }, z.ZodTypeAny, "passthrough">>]>;
 export type WebSocketSubscribeMessage = z.infer<typeof WebSocketSubscribeMessage>;
 export declare const WebSocketItemsMessage: z.ZodUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"items">;
     collection: z.ZodString;
+    type: z.ZodLiteral<"items">;
     uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     action: z.ZodLiteral<"create">;
     data: z.ZodUnion<[z.ZodArray<z.ZodType<Partial<Item>, z.ZodTypeDef, Partial<Item>>, "many">, z.ZodType<Partial<Item>, z.ZodTypeDef, Partial<Item>>]>;
     query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
 }, "strip", z.ZodTypeAny, {
+    collection: string;
     type: "items";
     action: "create";
     data: (Partial<Item> | Partial<Item>[]) & (Partial<Item> | Partial<Item>[] | undefined);
-    collection: string;
     uid?: string | number | undefined;
     query?: Query | undefined;
 }, {
+    collection: string;
     type: "items";
     action: "create";
     data: (Partial<Item> | Partial<Item>[]) & (Partial<Item> | Partial<Item>[] | undefined);
-    collection: string;
     uid?: string | number | undefined;
     query?: Query | undefined;
 }>, z.ZodObject<{
-    type: z.ZodLiteral<"items">;
     collection: z.ZodString;
+    type: z.ZodLiteral<"items">;
     uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     action: z.ZodLiteral<"read">;
     ids: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
     id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
 }, "strip", z.ZodTypeAny, {
+    collection: string;
     type: "items";
     action: "read";
-    collection: string;
     uid?: string | number | undefined;
     ids?: (string | number)[] | undefined;
     id?: string | number | undefined;
     query?: Query | undefined;
 }, {
+    collection: string;
     type: "items";
     action: "read";
-    collection: string;
     uid?: string | number | undefined;
     ids?: (string | number)[] | undefined;
     id?: string | number | undefined;
     query?: Query | undefined;
 }>, z.ZodObject<{
-    type: z.ZodLiteral<"items">;
     collection: z.ZodString;
+    type: z.ZodLiteral<"items">;
     uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     action: z.ZodLiteral<"update">;
     data: z.ZodType<Partial<Item>, z.ZodTypeDef, Partial<Item>>;
@@ -217,43 +217,43 @@ export declare const WebSocketItemsMessage: z.ZodUnion<[z.ZodObject<{
     id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
 }, "strip", z.ZodTypeAny, {
+    collection: string;
     type: "items";
     action: "update";
     data: Partial<Item>;
-    collection: string;
     uid?: string | number | undefined;
     ids?: (string | number)[] | undefined;
     id?: string | number | undefined;
     query?: Query | undefined;
 }, {
+    collection: string;
     type: "items";
     action: "update";
     data: Partial<Item>;
-    collection: string;
     uid?: string | number | undefined;
     ids?: (string | number)[] | undefined;
     id?: string | number | undefined;
     query?: Query | undefined;
 }>, z.ZodObject<{
-    type: z.ZodLiteral<"items">;
     collection: z.ZodString;
+    type: z.ZodLiteral<"items">;
     uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     action: z.ZodLiteral<"delete">;
     ids: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
     id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
 }, "strip", z.ZodTypeAny, {
+    collection: string;
     type: "items";
     action: "delete";
-    collection: string;
     uid?: string | number | undefined;
     ids?: (string | number)[] | undefined;
     id?: string | number | undefined;
     query?: Query | undefined;
 }, {
+    collection: string;
     type: "items";
     action: "delete";
-    collection: string;
     uid?: string | number | undefined;
     ids?: (string | number)[] | undefined;
     id?: string | number | undefined;
@@ -266,14 +266,14 @@ export declare const WebSocketEvent: z.ZodDiscriminatedUnion<"action", [z.ZodObj
     payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     key: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
 }, "strip", z.ZodTypeAny, {
+    collection: string;
     key: string | number;
     action: "create";
-    collection: string;
     payload?: Record<string, any> | undefined;
 }, {
+    collection: string;
     key: string | number;
     action: "create";
-    collection: string;
     payload?: Record<string, any> | undefined;
 }>, z.ZodObject<{
     action: z.ZodLiteral<"update">;
@@ -281,14 +281,14 @@ export declare const WebSocketEvent: z.ZodDiscriminatedUnion<"action", [z.ZodObj
     payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     keys: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
 }, "strip", z.ZodTypeAny, {
+    collection: string;
     action: "update";
     keys: (string | number)[];
-    collection: string;
     payload?: Record<string, any> | undefined;
 }, {
+    collection: string;
     action: "update";
     keys: (string | number)[];
-    collection: string;
     payload?: Record<string, any> | undefined;
 }>, z.ZodObject<{
     action: z.ZodLiteral<"delete">;
@@ -296,14 +296,14 @@ export declare const WebSocketEvent: z.ZodDiscriminatedUnion<"action", [z.ZodObj
     payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     keys: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
 }, "strip", z.ZodTypeAny, {
+    collection: string;
     action: "delete";
     keys: (string | number)[];
-    collection: string;
     payload?: Record<string, any> | undefined;
 }, {
+    collection: string;
     action: "delete";
     keys: (string | number)[];
-    collection: string;
     payload?: Record<string, any> | undefined;
 }>]>;
 export type WebSocketEvent = z.infer<typeof WebSocketEvent>;