@strapi/admin 4.14.2 → 4.14.3

package/dist/server/admin/server/src/services/index.d.ts

@@ -0,0 +1,61 @@
+import * as user from './user';
+import * as token from './token';
+import * as role from './role';
+import * as permission from './permission';
+import * as passport from './passport';
+import * as metrics from './metrics';
+import * as contentType from './content-type';
+import * as condition from './condition';
+import * as auth from './auth';
+import * as action from './action';
+import * as apiToken from './api-token';
+import * as transfer from './transfer';
+import * as projectSettings from './project-settings';
+declare const _default: {
+    user: typeof user;
+    token: typeof token;
+    role: typeof role;
+    permission: typeof permission;
+    passport: typeof passport;
+    metrics: typeof metrics;
+    'content-type': typeof contentType;
+    constants: {
+        CONTENT_TYPE_SECTION: string;
+        SUPER_ADMIN_CODE: string;
+        EDITOR_CODE: string;
+        AUTHOR_CODE: string;
+        READ_ACTION: string;
+        CREATE_ACTION: string;
+        UPDATE_ACTION: string;
+        DELETE_ACTION: string;
+        PUBLISH_ACTION: string;
+        API_TOKEN_TYPE: {
+            READ_ONLY: string;
+            FULL_ACCESS: string;
+            CUSTOM: string;
+        };
+        API_TOKEN_LIFESPANS: {
+            UNLIMITED: null;
+            DAYS_7: number;
+            DAYS_30: number;
+            DAYS_90: number;
+        };
+        TRANSFER_TOKEN_TYPE: {
+            PUSH: string;
+            PULL: string;
+        };
+        TRANSFER_TOKEN_LIFESPANS: {
+            UNLIMITED: null;
+            DAYS_7: number;
+            DAYS_30: number;
+            DAYS_90: number;
+        };
+    };
+    condition: typeof condition;
+    auth: typeof auth;
+    action: typeof action;
+    'api-token': typeof apiToken;
+    transfer: typeof transfer;
+    'project-settings': typeof projectSettings;
+};
+export default _default;

package/dist/server/admin/server/src/services/metrics.d.ts

@@ -0,0 +1,7 @@
+import type { Strapi } from '@strapi/types';
+declare const sendDidInviteUser: () => Promise<void>;
+declare const sendDidUpdateRolePermissions: () => Promise<void>;
+declare const sendDidChangeInterfaceLanguage: () => Promise<void>;
+declare const sendUpdateProjectInformation: () => Promise<void>;
+declare const startCron: (strapi: Strapi) => void;
+export { sendDidInviteUser, sendDidUpdateRolePermissions, sendDidChangeInterfaceLanguage, sendUpdateProjectInformation, startCron, };

package/dist/server/admin/server/src/services/permission/engine.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="lodash" />
+declare const _default: (params: any) => {
+    readonly hooks: import("@strapi/permissions/dist/engine/hooks").PermissionEngineHooks;
+    /**
+     * Generate an ability based on the given user (using associated roles & permissions)
+     * @param user
+     * @returns {Promise<Ability>}
+     */
+    generateUserAbility(user: any): Promise<import("@casl/ability").Ability<import("@casl/ability").AbilityTuple, any>>;
+    /**
+     * Check many permissions based on an ability
+     */
+    checkMany: import("lodash").CurriedFunction2<any, any, any>;
+};
+export default _default;

package/dist/server/admin/server/src/services/permission/queries.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Delete permissions of roles in database
+ * @param rolesIds ids of roles
+ * @returns {Promise<array>}
+ */
+export declare const deleteByRolesIds: (rolesIds: string[]) => Promise<void>;
+/**
+ * Delete permissions
+ * @param ids ids of permissions
+ * @returns {Promise<array>}
+ */
+export declare const deleteByIds: (ids: string[]) => Promise<void>;
+/**
+ * Create many permissions
+ * @param permissions
+ * @returns {Promise<*[]|*>}
+ */
+export declare const createMany: (permissions: any) => Promise<import("../../domain/permission/index").Permission>;
+/**
+ * Find assigned permissions in the database
+ * @param params query params to find the permissions
+ * @returns {Promise<Permission[]>}
+ */
+export declare const findMany: (params?: {}) => Promise<import("../../domain/permission/index").Permission>;
+/**
+ * Find all permissions for a user
+ * @param user - user
+ * @returns {Promise<Permission[]>}
+ */
+export declare const findUserPermissions: (user: any) => Promise<import("../../domain/permission/index").Permission>;
+/**
+ * Removes permissions in database that don't exist anymore
+ * @returns {Promise<>}
+ */
+export declare const cleanPermissionsInDatabase: () => Promise<void>;
+declare const _default: {
+    createMany: (permissions: any) => Promise<import("../../domain/permission/index").Permission>;
+    findMany: (params?: {}) => Promise<import("../../domain/permission/index").Permission>;
+    deleteByRolesIds: (rolesIds: string[]) => Promise<void>;
+    deleteByIds: (ids: string[]) => Promise<void>;
+    findUserPermissions: (user: any) => Promise<import("../../domain/permission/index").Permission>;
+    cleanPermissionsInDatabase: () => Promise<void>;
+};
+export default _default;

package/dist/server/admin/server/src/services/permission.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="lodash" />
+import createPermissionsManager from './permission/permissions-manager';
+import { cleanPermissionsInDatabase, createMany, deleteByIds, deleteByRolesIds, findMany, findUserPermissions } from './permission/queries';
+declare const actionProvider: {
+    hooks: {
+        appliesPropertyToSubject: {
+            call(context: unknown): Promise<any[]>;
+            getHandlers(): import("@strapi/utils/dist/hooks").Handler[];
+            register(handler: import("@strapi/utils/dist/hooks").Handler): import("@strapi/utils/dist/hooks").Hook<import("@strapi/utils/dist/hooks").Handler>;
+            delete(handler: import("@strapi/utils/dist/hooks").Handler): import("@strapi/utils/dist/hooks").Hook<import("@strapi/utils/dist/hooks").Handler>;
+        };
+        willRegister: import("@strapi/utils/dist/hooks").AsyncSeriesHook;
+        didRegister: import("@strapi/utils/dist/hooks").AsyncParallelHook;
+        willDelete: import("@strapi/utils/dist/hooks").AsyncParallelHook;
+        didDelete: import("@strapi/utils/dist/hooks").AsyncParallelHook;
+    };
+    register(actionAttributes: import("../domain/action").CreateActionPayload): Promise<import("@strapi/utils/dist/provider-factory").Provider>;
+    registerMany(actionsAttributes: import("../domain/action").CreateActionPayload[]): Promise<any>;
+    appliesToProperty(property: string, actionId: string, subject: string): Promise<boolean>;
+    delete(key: string): Promise<import("@strapi/utils/dist/provider-factory").Provider>;
+    get(key: string): {
+        [x: string]: unknown;
+    } | undefined;
+    getWhere(filters?: Record<string, unknown> | undefined): {
+        [x: string]: unknown;
+    }[];
+    values(): {
+        [x: string]: unknown;
+    }[];
+    keys(): string[];
+    has(key: string): boolean;
+    size(): number;
+    clear(): Promise<import("@strapi/utils/dist/provider-factory").Provider>;
+};
+declare const conditionProvider: {
+    register(conditionAttributes: import("../domain/condition").CreateConditionPayload): Promise<import("@strapi/utils/dist/provider-factory").Provider>;
+    registerMany(conditionsAttributes: import("../domain/condition").CreateConditionPayload[]): Promise<any>;
+    hooks: import("@strapi/utils/dist/provider-factory").ProviderHooksMap;
+    delete(key: string): Promise<import("@strapi/utils/dist/provider-factory").Provider>;
+    get(key: string): {
+        [x: string]: unknown;
+    } | undefined;
+    getWhere(filters?: Record<string, unknown> | undefined): {
+        [x: string]: unknown;
+    }[];
+    values(): {
+        [x: string]: unknown;
+    }[];
+    keys(): string[];
+    has(key: string): boolean;
+    size(): number;
+    clear(): Promise<import("@strapi/utils/dist/provider-factory").Provider>;
+};
+declare const sectionsBuilder: {
+    createSection(sectionName: string, options: any): any;
+    deleteSection(sectionName: string): any;
+    addHandler(sectionName: string, handler: () => unknown): any;
+    addMatcher(sectionName: string, matcher: () => unknown): any;
+    build(actions?: any): Promise<any>;
+};
+declare const sanitizePermission: import("lodash/fp").LodashPick2x1;
+declare const engine: {
+    readonly hooks: import("@strapi/permissions/dist/engine/hooks").PermissionEngineHooks;
+    generateUserAbility(user: any): Promise<import("@casl/ability").Ability<import("@casl/ability").AbilityTuple, any>>;
+    checkMany: import("lodash").CurriedFunction2<any, any, any>;
+};
+export { cleanPermissionsInDatabase, createMany, deleteByIds, deleteByRolesIds, findMany, findUserPermissions, createPermissionsManager, sectionsBuilder, sanitizePermission, engine, actionProvider, conditionProvider, };

package/dist/server/admin/server/src/services/role.d.ts

@@ -0,0 +1,116 @@
+declare const hooks: {
+    willResetSuperAdminPermissions: {
+        call(param: unknown): Promise<unknown>;
+        getHandlers(): import("@strapi/utils/dist/hooks").Handler[];
+        register(handler: import("@strapi/utils/dist/hooks").Handler): import("@strapi/utils/dist/hooks").Hook<import("@strapi/utils/dist/hooks").Handler>;
+        delete(handler: import("@strapi/utils/dist/hooks").Handler): import("@strapi/utils/dist/hooks").Hook<import("@strapi/utils/dist/hooks").Handler>;
+    };
+};
+declare const sanitizeRole: import("lodash/fp").LodashOmit2x1;
+/**
+ * Create and save a role in database
+ * @param attributes A partial role object
+ * @returns {Promise<role>}
+ */
+declare const create: (attributes: any) => Promise<any>;
+/**
+ * Find a role in database
+ * @param params query params to find the role
+ * @param populate
+ * @returns {Promise<role>}
+ */
+declare const findOne: (params?: any, populate?: any) => Promise<any>;
+/**
+ * Find a role in database with usersCounts
+ * @param params query params to find the role
+ * @param populate
+ * @returns {Promise<role>}
+ */
+declare const findOneWithUsersCount: (params?: {}, populate?: any) => Promise<any>;
+/**
+ * Find roles in database
+ * @param params query params to find the roles
+ * @param populate
+ * @returns {Promise<array>}
+ */
+declare const find: (params: {} | undefined, populate: any) => Promise<any[]>;
+/**
+ * Find all roles in database
+ * @returns {Promise<array>}
+ */
+declare const findAllWithUsersCount: (params: any) => Promise<any>;
+/**
+ * Update a role in database
+ * @param params query params to find the role to update
+ * @param attributes A partial role object
+ * @returns {Promise<role>}
+ */
+declare const update: (params: any, attributes: any) => Promise<any>;
+/**
+ * Check if a role exists in database
+ * @param params query params to find the role
+ * @returns {Promise<boolean>}
+ */
+declare const exists: (params?: {}) => Promise<boolean>;
+/**
+ * Count the number of roles based on search params
+ * @param params params used for the query
+ * @returns {Promise<number>}
+ */
+declare const count: (params?: {}) => Promise<number>;
+/**
+ * Check if the given roles id can be deleted safely, throw otherwise
+ * @param ids
+ * @returns {Promise<void>}
+ */
+declare const checkRolesIdForDeletion: (ids?: any[]) => Promise<void>;
+/**
+ * Delete roles in database if they have no user assigned
+ * @param ids query params to find the roles
+ * @returns {Promise<array>}
+ */
+declare const deleteByIds: (ids?: any[]) => Promise<any[]>;
+/** Count the number of users for some roles
+ * @returns {Promise<number>}
+ * @param roleId
+ */
+declare const getUsersCount: (roleId: string) => Promise<number>;
+/** Returns admin role
+ * @returns {Promise<role>}
+ */
+declare const getSuperAdmin: () => Promise<any>;
+/** Returns admin role with userCount
+ * @returns {Promise<role>}
+ */
+declare const getSuperAdminWithUsersCount: () => Promise<any>;
+/** Create superAdmin, Author and Editor role is no role already exist
+ * @returns {Promise<>}
+ */
+declare const createRolesIfNoneExist: () => Promise<void>;
+/** Display a warning if the role superAdmin doesn't exist
+ *  or if the role is not assigned to at least one user
+ * @returns {Promise<>}
+ */
+declare const displayWarningIfNoSuperAdmin: () => Promise<void>;
+/**
+ * Assign permissions to a role
+ * @param {string|int} roleId - role ID
+ * @param {Array<Permission{action,subject,fields,conditions}>} permissions - permissions to assign to the role
+ */
+declare const assignPermissions: (roleId: string, permissions?: never[]) => Promise<any>;
+declare const addPermissions: (roleId: string, permissions: any) => Promise<import("../domain/permission").Permission>;
+/**
+ * Reset super admin permissions (giving it all permissions)
+ * @returns {Promise<>}
+ */
+declare const resetSuperAdminPermissions: () => Promise<void>;
+/**
+ * Check if a user object includes the super admin role
+ * @param {object} user
+ * @return {boolean}
+ */
+declare const hasSuperAdminRole: (user: any) => any;
+declare const constants: {
+    superAdminCode: string;
+};
+export { hooks, sanitizeRole, create, findOne, findOneWithUsersCount, find, findAllWithUsersCount, update, exists, count, deleteByIds, getUsersCount, getSuperAdmin, getSuperAdminWithUsersCount, createRolesIfNoneExist, displayWarningIfNoSuperAdmin, addPermissions, hasSuperAdminRole, assignPermissions, resetSuperAdminPermissions, checkRolesIdForDeletion, constants, };

package/dist/server/admin/server/src/services/transfer/token.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Return a list of all tokens and their permissions
+ *
+ * @returns {Promise<Omit<TransferToken, 'accessKey'>[]>}
+ */
+declare const list: () => Promise<any[]>;
+/**
+ * Create a token and its permissions
+ *
+ * @param {Object} attributes
+ * @param {string} attributes.name
+ * @param {string} attributes.description
+ * @param {number} attributes.lifespan
+ * @param {string[]} attributes.permissions
+ * @param {string} [attributes.accessKey]
+ *
+ * @returns {Promise<TransferToken>}
+ */
+declare const create: (attributes: any) => Promise<any>;
+/**
+ * Update a token and its permissions
+ *
+ * @param {string|number} id
+ * @param {Object} attributes
+ * @param {string} attributes.name
+ * @param {number} attributes.lastUsedAt
+ * @param {string[]} attributes.permissions
+ * @param {string} attributes.description
+ *
+ * @returns {Promise<Omit<TransferToken, 'accessKey'>>}
+ */
+declare const update: (id: any, attributes: any) => Promise<unknown>;
+/**
+ * Revoke (delete) a token
+ *
+ * @param {string|number} id
+ *
+ * @returns {Promise<Omit<TransferToken, 'accessKey'>>}
+ */
+declare const revoke: (id: any) => Promise<unknown>;
+/**
+ *  Get a token
+ *
+ * @param {Object} whereParams
+ * @param {string|number} whereParams.id
+ * @param {string} whereParams.name
+ * @param {number} whereParams.lastUsedAt
+ * @param {string} whereParams.description
+ * @param {string} whereParams.accessKey
+ *
+ * @returns {Promise<Omit<TransferToken, 'accessKey'> | null>}
+ */
+declare const getBy: (whereParams?: {}) => Promise<any>;
+/**
+ * Retrieve a token by id
+ *
+ * @param {string|number} id
+ *
+ * @returns {Promise<Omit<TransferToken, 'accessKey'>>}
+ */
+declare const getById: (id: any) => Promise<any>;
+/**
+ * Retrieve a token by name
+ *
+ * @param {string} name
+ *
+ * ^@returns {Promise<Omit<TransferToken, 'accessKey'>>}
+ */
+declare const getByName: (name: string) => Promise<any>;
+/**
+ * Check if token exists
+ *
+ * @param {Object} whereParams
+ * @param {string|number} whereParams.id
+ * @param {string} whereParams.name
+ * @param {number} whereParams.lastUsedAt
+ * @param {string} whereParams.description
+ * @param {string} whereParams.accessKey
+ *
+ * @returns {Promise<boolean>}
+ */
+declare const exists: (whereParams?: {}) => Promise<boolean>;
+/**
+ * @param {string|number} id
+ *
+ * @returns {Promise<TransferToken>}
+ */
+declare const regenerate: (id: any) => Promise<{
+    accessKey: string;
+}>;
+/**
+ * Return a secure sha512 hash of an accessKey
+ *
+ * @param {string} accessKey
+ *
+ * @returns {string}
+ */
+declare const hash: (accessKey: string) => string;
+/**
+ * @returns {void}
+ */
+declare const checkSaltIsDefined: () => void;
+export { create, list, exists, getBy, getById, getByName, update, revoke, regenerate, hash, checkSaltIsDefined, };

package/dist/server/admin/server/src/services/transfer/utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Returns whether the data transfer features have been disabled from the env configuration
+ *
+ * @returns {boolean}
+ */
+declare const isDisabledFromEnv: () => boolean | undefined;
+/**
+ * A valid transfer token salt must be a non-empty string defined in the Strapi config
+ *
+ * @returns {boolean}
+ */
+declare const hasValidTokenSalt: () => boolean;
+/**
+ * Checks whether data transfer features are enabled
+ *
+ * @returns {boolean}
+ */
+declare const isDataTransferEnabled: () => any;
+export { isDataTransferEnabled, isDisabledFromEnv, hasValidTokenSalt };

package/dist/server/admin/server/src/services/user.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Remove private user fields
+ * @param {Object} user - user to sanitize
+ */
+declare const sanitizeUser: (user: any) => {
+    roles: any;
+};
+/**
+ * Create and save a user in database
+ * @param attributes A partial user object
+ * @returns {Promise<user>}
+ */
+declare const create: (attributes: any) => Promise<any>;
+/**
+ * Update a user in database
+ * @param id query params to find the user to update
+ * @param attributes A partial user object
+ * @returns {Promise<user>}
+ */
+declare const updateById: (id: any, attributes: any) => Promise<any>;
+/**
+ * Reset a user password by email. (Used in admin:reset CLI)
+ * @param {string} email - user email
+ * @param {string} password - new password
+ */
+declare const resetPasswordByEmail: (email: string, password: string) => Promise<void>;
+/**
+ * Check if a user with specific attributes exists in the database
+ * @param attributes A partial user object
+ * @returns {Promise<boolean>}
+ */
+declare const exists: (attributes?: {}) => Promise<boolean>;
+/**
+ * Returns a user registration info
+ * @param {string} registrationToken - a user registration token
+ * @returns {Promise<registrationInfo>} - Returns user email, firstname and lastname
+ */
+declare const findRegistrationInfo: (registrationToken: string) => Promise<Pick<any, "email" | "firstname" | "lastname"> | undefined>;
+/**
+ * Registers a user based on a registrationToken and some informations to update
+ * @param {Object} params
+ * @param {Object} params.registrationToken registration token
+ * @param {Object} params.userInfo user info
+ */
+declare const register: ({ registrationToken, userInfo }: any) => Promise<any>;
+/**
+ * Find one user
+ */
+declare const findOne: (id: any, populate?: string[]) => Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"admin::user", string> | null>;
+/**
+ * Find one user by its email
+ * @param {string} id  email
+ * @param {string || string[] || object} populate
+ * @returns
+ */
+declare const findOneByEmail: (email: string, populate?: never[]) => Promise<any>;
+/** Find many users (paginated)
+ * @param query
+ * @returns {Promise<user>}
+ */
+declare const findPage: (query?: {}) => Promise<import("@strapi/types/dist/modules/entity-service").PaginatedResult<"admin::user", {
+    populate: string[];
+}>>;
+/** Delete a user
+ * @param id id of the user to delete
+ * @returns {Promise<user>}
+ */
+declare const deleteById: (id: any) => Promise<any>;
+/** Delete a user
+ * @param ids ids of the users to delete
+ * @returns {Promise<user>}
+ */
+declare const deleteByIds: (ids: any[]) => Promise<any[]>;
+/** Count the users that don't have any associated roles
+ * @returns {Promise<number>}
+ */
+declare const countUsersWithoutRole: () => Promise<number>;
+/**
+ * Count the number of users based on search params
+ * @param params params used for the query
+ * @returns {Promise<number>}
+ */
+declare const count: (where?: {}) => Promise<number>;
+/** Assign some roles to several users
+ * @returns {undefined}
+ */
+declare const assignARoleToAll: (roleId: any) => Promise<void>;
+/** Display a warning if some users don't have at least one role
+ * @returns {Promise<>}
+ */
+declare const displayWarningIfUsersDontHaveRole: () => Promise<void>;
+/** Returns an array of interface languages currently used by users
+ * @returns {Promise<Array<string>>}
+ */
+declare const getLanguagesInUse: () => Promise<any[]>;
+export { create, updateById, exists, findRegistrationInfo, register, sanitizeUser, findOne, findOneByEmail, findPage, deleteById, deleteByIds, countUsersWithoutRole, count, assignARoleToAll, displayWarningIfUsersDontHaveRole, resetPasswordByEmail, getLanguagesInUse, };

package/dist/server/admin/server/src/strategies/admin.d.ts

@@ -0,0 +1,25 @@
+/** @type {import('.').AuthenticateFunction} */
+export declare const authenticate: (ctx: any) => Promise<{
+    authenticated: boolean;
+    credentials?: undefined;
+    ability?: undefined;
+} | {
+    authenticated: boolean;
+    credentials: any;
+    ability: import("@casl/ability").Ability<import("@casl/ability").AbilityTuple, any>;
+}>;
+export declare const name = "admin";
+/** @type {import('.').AuthStrategy} */
+declare const _default: {
+    name: string;
+    authenticate: (ctx: any) => Promise<{
+        authenticated: boolean;
+        credentials?: undefined;
+        ability?: undefined;
+    } | {
+        authenticated: boolean;
+        credentials: any;
+        ability: import("@casl/ability").Ability<import("@casl/ability").AbilityTuple, any>;
+    }>;
+};
+export default _default;

package/dist/server/admin/server/src/strategies/api-token.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Authenticate the validity of the token
+ *
+ *  @type {import('.').AuthenticateFunction}
+ */
+export declare const authenticate: (ctx: any) => Promise<{
+    authenticated: boolean;
+    error?: undefined;
+    ability?: undefined;
+    credentials?: undefined;
+} | {
+    authenticated: boolean;
+    error: import("@strapi/utils/dist/errors").UnauthorizedError;
+    ability?: undefined;
+    credentials?: undefined;
+} | {
+    authenticated: boolean;
+    ability: import("@casl/ability").Ability<import("@casl/ability").AbilityTuple, any>;
+    credentials: any;
+    error?: undefined;
+} | {
+    authenticated: boolean;
+    credentials: any;
+    error?: undefined;
+    ability?: undefined;
+}>;
+/**
+ * Verify the token has the required abilities for the requested scope
+ *
+ *  @type {import('.').VerifyFunction}
+ */
+export declare const verify: (auth: any, config: any) => void;
+export declare const name = "api-token";
+/** @type {import('.').AuthStrategy} */
+declare const _default: {
+    name: string;
+    authenticate: (ctx: any) => Promise<{
+        authenticated: boolean;
+        error?: undefined;
+        ability?: undefined;
+        credentials?: undefined;
+    } | {
+        authenticated: boolean;
+        error: import("@strapi/utils/dist/errors").UnauthorizedError;
+        ability?: undefined;
+        credentials?: undefined;
+    } | {
+        authenticated: boolean;
+        ability: import("@casl/ability").Ability<import("@casl/ability").AbilityTuple, any>;
+        credentials: any;
+        error?: undefined;
+    } | {
+        authenticated: boolean;
+        credentials: any;
+        error?: undefined;
+        ability?: undefined;
+    }>;
+    verify: (auth: any, config: any) => void;
+};
+export default _default;

package/dist/server/admin/server/src/strategies/data-transfer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Authenticate the validity of the token
+ *
+ *  @type {import('.').AuthenticateFunction}
+ */
+export declare const authenticate: (ctx: any) => Promise<{
+    authenticated: boolean;
+    error?: undefined;
+    ability?: undefined;
+    credentials?: undefined;
+} | {
+    authenticated: boolean;
+    error: import("@strapi/utils/dist/errors").UnauthorizedError;
+    ability?: undefined;
+    credentials?: undefined;
+} | {
+    authenticated: boolean;
+    ability: import("@casl/ability").Ability<import("@casl/ability").AbilityTuple, any>;
+    credentials: any;
+    error?: undefined;
+}>;
+/**
+ * Verify the token has the required abilities for the requested scope
+ *
+ *  @type {import('.').VerifyFunction}
+ */
+export declare const verify: (auth: any, config?: {}) => Promise<void>;
+export declare const name = "data-transfer";
+/** @type {import('.').AuthStrategy} */
+declare const _default: {
+    name: string;
+    authenticate: (ctx: any) => Promise<{
+        authenticated: boolean;
+        error?: undefined;
+        ability?: undefined;
+        credentials?: undefined;
+    } | {
+        authenticated: boolean;
+        error: import("@strapi/utils/dist/errors").UnauthorizedError;
+        ability?: undefined;
+        credentials?: undefined;
+    } | {
+        authenticated: boolean;
+        ability: import("@casl/ability").Ability<import("@casl/ability").AbilityTuple, any>;
+        credentials: any;
+        error?: undefined;
+    }>;
+    verify: (auth: any, config?: {}) => Promise<void>;
+};
+export default _default;