@axium/server 0.24.0 → 0.25.0

package/dist/audit.d.ts

@@ -1,35 +1,8 @@
-import type { Insertable } from 'kysely';
+import { Severity, type AuditEvent, type AuditFilter } from '@axium/core/audit';
+import type { Insertable, SelectQueryBuilder } from 'kysely';
 import * as z from 'zod';
 import { type Schema } from './database.js';
-export declare enum Severity {
-    Emergency = 0,
-    Alert = 1,
-    Critical = 2,
-    Error = 3,
-    Warning = 4,
-    Notice = 5,
-    Info = 6,
-    Debug = 7
-}
 export declare function styleSeverity(sev: Severity, align?: boolean): string;
-export interface AuditEvent<T extends Record<string, unknown> = Record<string, unknown>> {
-    /** UUID of the event */
-    id: string;
-    /** UUID of the user that triggered the event. `null` for events triggered via the server CLI */
-    userId?: string | null;
-    /** When the event happened */
-    timestamp: Date;
-    /** How severe the event is */
-    severity: Severity;
-    /** Snake case name for the event */
-    name: string;
-    /** The source of the event. This should be a package name */
-    source: string;
-    /** Tags for the event. For example, `auth` for authentication events */
-    tags: string[];
-    /** Additional event specific data. */
-    extra: T;
-}
 export interface AuditEventInit extends Insertable<Schema['audit_log']> {
 }
 export declare function audit_raw(event: AuditEventInit): Promise<void>;
@@ -48,6 +21,10 @@ export interface $EventTypes {
     admin_change: {
         user: string;
     };
+    admin_api: {
+        route: string;
+        session: string;
+    };
 }
 export type EventName = keyof $EventTypes;
 export type EventExtra<T extends EventName> = $EventTypes[T];
@@ -71,13 +48,4 @@ export interface AuditEventConfig {
 }
 export declare function addEvent(init: AuditEventConfigInit): void;
 export declare function audit<T extends EventName>(eventName: T, userId?: string, extra?: EventExtra<T>): Promise<void>;
-export interface AuditFilter {
-    since?: Date;
-    until?: Date;
-    user?: string | null;
-    severity?: Severity;
-    source?: string;
-    tags?: string[];
-    event?: string;
-}
-export declare function getEvents(filter: AuditFilter): Promise<AuditEvent[]>;
+export declare function getEvents(filter: AuditFilter): SelectQueryBuilder<Schema, 'audit_log', AuditEvent>;

package/dist/audit.js

@@ -1,20 +1,10 @@
+import { Severity } from '@axium/core/audit';
 import { styleText } from 'node:util';
 import { capitalize, omit } from 'utilium';
 import * as z from 'zod';
 import config from './config.js';
 import { database } from './database.js';
 import * as io from './io.js';
-export var Severity;
-(function (Severity) {
-    Severity[Severity["Emergency"] = 0] = "Emergency";
-    Severity[Severity["Alert"] = 1] = "Alert";
-    Severity[Severity["Critical"] = 2] = "Critical";
-    Severity[Severity["Error"] = 3] = "Error";
-    Severity[Severity["Warning"] = 4] = "Warning";
-    Severity[Severity["Notice"] = 5] = "Notice";
-    Severity[Severity["Info"] = 6] = "Info";
-    Severity[Severity["Debug"] = 7] = "Debug";
-})(Severity || (Severity = {}));
 const severityFormat = {
     [Severity.Emergency]: ['bgRedBright', 'white', 'underline'],
     [Severity.Alert]: ['bgRedBright', 'white'],
@@ -83,7 +73,7 @@ export async function audit(eventName, userId, extra) {
             .catch(() => null);
     }
 }
-export async function getEvents(filter) {
+export function getEvents(filter) {
     let query = database.selectFrom('audit_log').selectAll();
     if ('user' in filter && !filter.user)
         query = query.where('userId', 'is', null);
@@ -101,7 +91,7 @@ export async function getEvents(filter) {
         query = query.where('timestamp', '>=', filter.since);
     if (filter.until)
         query = query.where('timestamp', '<=', filter.until);
-    return await query.execute();
+    return query;
 }
 // Register built-ins
 addEvent({ source: '@axium/server', name: 'user_created', severity: Severity.Info, tags: ['user'] });
@@ -123,3 +113,10 @@ addEvent({
     extra: { item: z.string() },
     noAutoSuspend: true,
 });
+addEvent({
+    source: '@axium/server',
+    name: 'admin_api',
+    severity: Severity.Debug,
+    tags: ['auth'],
+    extra: { route: z.string(), session: z.string() },
+});

package/dist/auth.d.ts

@@ -1,14 +1,7 @@
-import type { Passkey, Permission, Session, User, Verification } from '@axium/core';
+import type { Passkey, Permission, Session, UserInternal, Verification } from '@axium/core';
 import type { Insertable } from 'kysely';
 import * as acl from './acl.js';
 import { type Schema } from './database.js';
-import type { RequestEvent } from './requests.js';
-export interface UserInternal extends User {
-    isAdmin: boolean;
-    isSuspended: boolean;
-    /** Tags are internal, roles are public */
-    tags: string[];
-}
 export declare function getUser(id: string): Promise<UserInternal>;
 export declare function updateUser({ id, ...user }: Insertable<Schema['users']>): Promise<UserInternal>;
 export interface SessionInternal extends Session {
@@ -33,7 +26,7 @@ export interface VerificationInternal extends Verification {
 export declare function createVerification(role: VerificationRole, userId: string, expires: number): Promise<VerificationInternal>;
 export declare function useVerification(role: VerificationRole, userId: string, token: string): Promise<VerificationInternal | undefined>;
 export interface PasskeyInternal extends Passkey {
-    publicKey: Uint8Array;
+    publicKey: Uint8Array<ArrayBuffer>;
     counter: number;
 }
 export declare function getPasskey(id: string): Promise<PasskeyInternal>;
@@ -44,11 +37,11 @@ export interface UserAuthResult extends SessionAndUser {
     /** The user authenticating the request. */
     accessor: UserInternal;
 }
-export declare function checkAuthForUser(event: RequestEvent, userId: string, sensitive?: boolean): Promise<UserAuthResult>;
+export declare function checkAuthForUser(request: Request, userId: string, sensitive?: boolean): Promise<UserAuthResult>;
 export interface ItemAuthResult<T extends acl.Target> {
     fromACL: boolean;
     item: T;
     user?: UserInternal;
     session?: SessionInternal;
 }
-export declare function checkAuthForItem<const V extends acl.Target>(event: RequestEvent, itemType: acl.TargetName, itemId: string, permission: Permission): Promise<ItemAuthResult<V>>;
+export declare function checkAuthForItem<const V extends acl.Target>(request: Request, itemType: acl.TargetName, itemId: string, permission: Permission): Promise<ItemAuthResult<V>>;

package/dist/auth.js

@@ -87,8 +87,8 @@ export async function updatePasskeyCounter(id, newCounter) {
         throw new Error('Passkey not found');
     return passkey;
 }
-export async function checkAuthForUser(event, userId, sensitive = false) {
-    const token = getToken(event, sensitive);
+export async function checkAuthForUser(request, userId, sensitive = false) {
+    const token = getToken(request, sensitive);
     if (!token)
         throw error(401, 'Missing token');
     const session = await getSessionAndUser(token).catch(withError('Invalid or expired session', 401));
@@ -106,8 +106,8 @@ export async function checkAuthForUser(event, userId, sensitive = false) {
         error(403, 'This token can not be used for sensitive actions');
     return Object.assign(session, { accessor: session.user });
 }
-export async function checkAuthForItem(event, itemType, itemId, permission) {
-    const token = getToken(event, false);
+export async function checkAuthForItem(request, itemType, itemId, permission) {
+    const token = getToken(request, false);
     if (!token)
         error(401, 'Missing token');
     const session = await getSessionAndUser(token).catch(() => null);

package/dist/cli.js

@@ -51,24 +51,26 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { AuditFilter } from '@axium/core/audit';
+import { severityNames } from '@axium/core/audit';
 import { formatDateRange } from '@axium/core/format';
 import { Argument, Option, program } from 'commander';
 import { spawnSync } from 'node:child_process';
 import { access } from 'node:fs/promises';
-import { join } from 'node:path/posix';
+import { join, resolve } from 'node:path/posix';
 import { createInterface } from 'node:readline/promises';
 import { styleText } from 'node:util';
-import { capitalize, getByString, isJSON, setByString, uncapitalize } from 'utilium';
+import { getByString, isJSON, setByString } from 'utilium';
 import * as z from 'zod';
 import $pkg from '../package.json' with { type: 'json' };
 import { apps } from './apps.js';
-import { audit, getEvents, Severity, styleSeverity } from './audit.js';
+import { audit, getEvents, styleSeverity } from './audit.js';
 import config, { configFiles, FileSchema, saveConfigTo } from './config.js';
 import * as db from './database.js';
 import * as io from './io.js';
 import { linkRoutes, listRouteLinks, unlinkRoutes } from './linking.js';
-import { getSpecifier, plugins, pluginText, resolvePlugin } from './plugins.js';
-import { serveSvelteKit } from './serve.js';
+import { plugins, pluginText } from './plugins.js';
+import { serve } from './serve.js';
 function readline() {
     const rl = createInterface({
         input: process.stdin,
@@ -82,19 +84,22 @@ function userText(user, bold = false) {
     const text = `${user.name} <${user.email}> (${user.id})`;
     return bold ? styleText('bold', text) : text;
 }
+let safe = false;
 program
     .version($pkg.version)
     .name('axium')
     .description('Axium server CLI')
     .configureHelp({ showGlobalOptions: true })
+    .option('--safe', 'do not execute code from plugins')
     .option('--debug', 'override debug mode')
     .option('--no-debug', 'override debug mode')
     .option('-c, --config <path>', 'path to the config file');
+program.on('option:safe', () => (safe = true));
 program.on('option:debug', () => config.set({ debug: true }));
-program.on('option:config', () => void config.load(program.opts().config));
+program.on('option:config', () => void config.load(program.opts().config, { safe }));
 const noAutoDB = ['init', 'serve', 'check'];
 program.hook('preAction', async function (_, action) {
-    await config.loadDefaults();
+    await config.loadDefaults(safe);
     const opt = action.optsWithGlobals();
     opt.force && io.output.warn('--force: Protections disabled.');
     if (typeof opt.debug == 'boolean') {
@@ -275,24 +280,26 @@ axiumPlugin
         return;
     }
     if (!opt.long) {
-        console.log(Array.from(plugins)
-            .map(plugin => plugin.name)
-            .join(', '));
+        console.log(Array.from(plugins.keys()).join(', '));
         return;
     }
     console.log(styleText('whiteBright', plugins.size + ' plugin(s) loaded:'));
-    for (const plugin of plugins) {
+    for (const plugin of plugins.values()) {
         console.log(plugin.name, opt.versions ? plugin.version : '');
     }
 });
+function _findPlugin(search) {
+    const plugin = plugins.get(search) ?? plugins.values().find(p => p.specifier.toLowerCase() == search.toLowerCase());
+    if (!plugin)
+        io.exit(`Can't find a plugin matching "${search}"`);
+    return plugin;
+}
 axiumPlugin
     .command('info')
     .description('Get information about a plugin')
     .argument('<plugin>', 'the plugin to get information about')
     .action((search) => {
-    const plugin = resolvePlugin(search);
-    if (!plugin)
-        io.exit(`Can't find a plugin matching "${search}"`);
+    const plugin = _findPlugin(search);
     console.log(pluginText(plugin));
 });
 axiumPlugin
@@ -301,18 +308,15 @@ axiumPlugin
     .description('Remove a plugin')
     .argument('<plugin>', 'the plugin to remove')
     .action(async (search, opt) => {
-    const plugin = resolvePlugin(search);
-    if (!plugin)
-        io.exit(`Can't find a plugin matching "${search}"`);
-    const specifier = getSpecifier(plugin);
-    await plugin.hooks.remove?.(opt);
+    const plugin = _findPlugin(search);
+    await plugin._hooks?.remove?.(opt);
     for (const [path, data] of configFiles) {
         if (!data.plugins)
             continue;
-        data.plugins = data.plugins.filter(p => p !== specifier);
+        data.plugins = data.plugins.filter(p => p !== plugin.specifier);
         saveConfigTo(path, data);
     }
-    plugins.delete(plugin);
+    plugins.delete(plugin.name);
 });
 axiumPlugin
     .command('init')
@@ -325,11 +329,11 @@ axiumPlugin
     .action(async (search, opt) => {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const plugin = resolvePlugin(search);
+        const plugin = _findPlugin(search);
         if (!plugin)
             io.exit(`Can't find a plugin matching "${search}"`);
         const _ = __addDisposableResource(env_1, db.connect(), true);
-        await plugin.hooks.db_init?.({ force: false, ...opt, skip: true });
+        await plugin._hooks?.db_init?.({ force: false, ...opt, skip: true });
     }
     catch (e_1) {
         env_1.error = e_1;
@@ -539,13 +543,11 @@ program
     catch {
         console.log(styleText('red', 'Unavailable'));
     }
-    console.log(styleText('whiteBright', 'Loaded plugins:'), styleText(['dim', 'bold'], `(${plugins.size || 'none'})`), Array.from(plugins)
-        .map(plugin => plugin.name)
-        .join(', '));
-    for (const plugin of plugins) {
-        if (!plugin.statusText)
+    console.log(styleText('whiteBright', 'Loaded plugins:'), styleText(['dim', 'bold'], `(${plugins.size || 'none'})`), Array.from(plugins.keys()).join(', '));
+    for (const plugin of plugins.values()) {
+        if (!plugin._hooks?.statusText)
             continue;
-        const text = await plugin.statusText();
+        const text = await plugin._hooks?.statusText();
         console.log(styleText('bold', plugin.name), plugin.version + ':', text.includes('\n') ? '\n' + text : text);
     }
 });
@@ -568,20 +570,19 @@ program
     .action(async (opt) => {
     await db.init({ ...opt, skip: opt.dbSkip }).catch(io.handleError);
     await io.restrictedPorts({ method: 'node-cap', action: 'enable' }).catch(io.handleError);
-    linkRoutes(opt);
 });
 program
     .command('serve')
     .description('Start the Axium server')
     .option('-p, --port <port>', 'the port to listen on')
     .option('--ssl <prefix>', 'the prefix for the cert.pem and key.pem SSL files')
-    .option('-B, --build', 'the path to a built SvelteKit server handler')
+    .option('-b, --build <path>', 'the path to the handler build')
     .action(async (opt) => {
-    const server = await serveSvelteKit({
+    const server = await serve({
         secure: opt.ssl ? true : config.web.secure,
         ssl_cert: opt.ssl ? join(opt.ssl, 'cert.pem') : config.web.ssl_cert,
         ssl_key: opt.ssl ? join(opt.ssl, 'key.pem') : config.web.ssl_key,
-        build: opt.build ?? config.web.build,
+        build: opt.build ? resolve(opt.build) : undefined,
     });
     const port = !Number.isNaN(Number.parseInt(opt.port ?? '')) ? Number.parseInt(opt.port) : config.web.port;
     server.listen(port, () => {
@@ -622,31 +623,16 @@ program
     .option('-t, --include-tags', 'Include tags when listing events')
     .addOption(new Option('-s, --summary', 'Summarize audit log entries instead of displaying individual ones').conflicts(['extra', 'includeTags']))
     .optionsGroup('Filters:')
-    .addOption(new Option('--since <date>', 'Filter for events since a date').argParser(v => new Date(v)))
-    .addOption(new Option('--until <date>', 'Filter for events until a date').argParser(v => new Date(v)))
-    .addOption(new Option('--user <uuid|null>', 'Filter for events triggered by a user').argParser(v => {
-    try {
-        return z.union([z.uuid(), z.literal(['null', '']).transform(() => null)]).parse(v);
-    }
-    catch (e) {
-        throw z.prettifyError(e);
-    }
-}))
-    .addOption(new Option('--severity <level>', 'Filter for events at or above a severity level')
-    .choices(Object.keys(Severity)
-    .filter(k => isNaN(Number(k)))
-    .map(uncapitalize))
-    .argParser(v => {
-    const cap = capitalize(v);
-    if (!(cap in Severity))
-        throw new Error('Invalid severity: ' + v);
-    return Severity[cap];
-}))
+    .option('--since <date>', 'Filter for events since a date')
+    .option('--until <date>', 'Filter for events until a date')
+    .option('--user <uuid|null>', 'Filter for events triggered by a user')
+    .addOption(new Option('--severity <level>', 'Filter for events at or above a severity level').choices(severityNames))
     .option('--source <source>', 'Filter by source')
     .option('--tag <tag...>', 'Filter by tag(s)')
     .option('--event <event>', 'Filter by event name')
     .action(async (opt) => {
-    const events = await getEvents(opt);
+    const filter = await AuditFilter.parseAsync(opt).catch(e => io.exit('Invalid filter: ' + z.prettifyError(e)));
+    const events = await getEvents(filter).execute();
     if (opt.summary) {
         const groups = Object.groupBy(events, e => e.severity);
         const maxGroupLength = Math.max(...Object.values(groups).map(g => g.length.toString().length), 0);

package/dist/config.d.ts

@@ -1,6 +1,7 @@
 import { type DeepRequired } from 'utilium';
 import * as z from 'zod';
 export declare const ConfigSchema: z.ZodObject<{
+    admin_api: z.ZodOptional<z.ZodBoolean>;
     allow_new_users: z.ZodOptional<z.ZodBoolean>;
     apps: z.ZodOptional<z.ZodObject<{
         disabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -8,8 +9,8 @@ export declare const ConfigSchema: z.ZodObject<{
     audit: z.ZodOptional<z.ZodObject<{
         allow_raw: z.ZodOptional<z.ZodBoolean>;
         retention: z.ZodOptional<z.ZodNumber>;
-        min_severity: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Error" | "notice" | "info" | "warning" | "Emergency" | "Alert" | "Critical" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical">>;
-        auto_suspend: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Error" | "notice" | "info" | "warning" | "Emergency" | "Alert" | "Critical" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical">>;
+        min_severity: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Emergency" | "Alert" | "Critical" | "Error" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical" | "warning" | "notice" | "info">>;
+        auto_suspend: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Emergency" | "Alert" | "Critical" | "Error" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical" | "warning" | "notice" | "info">>;
     }, z.core.$loose>>;
     auth: z.ZodOptional<z.ZodObject<{
         origin: z.ZodOptional<z.ZodString>;
@@ -34,16 +35,15 @@ export declare const ConfigSchema: z.ZodObject<{
         level: z.ZodOptional<z.ZodEnum<{
             error: "error";
             debug: "debug";
-            warn: "warn";
             notice: "notice";
             info: "info";
+            warn: "warn";
         }>>;
         console: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$loose>>;
+    request_size_limit: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     show_duplicate_state: z.ZodOptional<z.ZodBoolean>;
     web: z.ZodOptional<z.ZodObject<{
-        assets: z.ZodOptional<z.ZodString>;
-        build: z.ZodOptional<z.ZodString>;
         disable_cache: z.ZodOptional<z.ZodBoolean>;
         port: z.ZodOptional<z.ZodNumber>;
         prefix: z.ZodOptional<z.ZodString>;
@@ -51,13 +51,13 @@ export declare const ConfigSchema: z.ZodObject<{
         secure: z.ZodOptional<z.ZodBoolean>;
         ssl_key: z.ZodOptional<z.ZodString>;
         ssl_cert: z.ZodOptional<z.ZodString>;
-        template: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>;
 }, z.core.$loose>;
 export interface Config extends z.infer<typeof ConfigSchema> {
 }
 export declare const configFiles: Map<string, File>;
 export declare function plainConfig(): Omit<DeepRequired<Config>, keyof typeof configShortcuts>;
+export declare const defaultConfig: DeepRequired<Config>;
 declare const configShortcuts: {
     findPath: typeof findConfigPaths;
     load: typeof loadConfig;
@@ -67,12 +67,14 @@ declare const configShortcuts: {
     saveTo: typeof saveConfigTo;
     set: typeof setConfig;
     files: Map<string, File>;
+    defaults: DeepRequired<Config>;
 };
 export declare const config: DeepRequired<Config> & typeof configShortcuts;
 export default config;
 export declare const FileSchema: z.ZodObject<{
     include: z.ZodOptional<z.ZodArray<z.ZodString>>;
     plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    admin_api: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
     allow_new_users: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
     apps: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         disabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -80,8 +82,8 @@ export declare const FileSchema: z.ZodObject<{
     audit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         allow_raw: z.ZodOptional<z.ZodBoolean>;
         retention: z.ZodOptional<z.ZodNumber>;
-        min_severity: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Error" | "notice" | "info" | "warning" | "Emergency" | "Alert" | "Critical" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical">>;
-        auto_suspend: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Error" | "notice" | "info" | "warning" | "Emergency" | "Alert" | "Critical" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical">>;
+        min_severity: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Emergency" | "Alert" | "Critical" | "Error" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical" | "warning" | "notice" | "info">>;
+        auto_suspend: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Emergency" | "Alert" | "Critical" | "Error" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical" | "warning" | "notice" | "info">>;
     }, z.core.$loose>>>;
     auth: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         origin: z.ZodOptional<z.ZodString>;
@@ -106,16 +108,15 @@ export declare const FileSchema: z.ZodObject<{
         level: z.ZodOptional<z.ZodEnum<{
             error: "error";
             debug: "debug";
-            warn: "warn";
             notice: "notice";
             info: "info";
+            warn: "warn";
         }>>;
         console: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$loose>>>;
+    request_size_limit: z.ZodOptional<z.ZodOptional<z.ZodOptional<z.ZodNumber>>>;
     show_duplicate_state: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
     web: z.ZodOptional<z.ZodOptional<z.ZodObject<{
-        assets: z.ZodOptional<z.ZodString>;
-        build: z.ZodOptional<z.ZodString>;
         disable_cache: z.ZodOptional<z.ZodBoolean>;
         port: z.ZodOptional<z.ZodNumber>;
         prefix: z.ZodOptional<z.ZodString>;
@@ -123,12 +124,11 @@ export declare const FileSchema: z.ZodObject<{
         secure: z.ZodOptional<z.ZodBoolean>;
         ssl_key: z.ZodOptional<z.ZodString>;
         ssl_cert: z.ZodOptional<z.ZodString>;
-        template: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;
 export interface File extends z.infer<typeof FileSchema> {
 }
-export declare function addConfigDefaults(other: Config, _target?: Record<string, any>): void;
+export declare function addConfigDefaults(other: Config, _target?: Record<string, any>, _noDefault?: boolean): void;
 /**
  * Update the current config
  */
@@ -142,16 +142,26 @@ export interface LoadOptions {
      * If enabled, the config file will be skipped if it does not exist.
      */
     optional?: boolean;
+    /**
+     * If enabled, code from plugins will not be executed.
+     */
+    safe?: boolean;
     /**
      * If `optional`, this function will be called with the error if the config file is invalid or can't be read.
      */
     onError?(error: Error): void;
+    /**
+     * Used to mark included files
+     * @internal
+     */
+    _markIncluded?: boolean;
 }
 /**
  * Load the config from the provided path
  */
 export declare function loadConfig(path: string, options?: LoadOptions): Promise<void>;
-export declare function loadDefaultConfigs(): Promise<void>;
+export declare function loadDefaultConfigs(safe?: boolean): Promise<void>;
+export declare function reloadConfigs(safe?: boolean): Promise<void>;
 /**
  * Update the current config and write the updated config to the appropriate file
  */