directus-template-cli 0.5.0-beta.9 → 0.5.1

package/dist/lib/load/load-policies.js

@@ -10,26 +10,28 @@ const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadPolicies(dir) {
     const policies = (0, read_file_1.default)('policies', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${policies.length} policies`));
-    // Fetch existing policies
-    const existingPolicies = await sdk_2.api.client.request((0, sdk_1.readPolicies)({
-        limit: -1,
-    }));
-    const existingPolicyIds = new Set(existingPolicies.map(policy => policy.id));
-    const PUBLIC_POLICY_ID = 'abf8a154-5b1c-4a46-ac9c-7300570f4f17';
-    const policiesWithoutPublic = policies.filter(policy => policy.id !== PUBLIC_POLICY_ID);
-    for await (const policy of policiesWithoutPublic) {
-        try {
-            if (existingPolicyIds.has(policy.id)) {
-                core_1.ux.action.status = `Skipping existing policy: ${policy.name}`;
-                continue;
+    if (policies && policies.length > 0) {
+        // Fetch existing policies
+        const existingPolicies = await sdk_2.api.client.request((0, sdk_1.readPolicies)({
+            limit: -1,
+        }));
+        const existingPolicyIds = new Set(existingPolicies.map(policy => policy.id));
+        const PUBLIC_POLICY_ID = 'abf8a154-5b1c-4a46-ac9c-7300570f4f17';
+        const policiesWithoutPublic = policies.filter(policy => policy.id !== PUBLIC_POLICY_ID);
+        for await (const policy of policiesWithoutPublic) {
+            try {
+                if (existingPolicyIds.has(policy.id)) {
+                    core_1.ux.action.status = `Skipping existing policy: ${policy.name}`;
+                    continue;
+                }
+                // Create new policy
+                await sdk_2.api.client.request((0, sdk_1.createPolicy)(policy));
+                // Add the new policy ID to our set of existing policies
+                existingPolicyIds.add(policy.id);
+            }
+            catch (error) {
+                (0, catch_error_1.default)(error);
             }
-            // Create new policy
-            await sdk_2.api.client.request((0, sdk_1.createPolicy)(policy));
-            // Add the new policy ID to our set of existing policies
-            existingPolicyIds.add(policy.id);
-        }
-        catch (error) {
-            (0, catch_error_1.default)(error);
         }
     }
     core_1.ux.action.stop();

package/dist/lib/load/load-presets.js

@@ -10,31 +10,33 @@ const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadPresets(dir) {
     const presets = (0, read_file_1.default)('presets', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${presets.length} presets`));
-    // Fetch existing presets
-    const existingPresets = await sdk_2.api.client.request((0, sdk_1.readPresets)({
-        limit: -1,
-    }));
-    const existingPresetIds = new Set(existingPresets.map(preset => preset.id));
-    const presetsToAdd = presets.filter(preset => {
-        if (existingPresetIds.has(preset.id)) {
-            return false;
+    if (presets && presets.length > 0) {
+        // Fetch existing presets
+        const existingPresets = await sdk_2.api.client.request((0, sdk_1.readPresets)({
+            limit: -1,
+        }));
+        const existingPresetIds = new Set(existingPresets.map(preset => preset.id));
+        const presetsToAdd = presets.filter(preset => {
+            if (existingPresetIds.has(preset.id)) {
+                return false;
+            }
+            return true;
+        }).map(preset => {
+            const cleanPreset = { ...preset };
+            cleanPreset.user = null;
+            return cleanPreset;
+        });
+        if (presetsToAdd.length > 0) {
+            try {
+                await sdk_2.api.client.request((0, sdk_1.createPresets)(presetsToAdd));
+            }
+            catch (error) {
+                (0, catch_error_1.default)(error);
+            }
         }
-        return true;
-    }).map(preset => {
-        const cleanPreset = { ...preset };
-        cleanPreset.user = null;
-        return cleanPreset;
-    });
-    if (presetsToAdd.length > 0) {
-        try {
-            await sdk_2.api.client.request((0, sdk_1.createPresets)(presetsToAdd));
+        else {
+            // ux.info('-- No new presets to create')
         }
-        catch (error) {
-            (0, catch_error_1.default)(error);
-        }
-    }
-    else {
-        // ux.info('-- No new presets to create')
     }
     core_1.ux.action.stop();
 }

package/dist/lib/load/load-relations.js

@@ -13,21 +13,23 @@ const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadRelations(dir) {
     const relations = (0, read_file_1.default)('relations', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${relations.length} relations`));
-    // Fetch existing relations
-    const existingRelations = await sdk_2.api.client.request((0, sdk_1.readRelations)());
-    const existingRelationKeys = new Set(existingRelations.map(relation => `${relation.collection}:${relation.field}:${relation.related_collection}`));
-    const relationsToAdd = relations.filter(relation => {
-        const key = `${relation.collection}:${relation.field}:${relation.related_collection}`;
-        if (existingRelationKeys.has(key)) {
-            return false;
-        }
-        return true;
-    }).map(relation => {
-        const cleanRelation = { ...relation };
-        delete cleanRelation.meta.id;
-        return cleanRelation;
-    });
-    await addRelations(relationsToAdd);
+    if (relations && relations.length > 0) {
+        // Fetch existing relations
+        const existingRelations = await sdk_2.api.client.request((0, sdk_1.readRelations)());
+        const existingRelationKeys = new Set(existingRelations.map(relation => `${relation.collection}:${relation.field}:${relation.related_collection}`));
+        const relationsToAdd = relations.filter(relation => {
+            const key = `${relation.collection}:${relation.field}:${relation.related_collection}`;
+            if (existingRelationKeys.has(key)) {
+                return false;
+            }
+            return true;
+        }).map(relation => {
+            const cleanRelation = { ...relation };
+            delete cleanRelation.meta.id;
+            return cleanRelation;
+        });
+        await addRelations(relationsToAdd);
+    }
     core_1.ux.action.stop();
 }
 exports.default = loadRelations;

package/dist/lib/load/load-roles.js

@@ -11,50 +11,52 @@ const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadRoles(dir) {
     const roles = (0, read_file_1.default)('roles', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${roles.length} roles`));
-    const { legacyAdminRoleId, newAdminRoleId } = await (0, get_role_ids_1.default)(dir);
-    // Fetch existing roles
-    const existingRoles = await sdk_2.api.client.request((0, sdk_1.readRoles)({
-        limit: -1,
-    }));
-    const existingRoleIds = new Set(existingRoles.map(role => role.id));
-    const existingRoleNames = new Set(existingRoles.map(role => role.name.toLowerCase()));
-    const cleanedUpRoles = roles
-        .filter(role => role.name !== 'Administrator') // Don't load legacy admin role
-        .filter(role => !existingRoleNames.has(role.name.toLowerCase())) // Filter out roles with existing names
-        .map(role => {
-        const r = { ...role };
-        delete r.users; // Alias field. User roles will be applied when the users are loaded.
-        delete r.parent; // We need to load all roles first
-        return r;
-    });
-    for await (const role of cleanedUpRoles) {
-        try {
-            if (existingRoleIds.has(role.id)) {
-                continue;
+    if (roles && roles.length > 0) {
+        const { legacyAdminRoleId, newAdminRoleId } = await (0, get_role_ids_1.default)(dir);
+        // Fetch existing roles
+        const existingRoles = await sdk_2.api.client.request((0, sdk_1.readRoles)({
+            limit: -1,
+        }));
+        const existingRoleIds = new Set(existingRoles.map(role => role.id));
+        const existingRoleNames = new Set(existingRoles.map(role => role.name.toLowerCase()));
+        const cleanedUpRoles = roles
+            .filter(role => role.name !== 'Administrator') // Don't load legacy admin role
+            .filter(role => !existingRoleNames.has(role.name.toLowerCase())) // Filter out roles with existing names
+            .map(role => {
+            const r = { ...role };
+            delete r.users; // Alias field. User roles will be applied when the users are loaded.
+            delete r.parent; // We need to load all roles first
+            return r;
+        });
+        for await (const role of cleanedUpRoles) {
+            try {
+                if (existingRoleIds.has(role.id)) {
+                    continue;
+                }
+                // Create new role
+                await sdk_2.api.client.request((0, sdk_1.createRole)(role));
+                // Add the new role ID and name to our sets of existing roles
+                existingRoleIds.add(role.id);
+                existingRoleNames.add(role.name.toLowerCase());
             }
-            // Create new role
-            await sdk_2.api.client.request((0, sdk_1.createRole)(role));
-            // Add the new role ID and name to our sets of existing roles
-            existingRoleIds.add(role.id);
-            existingRoleNames.add(role.name.toLowerCase());
-        }
-        catch (error) {
-            (0, catch_error_1.default)(error);
-        }
-    }
-    // Now add in any parent fields
-    const rolesWithParents = roles.filter(role => role.parent !== null);
-    for await (const role of rolesWithParents) {
-        try {
-            // Remap any roles where the parent ID is the default admin role
-            if (role.parent === legacyAdminRoleId) {
-                role.parent = newAdminRoleId;
+            catch (error) {
+                (0, catch_error_1.default)(error);
             }
-            const simplifiedRole = { parent: role.parent };
-            await sdk_2.api.client.request((0, sdk_1.updateRole)(role.id, simplifiedRole));
         }
-        catch (error) {
-            (0, catch_error_1.default)(error);
+        // Now add in any parent fields
+        const rolesWithParents = roles.filter(role => role.parent !== null);
+        for await (const role of rolesWithParents) {
+            try {
+                // Remap any roles where the parent ID is the default admin role
+                if (role.parent === legacyAdminRoleId) {
+                    role.parent = newAdminRoleId;
+                }
+                const simplifiedRole = { parent: role.parent };
+                await sdk_2.api.client.request((0, sdk_1.updateRole)(role.id, simplifiedRole));
+            }
+            catch (error) {
+                (0, catch_error_1.default)(error);
+            }
         }
     }
     core_1.ux.action.stop();

package/dist/lib/load/load-translations.js

@@ -10,28 +10,30 @@ const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadTranslations(dir) {
     const translations = (0, read_file_1.default)('translations', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${translations.length} translations`));
-    // Fetch existing translations
-    const existingTranslations = await sdk_2.api.client.request((0, sdk_1.readTranslations)({
-        limit: -1,
-    }));
-    const existingTranslationKeys = new Set(existingTranslations.map(t => `${t.language}_${t.key}`));
-    const newTranslations = translations.filter(t => {
-        const key = `${t.language}_${t.key}`;
-        if (existingTranslationKeys.has(key)) {
-            return false;
+    if (translations && translations.length > 0) {
+        // Fetch existing translations
+        const existingTranslations = await sdk_2.api.client.request((0, sdk_1.readTranslations)({
+            limit: -1,
+        }));
+        const existingTranslationKeys = new Set(existingTranslations.map(t => `${t.language}_${t.key}`));
+        const newTranslations = translations.filter(t => {
+            const key = `${t.language}_${t.key}`;
+            if (existingTranslationKeys.has(key)) {
+                return false;
+            }
+            return true;
+        });
+        if (newTranslations.length > 0) {
+            try {
+                await sdk_2.api.client.request((0, sdk_1.createTranslations)(newTranslations));
+            }
+            catch (error) {
+                (0, catch_error_1.default)(error);
+            }
         }
-        return true;
-    });
-    if (newTranslations.length > 0) {
-        try {
-            await sdk_2.api.client.request((0, sdk_1.createTranslations)(newTranslations));
+        else {
+            // ux.info('-- No new translations to create')
         }
-        catch (error) {
-            (0, catch_error_1.default)(error);
-        }
-    }
-    else {
-        // ux.info('-- No new translations to create')
     }
     core_1.ux.action.stop();
 }

package/dist/lib/load/load-users.js

@@ -11,45 +11,48 @@ const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadUsers(dir) {
     const users = (0, read_file_1.default)('users', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${users.length} users`));
-    const { legacyAdminRoleId, newAdminRoleId } = await (0, get_role_ids_1.default)(dir);
-    const incomingUserEmails = users.map(user => user.email);
-    const incomingUserIds = users.map(user => user.id).filter(Boolean);
-    const existingUsers = await sdk_2.api.client.request((0, sdk_1.readUsers)({
-        filter: {
-            _or: [
-                { email: { _in: incomingUserEmails } },
-                { id: { _in: incomingUserIds } },
-            ],
-        },
-        limit: -1,
-    }));
-    const filteredUsers = users.map(user => {
-        // If the user is an admin, we need to change their role to the new admin role
-        const isAdmin = user.role === legacyAdminRoleId;
-        user.role = isAdmin ? newAdminRoleId : user.role;
-        // Delete the unneeded fields
-        delete user.last_page;
-        delete user.token;
-        delete user.policies;
-        // Delete passwords to prevent setting to *******
-        delete user.password;
-        return user;
-    });
-    for await (const user of filteredUsers) {
-        const existingUser = existingUsers.find(existing => existing.email === user.email || existing.id === user.id);
-        if (existingUser) {
-            // If user already exists, we'll skip creating a new one
-            delete user.email;
-            delete user.id;
-            // You might want to update the existing user here instead
-            // await api.client.request(updateUser(existingUser.id, user))
-            continue;
-        }
-        try {
-            await sdk_2.api.client.request((0, sdk_1.createUser)(user));
-        }
-        catch (error) {
-            (0, catch_error_1.default)(error);
+    if (users && users.length > 0) {
+        const { legacyAdminRoleId, newAdminRoleId } = await (0, get_role_ids_1.default)(dir);
+        const existingUsers = await sdk_2.api.client.request((0, sdk_1.readUsers)({
+            limit: -1,
+        }));
+        const filteredUsers = users.map(user => {
+            // If the user is an admin, we need to change their role to the new admin role
+            const isAdmin = user.role === legacyAdminRoleId;
+            user.role = isAdmin ? newAdminRoleId : user.role;
+            // Delete the unneeded fields
+            delete user.last_page;
+            delete user.token;
+            delete user.policies;
+            // Delete passwords to prevent setting to *******
+            delete user.password;
+            return user;
+        });
+        for await (const user of filteredUsers) {
+            const existingUserWithSameId = existingUsers && Array.isArray(existingUsers)
+                ? existingUsers.find(existing => existing.id === user.id)
+                : undefined;
+            const existingUserWithSameEmail = existingUsers && Array.isArray(existingUsers)
+                ? existingUsers.find(existing => existing.email === user.email)
+                : undefined;
+            if (existingUserWithSameId) {
+                // Skip if there's an existing user with the same id
+                continue;
+            }
+            if (existingUserWithSameEmail) {
+                // Delete email if there's an existing user with the same email but different id
+                delete user.email;
+            }
+            if (user.email === null) {
+                // Delete email if it's null
+                delete user.email;
+            }
+            try {
+                await sdk_2.api.client.request((0, sdk_1.createUser)(user));
+            }
+            catch (error) {
+                (0, catch_error_1.default)(error);
+            }
         }
     }
     core_1.ux.action.stop();

package/dist/lib/load/update-required-fields.d.ts

@@ -0,0 +1 @@
+export default function updateRequiredFields(dir: string): Promise<void>;

package/dist/lib/load/update-required-fields.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const sdk_1 = require("@directus/sdk");
+const core_1 = require("@oclif/core");
+const constants_1 = require("../constants");
+const sdk_2 = require("../sdk");
+const catch_error_1 = tslib_1.__importDefault(require("../utils/catch-error"));
+const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
+async function updateRequiredFields(dir) {
+    const fieldsToUpdate = (0, read_file_1.default)('fields', dir)
+        .filter(field => { var _a, _b; return field.meta.required === true || ((_a = field.schema) === null || _a === void 0 ? void 0 : _a.is_nullable) === false || ((_b = field.schema) === null || _b === void 0 ? void 0 : _b.is_unique) === true; });
+    core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Updating ${fieldsToUpdate.length} fields to required`));
+    for await (const field of fieldsToUpdate) {
+        try {
+            await sdk_2.api.client.request((0, sdk_1.updateField)(field.collection, field.field, { meta: { ...field.meta }, schema: { ...field.schema } }));
+        }
+        catch (error) {
+            (0, catch_error_1.default)(error);
+        }
+    }
+    core_1.ux.action.stop();
+}
+exports.default = updateRequiredFields;

package/dist/lib/sdk.d.ts

@@ -1,13 +1,31 @@
 import type { AuthenticationClient, RestClient } from '@directus/sdk';
 export interface Schema {
-    any: any;
+}
+export declare class DirectusError extends Error {
+    errors: Array<{
+        extensions?: Record<string, unknown>;
+        message: string;
+    }>;
+    headers: Headers;
+    message: string;
+    response: Response;
+    status: number;
+    constructor(response: Response);
+    formatError(): string;
+    parseErrors(): Promise<void>;
 }
 declare class Api {
     client: (RestClient<Schema> & AuthenticationClient<Schema>) | undefined;
+    private authData;
     private limiter;
     constructor();
+    getToken(): null | string;
     initialize(url: string): void;
-    setAuthToken(token: string): void;
+    login(email: string, password: string): Promise<void>;
+    loginWithToken(token: string): Promise<void>;
+    logout(): Promise<void>;
+    refreshToken(): Promise<void>;
+    private enhancedFetch;
 }
 declare const api: Api;
 export { api };

package/dist/lib/sdk.js

@@ -1,32 +1,147 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.api = void 0;
+exports.api = exports.DirectusError = void 0;
 const tslib_1 = require("tslib");
 const sdk_1 = require("@directus/sdk");
+const core_1 = require("@oclif/core");
 const bottleneck_1 = tslib_1.__importDefault(require("bottleneck"));
+class DirectusError extends Error {
+    constructor(response) {
+        super(response.statusText);
+        this.name = 'DirectusError';
+        this.headers = response.headers;
+        this.status = response.status;
+        this.response = response;
+        this.errors = [];
+        this.message = response.statusText;
+    }
+    formatError() {
+        if (this.errors.length === 0) {
+            return `Directus Error: ${this.message} (Status: ${this.status})`;
+        }
+        const { extensions, message } = this.errors[0];
+        let formattedError = `Directus Error: ${message.trim()} (Status: ${this.status})`;
+        if (extensions) {
+            formattedError += ` ${JSON.stringify(extensions)}`;
+        }
+        return formattedError;
+    }
+    async parseErrors() {
+        try {
+            const data = await this.response.json();
+            if (data && Array.isArray(data.errors)) {
+                this.errors = data.errors;
+                this.message = this.formatError();
+            }
+        }
+        catch {
+            // If parsing fails, keep the errors array empty
+        }
+    }
+}
+exports.DirectusError = DirectusError;
 class Api {
     constructor() {
+        this.authData = null;
         this.limiter = new bottleneck_1.default({
-            maxConcurrent: 10, // Max 10 concurrent requests
-            minTime: 100, // 100ms between requests
-            retryCount: 3, // Retry failed requests up to 3 times
-            retryDelay: 3000, // Wait 3 seconds between retries
+            maxConcurrent: 10,
+            minTime: 100, // Ensure at least 100ms between requests
+            reservoir: 50, // Reservoir to handle the default rate limiter of 50 requests per second
+            reservoirRefreshAmount: 50,
+            reservoirRefreshInterval: 1000, // Refill 50 requests every 1 second
+            retryCount: 3, // Retry a maximum of 3 times
+        });
+        this.limiter.on('failed', async (error, jobInfo) => {
+            var _a;
+            if (error instanceof DirectusError) {
+                const retryAfter = (_a = error.headers) === null || _a === void 0 ? void 0 : _a.get('Retry-After');
+                const statusCode = error.status;
+                if (statusCode === 429) {
+                    const delay = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : 60000;
+                    core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Rate limited. Retrying after ${delay}ms`);
+                    return delay;
+                }
+                if (statusCode === 503) {
+                    const delay = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : 5000;
+                    core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Server under pressure. Retrying after ${delay}ms`);
+                    return delay;
+                }
+                // If the status code is 400 or 401, we don't want to retry
+                if (statusCode === 400 || statusCode === 401) {
+                    return;
+                }
+            }
+            // For other errors, use exponential backoff, but only if we haven't exceeded retryCount
+            if (jobInfo.retryCount < 3) {
+                const delay = Math.min(1000 * 2 ** jobInfo.retryCount, 30000);
+                core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Request failed. Retrying after ${delay}ms`);
+                return delay;
+            }
+            core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Max retries reached, not retrying further`);
+        });
+        this.limiter.on('retry', (error, jobInfo) => {
+            core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Retrying job (attempt ${jobInfo.retryCount + 1})`);
+        });
+        this.limiter.on('depleted', empty => {
+            if (empty) {
+                core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Rate limit quota depleted. Requests will be queued.`);
+            }
         });
     }
+    getToken() {
+        var _a, _b;
+        return (_b = (_a = this.authData) === null || _a === void 0 ? void 0 : _a.access_token) !== null && _b !== void 0 ? _b : null;
+    }
     initialize(url) {
         this.client = (0, sdk_1.createDirectus)(url, {
             globals: {
-                fetch: (...args) => this.limiter.schedule(() => fetch(...args)),
+                fetch: this.limiter.wrap(this.enhancedFetch),
             },
         })
             .with((0, sdk_1.rest)())
-            .with((0, sdk_1.authentication)());
+            .with((0, sdk_1.authentication)('json', {
+            autoRefresh: true,
+            storage: {
+                get: () => this.authData,
+                set: data => {
+                    this.authData = data;
+                },
+            },
+        }));
     }
-    setAuthToken(token) {
+    async login(email, password) {
         if (!this.client) {
             throw new Error('API client is not initialized. Call initialize() first.');
         }
-        this.client.setToken(token);
+        await this.client.login(email, password);
+    }
+    async loginWithToken(token) {
+        if (!this.client) {
+            throw new Error('API client is not initialized. Call initialize() first.');
+        }
+        await this.client.setToken(token);
+    }
+    async logout() {
+        if (!this.client) {
+            throw new Error('API client is not initialized. Call initialize() first.');
+        }
+        await this.client.logout();
+        this.authData = null;
+    }
+    async refreshToken() {
+        if (!this.client) {
+            throw new Error('API client is not initialized. Call initialize() first.');
+        }
+        await this.client.refresh();
+    }
+    async enhancedFetch(...args) {
+        const response = await fetch(...args);
+        if (!response.ok) {
+            const error = new DirectusError(response);
+            await error.parseErrors();
+            throw error;
+        }
+        return response;
     }
 }
 const api = new Api();

package/dist/lib/utils/auth.d.ts

@@ -1,2 +1,28 @@
+interface AuthFlags {
+    directusToken?: string;
+    directusUrl: string;
+    userEmail?: string;
+    userPassword?: string;
+}
+/**
+ * Get the Directus URL from the user
+ * @returns The Directus URL
+ */
 export declare function getDirectusUrl(): Promise<string>;
+/**
+ * Get the Directus token from the user
+ * @param directusUrl - The Directus URL
+ * @returns The Directus token
+ */
 export declare function getDirectusToken(directusUrl: string): Promise<string>;
+/**
+   * Initialize the Directus API with the provided flags
+   * @param flags - The validated ApplyFlags
+   */
+export declare function initializeDirectusApi(flags: AuthFlags): Promise<void>;
+/**
+ * Validate the authentication flags
+ * @param flags - The AuthFlags
+ */
+export declare function validateAuthFlags(flags: AuthFlags): void;
+export {};