@directus/api 12.1.3 → 13.1.0-beta.0

package/dist/__utils__/snapshots.js

@@ -13,6 +13,7 @@ export const snapshotBeforeCreateCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                branches_enabled: false,
                 translations: {},
             },
             schema: {
@@ -86,6 +87,7 @@ export const snapshotCreateCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                branches_enabled: false,
                 translations: {},
             },
             schema: {
@@ -105,6 +107,7 @@ export const snapshotCreateCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                branches_enabled: false,
                 translations: {},
             },
             schema: {
@@ -124,6 +127,7 @@ export const snapshotCreateCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                branches_enabled: false,
                 translations: {},
             },
             schema: {
@@ -287,6 +291,7 @@ export const snapshotCreateCollectionNotNested = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                branches_enabled: false,
                 translations: {},
             },
             schema: {
@@ -306,6 +311,7 @@ export const snapshotCreateCollectionNotNested = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                branches_enabled: false,
                 translations: {},
             },
             schema: {
@@ -424,6 +430,7 @@ export const snapshotBeforeDeleteCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                branches_enabled: false,
                 translations: {},
             },
             schema: {
@@ -443,6 +450,7 @@ export const snapshotBeforeDeleteCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                branches_enabled: false,
                 translations: {},
             },
             schema: {
@@ -462,6 +470,7 @@ export const snapshotBeforeDeleteCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                branches_enabled: false,
                 translations: {},
             },
             schema: {

package/dist/app.js

@@ -10,6 +10,7 @@ import { registerAuthProviders } from './auth.js';
 import activityRouter from './controllers/activity.js';
 import assetsRouter from './controllers/assets.js';
 import authRouter from './controllers/auth.js';
+import branchesRouter from './controllers/branches.js';
 import collectionsRouter from './controllers/collections.js';
 import dashboardsRouter from './controllers/dashboards.js';
 import extensionsRouter from './controllers/extensions.js';
@@ -199,6 +200,7 @@ export default async function createApp() {
     app.use('/graphql', graphqlRouter);
     app.use('/activity', activityRouter);
     app.use('/assets', assetsRouter);
+    app.use('/branches', branchesRouter);
     app.use('/collections', collectionsRouter);
     app.use('/dashboards', dashboardsRouter);
     app.use('/extensions', extensionsRouter);

package/dist/cli/utils/create-env/env-stub.liquid

@@ -148,8 +148,8 @@ CACHE_ENABLED=false
 # How long the cache is persisted ["5m"]
 # CACHE_TTL="30m"
 
-# How to scope the cache data ["directus-cache"]
-# CACHE_NAMESPACE="directus-cache"
+# How to scope the cache data ["system-cache"]
+# CACHE_NAMESPACE="system-cache"
 
 # Automatically purge the cache on create, update, and delete actions. [false]
 # CACHE_AUTO_PURGE=true

package/dist/controllers/branches.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/controllers/branches.js

@@ -0,0 +1,190 @@
+import { isDirectusError } from '@directus/errors';
+import express from 'express';
+import { assign } from 'lodash-es';
+import { ErrorCode, InvalidPayloadError } from '../errors/index.js';
+import { respond } from '../middleware/respond.js';
+import useCollection from '../middleware/use-collection.js';
+import { validateBatch } from '../middleware/validate-batch.js';
+import { BranchesService } from '../services/branches.js';
+import { MetaService } from '../services/meta.js';
+import asyncHandler from '../utils/async-handler.js';
+import { sanitizeQuery } from '../utils/sanitize-query.js';
+const router = express.Router();
+router.use(useCollection('directus_branches'));
+router.post('/', asyncHandler(async (req, res, next) => {
+    const service = new BranchesService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const savedKeys = [];
+    if (Array.isArray(req.body)) {
+        const keys = await service.createMany(req.body);
+        savedKeys.push(...keys);
+    }
+    else {
+        const primaryKey = await service.createOne(req.body);
+        savedKeys.push(primaryKey);
+    }
+    try {
+        if (Array.isArray(req.body)) {
+            const records = await service.readMany(savedKeys, req.sanitizedQuery);
+            res.locals['payload'] = { data: records };
+        }
+        else {
+            const record = await service.readOne(savedKeys[0], req.sanitizedQuery);
+            res.locals['payload'] = { data: record };
+        }
+    }
+    catch (error) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+const readHandler = asyncHandler(async (req, res, next) => {
+    const service = new BranchesService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const metaService = new MetaService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    let result;
+    if (req.singleton) {
+        result = await service.readSingleton(req.sanitizedQuery);
+    }
+    else if (req.body.keys) {
+        result = await service.readMany(req.body.keys, req.sanitizedQuery);
+    }
+    else {
+        result = await service.readByQuery(req.sanitizedQuery);
+    }
+    const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
+    res.locals['payload'] = { data: result, meta };
+    return next();
+});
+router.get('/', validateBatch('read'), readHandler, respond);
+router.search('/', validateBatch('read'), readHandler, respond);
+router.get('/:pk', asyncHandler(async (req, res, next) => {
+    const service = new BranchesService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const record = await service.readOne(req.params['pk'], req.sanitizedQuery);
+    res.locals['payload'] = { data: record || null };
+    return next();
+}), respond);
+router.patch('/', validateBatch('update'), asyncHandler(async (req, res, next) => {
+    const service = new BranchesService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    let keys = [];
+    if (Array.isArray(req.body)) {
+        keys = await service.updateBatch(req.body);
+    }
+    else if (req.body.keys) {
+        keys = await service.updateMany(req.body.keys, req.body.data);
+    }
+    else {
+        const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
+        keys = await service.updateByQuery(sanitizedQuery, req.body.data);
+    }
+    try {
+        const result = await service.readMany(keys, req.sanitizedQuery);
+        res.locals['payload'] = { data: result || null };
+    }
+    catch (error) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+router.patch('/:pk', asyncHandler(async (req, res, next) => {
+    const service = new BranchesService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const primaryKey = await service.updateOne(req.params['pk'], req.body);
+    try {
+        const record = await service.readOne(primaryKey, req.sanitizedQuery);
+        res.locals['payload'] = { data: record || null };
+    }
+    catch (error) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+router.delete('/', validateBatch('delete'), asyncHandler(async (req, _res, next) => {
+    const service = new BranchesService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    if (Array.isArray(req.body)) {
+        await service.deleteMany(req.body);
+    }
+    else if (req.body.keys) {
+        await service.deleteMany(req.body.keys);
+    }
+    else {
+        const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
+        await service.deleteByQuery(sanitizedQuery);
+    }
+    return next();
+}), respond);
+router.delete('/:pk', asyncHandler(async (req, _res, next) => {
+    const service = new BranchesService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await service.deleteOne(req.params['pk']);
+    return next();
+}), respond);
+router.get('/:pk/compare', asyncHandler(async (req, res, next) => {
+    const service = new BranchesService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const branch = await service.readOne(req.params['pk']);
+    const { outdated, mainHash } = await service.verifyHash(branch['collection'], branch['item'], branch['hash']);
+    const commits = await service.getBranchCommits(branch['id']);
+    const current = assign({}, ...commits);
+    const fields = Object.keys(current);
+    const mainBranchItem = await service.getMainBranchItem(branch['collection'], branch['item'], fields.length > 0 ? { fields } : undefined);
+    res.locals['payload'] = { data: { outdated, mainHash, current, main: mainBranchItem } };
+    return next();
+}), respond);
+router.post('/:pk/commit', asyncHandler(async (req, res, next) => {
+    const service = new BranchesService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const branch = await service.readOne(req.params['pk']);
+    const mainBranchItem = await service.getMainBranchItem(branch['collection'], branch['item']);
+    await service.commit(req.params['pk'], req.body);
+    const commits = await service.getBranchCommits(req.params['pk']);
+    const result = assign(mainBranchItem, ...commits);
+    res.locals['payload'] = { data: result || null };
+    return next();
+}), respond);
+router.post('/:pk/merge', asyncHandler(async (req, res, next) => {
+    if (typeof req.body.mainHash !== 'string') {
+        throw new InvalidPayloadError({ reason: `"mainHash" field is required` });
+    }
+    const service = new BranchesService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const updatedItemKey = await service.merge(req.params['pk'], req.body.mainHash, req.body?.['fields']);
+    res.locals['payload'] = { data: updatedItemKey || null };
+    return next();
+}), respond);
+export default router;

package/dist/database/migrations/20230721A-require-shares-fields.js

@@ -1,12 +1,28 @@
 export async function up(knex) {
     await knex.schema.alterTable('directus_shares', (table) => {
+        if (knex.client.constructor.name === 'Client_MySQL') {
+            // Temporary drop foreign key constraint, see https://github.com/directus/directus/issues/19399
+            table.dropForeign('collection', 'directus_shares_collection_foreign');
+        }
         table.dropNullable('collection');
+        if (knex.client.constructor.name === 'Client_MySQL') {
+            // Recreate foreign key constraint, from 20211211A-add-shares.ts
+            table.foreign('collection').references('directus_collections.collection').onDelete('CASCADE');
+        }
         table.dropNullable('item');
     });
 }
 export async function down(knex) {
     await knex.schema.alterTable('directus_shares', (table) => {
+        if (knex.client.constructor.name === 'Client_MySQL') {
+            // Temporary drop foreign key constraint, see https://github.com/directus/directus/issues/19399
+            table.dropForeign('collection', 'directus_shares_collection_foreign');
+        }
         table.setNullable('collection');
+        if (knex.client.constructor.name === 'Client_MySQL') {
+            // Recreate foreign key constraint, from 20211211A-add-shares.ts
+            table.foreign('collection').references('directus_collections.collection').onDelete('CASCADE');
+        }
         table.setNullable('item');
     });
 }

package/dist/database/migrations/20230823A-add-content-versioning.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20230823A-add-content-versioning.js

@@ -0,0 +1,26 @@
+export async function up(knex) {
+    await knex.schema.createTable('directus_branches', (table) => {
+        table.uuid('id').primary().notNullable();
+        table.string('name').notNullable();
+        table.string('collection', 64).references('collection').inTable('directus_collections').onDelete('CASCADE');
+        table.string('item');
+        table.string('hash').notNullable();
+        table.timestamp('date_created').defaultTo(knex.fn.now());
+        table.uuid('user_created').references('id').inTable('directus_users').onDelete('SET NULL');
+    });
+    await knex.schema.alterTable('directus_collections', (table) => {
+        table.boolean('branches_enabled').notNullable().defaultTo(false);
+    });
+    await knex.schema.alterTable('directus_revisions', (table) => {
+        table.uuid('branch').references('id').inTable('directus_branches').onDelete('CASCADE');
+    });
+}
+export async function down(knex) {
+    await knex.schema.dropTable('directus_branches');
+    await knex.schema.alterTable('directus_collections', (table) => {
+        table.dropColumn('branches_enabled');
+    });
+    await knex.schema.alterTable('directus_revisions', (table) => {
+        table.dropColumn('branch');
+    });
+}

package/dist/database/system-data/fields/branches.yaml

@@ -0,0 +1,19 @@
+table: directus_branches
+
+fields:
+  - field: id
+    special:
+      - uuid
+    readonly: true
+    hidden: true
+  - field: name
+  - field: collection
+  - field: item
+  - field: hash
+  - field: date_created
+    special:
+      - date-created
+      - cast-timestamp
+  - field: user_created
+    special:
+      - user-created

package/dist/database/system-data/fields/collections.yaml

@@ -114,8 +114,27 @@ fields:
     interface: system-display-template
     options:
       collectionField: collection
+      injectBranchField: true
     width: full
 
+  - field: content_versioning_divider
+    special:
+      - alias
+      - no-data
+    interface: presentation-divider
+    options:
+      icon: update
+      title: $t:field_options.directus_collections.content_versioning_divider
+    width: full
+
+  - field: branches_enabled
+    interface: boolean
+    special:
+      - cast-boolean
+    options:
+      label: $t:field_options.directus_collections.enable_branches
+    width: half
+
   - field: archive_divider
     special:
       - alias

package/dist/env.js

@@ -192,8 +192,9 @@ const allowedEnvironmentVars = [
     'RELATIONAL_BATCH_SIZE',
     'EXPORT_BATCH_SIZE',
     // flows
-    'FLOWS_EXEC_ALLOWED_MODULES',
     'FLOWS_ENV_ALLOW_LIST',
+    'FLOWS_RUN_SCRIPT_MAX_MEMORY',
+    'FLOWS_RUN_SCRIPT_TIMEOUT',
     // websockets
     'WEBSOCKETS_.+',
 ].map((name) => new RegExp(`^${name}$`));
@@ -282,8 +283,9 @@ const defaults = {
     WEBSOCKETS_GRAPHQL_PATH: '/graphql',
     WEBSOCKETS_HEARTBEAT_ENABLED: true,
     WEBSOCKETS_HEARTBEAT_PERIOD: 30,
-    FLOWS_EXEC_ALLOWED_MODULES: false,
     FLOWS_ENV_ALLOW_LIST: false,
+    FLOWS_RUN_SCRIPT_MAX_MEMORY: 32,
+    FLOWS_RUN_SCRIPT_TIMEOUT: 10000,
     PRESSURE_LIMITER_ENABLED: true,
     PRESSURE_LIMITER_SAMPLE_INTERVAL: 250,
     PRESSURE_LIMITER_MAX_EVENT_LOOP_UTILIZATION: 0.99,

package/dist/flows.d.ts

@@ -7,6 +7,7 @@ declare class FlowManager {
     private operationFlowHandlers;
     private webhookFlowHandlers;
     private reloadQueue;
+    private envs;
     constructor();
     initialize(): Promise<void>;
     reload(): Promise<void>;

package/dist/flows.js

@@ -1,5 +1,5 @@
-import { Action, REDACTED_TEXT } from '@directus/constants';
-import { applyOptionsData, isValidJSON, parseJSON, toArray } from '@directus/utils';
+import { Action } from '@directus/constants';
+import { applyOptionsData, getRedactedString, isValidJSON, parseJSON, toArray } from '@directus/utils';
 import { omit, pick } from 'lodash-es';
 import { get } from 'micromustache';
 import getDatabase from './database/index.js';
@@ -16,7 +16,7 @@ import { constructFlowTree } from './utils/construct-flow-tree.js';
 import { getSchema } from './utils/get-schema.js';
 import { JobQueue } from './utils/job-queue.js';
 import { mapValuesDeep } from './utils/map-values-deep.js';
-import { redact } from './utils/redact.js';
+import { redactObject } from './utils/redact-object.js';
 import { sanitizeError } from './utils/sanitize-error.js';
 import { scheduleSynchronizedJob, validateCron } from './utils/schedule.js';
 let flowManager;
@@ -38,8 +38,10 @@ class FlowManager {
     operationFlowHandlers = {};
     webhookFlowHandlers = {};
     reloadQueue;
+    envs;
     constructor() {
         this.reloadQueue = new JobQueue();
+        this.envs = env['FLOWS_ENV_ALLOW_LIST'] ? pick(env, toArray(env['FLOWS_ENV_ALLOW_LIST'])) : {};
         const messenger = getMessenger();
         messenger.subscribe('flows', (event) => {
             if (event['type'] === 'reload') {
@@ -238,7 +240,7 @@ class FlowManager {
             [TRIGGER_KEY]: data,
             [LAST_KEY]: data,
             [ACCOUNTABILITY_KEY]: context?.['accountability'] ?? null,
-            [ENV_KEY]: pick(env, env['FLOWS_ENV_ALLOW_LIST'] ? toArray(env['FLOWS_ENV_ALLOW_LIST']) : []),
+            [ENV_KEY]: this.envs,
         };
         let nextOperation = flow.operation;
         let lastOperationStatus = 'unknown';
@@ -276,14 +278,17 @@ class FlowManager {
                     collection: 'directus_flows',
                     item: flow.id,
                     data: {
-                        steps: steps,
-                        data: redact(omit(keyedData, '$accountability.permissions'), // Permissions is a ton of data, and is just a copy of what's in the directus_permissions table
-                        [
-                            ['**', 'headers', 'authorization'],
-                            ['**', 'headers', 'cookie'],
-                            ['**', 'query', 'access_token'],
-                            ['**', 'payload', 'password'],
-                        ], REDACTED_TEXT),
+                        steps: steps.map((step) => redactObject(step, { values: this.envs }, getRedactedString)),
+                        data: redactObject(omit(keyedData, '$accountability.permissions'), // Permissions is a ton of data, and is just a copy of what's in the directus_permissions table
+                        {
+                            keys: [
+                                ['**', 'headers', 'authorization'],
+                                ['**', 'headers', 'cookie'],
+                                ['**', 'query', 'access_token'],
+                                ['**', 'payload', 'password'],
+                            ],
+                            values: this.envs,
+                        }, getRedactedString),
                     },
                 });
             }

package/dist/logger.js

@@ -1,5 +1,4 @@
-import { REDACTED_TEXT } from '@directus/constants';
-import { toArray } from '@directus/utils';
+import { REDACTED_TEXT, toArray } from '@directus/utils';
 import { merge } from 'lodash-es';
 import { pino } from 'pino';
 import { pinoHttp, stdSerializers } from 'pino-http';

package/dist/middleware/respond.js

@@ -1,7 +1,9 @@
 import { parse as parseBytesConfiguration } from 'bytes';
+import { assign } from 'lodash-es';
 import { getCache, setCacheValue } from '../cache.js';
 import env from '../env.js';
 import logger from '../logger.js';
+import { BranchesService } from '../services/branches.js';
 import { ExportService } from '../services/import-export.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';
@@ -39,6 +41,24 @@ export const respond = asyncHandler(async (req, res) => {
         res.setHeader('Cache-Control', 'no-cache');
         res.setHeader('Vary', 'Origin, Cache-Control');
     }
+    if (req.sanitizedQuery.branch &&
+        req.collection &&
+        (req.singleton || req.params['pk']) &&
+        'data' in res.locals['payload']) {
+        const branchesService = new BranchesService({ accountability: req.accountability ?? null, schema: req.schema });
+        const filter = {
+            name: { _eq: req.sanitizedQuery.branch },
+            collection: { _eq: req.collection },
+        };
+        if (req.params['pk']) {
+            filter['item'] = { _eq: req.params['pk'] };
+        }
+        const branch = await branchesService.readByQuery({ filter });
+        if (branch[0]) {
+            const commits = await branchesService.getBranchCommits(branch[0]['id']);
+            assign(res.locals['payload'].data, ...commits);
+        }
+    }
     if (req.sanitizedQuery.export) {
         const exportService = new ExportService({ accountability: req.accountability ?? null, schema: req.schema });
         let filename = '';

package/dist/operations/exec/index.js

@@ -1,38 +1,47 @@
-import { defineOperationApi, toArray } from '@directus/utils';
-import { isBuiltin } from 'node:module';
-import { NodeVM, VMScript } from 'vm2';
+import { defineOperationApi } from '@directus/utils';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const ivm = require('isolated-vm');
+/**
+ * A helper for making the logs prettier.
+ * The logger prints arrays with their indices but this looks "bad" when you have only one argument.
+ */
+function unpackArgs(args) {
+    return args.length === 1 ? args[0] : args;
+}
 export default defineOperationApi({
     id: 'exec',
-    handler: async ({ code }, { data, env }) => {
-        const allowedModules = env['FLOWS_EXEC_ALLOWED_MODULES'] ? toArray(env['FLOWS_EXEC_ALLOWED_MODULES']) : [];
-        const allowedModulesBuiltIn = [];
-        const allowedModulesExternal = [];
+    handler: async ({ code }, { data, env, logger }) => {
         const allowedEnv = data['$env'] ?? {};
-        const opts = {
-            eval: false,
-            wasm: false,
-            env: allowedEnv,
-        };
-        for (const module of allowedModules) {
-            if (isBuiltin(module)) {
-                allowedModulesBuiltIn.push(module);
-            }
-            else {
-                allowedModulesExternal.push(module);
-            }
-        }
-        if (allowedModules.length > 0) {
-            opts.require = {
-                builtin: allowedModulesBuiltIn,
-                external: {
-                    modules: allowedModulesExternal,
-                    transitive: false,
-                },
-            };
-        }
-        const vm = new NodeVM(opts);
-        const script = new VMScript(code).compile();
-        const fn = await vm.run(script);
-        return await fn(data);
+        const isolateSizeMb = env['FLOWS_RUN_SCRIPT_MAX_MEMORY'];
+        const scriptTimeoutMs = env['FLOWS_RUN_SCRIPT_TIMEOUT'];
+        const isolate = new ivm.Isolate({ memoryLimit: isolateSizeMb });
+        const context = isolate.createContextSync();
+        const jail = context.global;
+        jail.setSync('global', jail.derefInto());
+        jail.setSync('process', { env: allowedEnv }, { copy: true });
+        jail.setSync('module', { exports: null }, { copy: true });
+        jail.setSync('console', {
+            log: new ivm.Callback((...args) => logger.info(unpackArgs(args)), { sync: true }),
+            info: new ivm.Callback((...args) => logger.info(unpackArgs(args)), { sync: true }),
+            warn: new ivm.Callback((...args) => logger.warn(unpackArgs(args)), { sync: true }),
+            error: new ivm.Callback((...args) => logger.error(unpackArgs(args)), { sync: true }),
+            trace: new ivm.Callback((...args) => logger.trace(unpackArgs(args)), { sync: true }),
+            debug: new ivm.Callback((...args) => logger.debug(unpackArgs(args)), { sync: true }),
+        }, { copy: true });
+        // Run the operation once to define the module.exports function
+        await context.eval(code, { timeout: scriptTimeoutMs });
+        const inputData = new ivm.ExternalCopy({ data });
+        const resultRef = await context.evalClosure(`return module.exports($0.data)`, [inputData.copyInto()], {
+            result: { reference: true, promise: true },
+            timeout: scriptTimeoutMs,
+        });
+        const result = await resultRef.copy();
+        // Memory cleanup
+        resultRef.release();
+        inputData.release();
+        context.release();
+        isolate.dispose();
+        return result;
     },
 });

package/dist/operations/json-web-token/index.d.ts

@@ -0,0 +1,10 @@
+import jwt from 'jsonwebtoken';
+type Options = {
+    operation: string;
+    payload?: Record<string, any> | string;
+    token?: string;
+    secret?: jwt.Secret;
+    options?: any;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;