@strapi/admin 4.14.3 → 4.14.5

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

@@ -1,42 +0,0 @@
-/**
- * hashes a password
- * @param {string} password - password to hash
- * @returns {string} hashed password
- */
-declare const hashPassword: (password: string) => Promise<string>;
-/**
- * Validate a password
- * @param {string} password
- * @param {string} hash
- * @returns {Promise<boolean>} is the password valid
- */
-declare const validatePassword: (password: string, hash: string) => Promise<boolean>;
-/**
- * Check login credentials
- * @param {Object} options
- * @param {string} options.email
- * @param {string} options.password
- */
-declare const checkCredentials: ({ email, password }: {
-    email: string;
-    password: string;
-}) => Promise<any[]>;
-/**
- * Send an email to the user if it exists or do nothing
- * @param {Object} param params
- * @param {string} param.email user email for which to reset the password
- */
-declare const forgotPassword: ({ email }?: {
-    email: string;
-}) => Promise<any>;
-/**
- * Reset a user password
- * @param {Object} param params
- * @param {string} param.resetPasswordToken token generated to request a password reset
- * @param {string} param.password new user password
- */
-declare const resetPassword: ({ resetPasswordToken, password }?: {
-    resetPasswordToken: string;
-    password: string;
-}) => Promise<any>;
-export { checkCredentials, validatePassword, hashPassword, forgotPassword, resetPassword };

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

@@ -1,2 +0,0 @@
-declare const isValidCondition: (condition: any) => boolean;
-export { isValidCondition };

package/dist/server/admin/server/src/services/content-type.d.ts

@@ -1,51 +0,0 @@
-/**
- * Creates an array of paths to the fields and nested fields, without path nodes
- * @param {string} model model used to get the nested fields
- * @param {Object} options
- * @param {string} options.prefix prefix to add to the path
- * @param {number} options.nestingLevel level of nesting to achieve
- * @param {object} options.components components where components attributes can be found
- * @param {object} options.requiredOnly only returns required nestedFields
- * @param {object} options.existingFields fields that are already selected, meaning that some sub-fields may be required
- * @returns {array<string>}
- * @param model
- */
-declare const getNestedFields: (model: any, { prefix, nestingLevel, components, requiredOnly, existingFields }: {
-    prefix?: string | undefined;
-    nestingLevel?: number | undefined;
-    components?: {} | undefined;
-    requiredOnly?: boolean | undefined;
-    existingFields?: never[] | undefined;
-}) => any;
-/**
- * Creates an array of paths to the fields and nested fields, with path nodes
- * @param {string} model model used to get the nested fields
- * @param {Object} options
- * @param {string} options.prefix prefix to add to the path
- * @param {number} options.nestingLevel level of nesting to achieve
- * @param {object} options.components components where components attributes can be found
- * @returns {array<string>}
- */
-declare const getNestedFieldsWithIntermediate: (model: any, { prefix, nestingLevel, components }: {
-    prefix?: string | undefined;
-    nestingLevel?: number | undefined;
-    components?: {} | undefined;
-}) => any;
-/**
- * Creates an array of permissions with the "properties.fields" attribute filled
- * @param {array} actions array of actions
- * @param {object} options
- * @param {number} options.nestingLevel level of nesting
- * @param {array} options.restrictedSubjects subjectsId to ignore
- * @returns {Permission[]}
- */
-declare const getPermissionsWithNestedFields: (actions: any[], { nestingLevel, restrictedSubjects }?: any) => any;
-/**
- * Cleans permissions' fields (add required ones, remove the non-existing ones)
- * @param {Permission[]} permissions array of existing permissions in db
- * @param {object} options
- * @param {number} options.nestingLevel level of nesting
- * @returns {Permission[]}
- */
-declare const cleanPermissionFields: (permissions: any, { nestingLevel }?: any) => any;
-export { getNestedFields, getPermissionsWithNestedFields, cleanPermissionFields, getNestedFieldsWithIntermediate, };

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

@@ -1,61 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,15 +0,0 @@
-/// <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

@@ -1,44 +0,0 @@
-/**
- * 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

@@ -1,67 +0,0 @@
-/// <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

@@ -1,116 +0,0 @@
-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

@@ -1,103 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,96 +0,0 @@
-/**
- * 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

@@ -1,25 +0,0 @@
-/** @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;