@strapi/admin 4.18.1-beta.0 → 4.18.1-experimental.0

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

@@ -0,0 +1,111 @@
+/// <reference types="koa" />
+import * as token from './token';
+import * as permission from './permission';
+import * as metrics from './metrics';
+import * as contentType from './content-type';
+import * as constants from './constants';
+import * as condition from './condition';
+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: {
+    auth: {
+        checkCredentials: ({ email, password }: {
+            email: string;
+            password: string;
+        }) => Promise<(import("../../../shared/contracts/shared").AdminUser | null)[] | (boolean | {
+            message: string;
+        } | null)[]>;
+        validatePassword: (password: string, hash: string) => Promise<boolean>;
+        hashPassword: (password: string) => Promise<string>;
+        forgotPassword: ({ email }?: {
+            email: string;
+        }) => Promise<any>;
+        resetPassword: ({ resetPasswordToken, password }?: {
+            resetPasswordToken: string;
+            password: string;
+        }) => Promise<import("../../../shared/contracts/shared").AdminUser>;
+    };
+    user: {
+        create: (attributes: Partial<import("../../../shared/contracts/shared").AdminUserCreationPayload> & {
+            isActive?: true | undefined;
+        }) => Promise<import("../../../shared/contracts/shared").AdminUser>;
+        updateById: (id: import("@strapi/types/dist/types/core/entity").ID, attributes: Partial<import("../../../shared/contracts/shared").AdminUserUpdatePayload>) => Promise<import("../../../shared/contracts/shared").AdminUser>;
+        exists: (attributes?: unknown) => Promise<boolean>;
+        findRegistrationInfo: (registrationToken: string) => Promise<Pick<import("../../../shared/contracts/shared").AdminUser, "firstname" | "lastname" | "email"> | undefined>;
+        register: ({ registrationToken, userInfo, }: {
+            registrationToken: string;
+            userInfo: Partial<import("../../../shared/contracts/shared").AdminUser>;
+        }) => Promise<import("../../../shared/contracts/shared").AdminUser>;
+        sanitizeUser: (user: import("../../../shared/contracts/shared").AdminUser) => import("../../../shared/contracts/shared").SanitizedAdminUser;
+        findOne: (id: import("@strapi/types/dist/types/core/entity").ID, populate?: string[]) => Promise<({
+            id: import("@strapi/types/dist/types/core/entity").ID;
+        } & {
+            [key: string]: any;
+        }) | null>;
+        findOneByEmail: (email: string, populate?: never[]) => Promise<any>;
+        findPage: (query?: {}) => Promise<unknown>;
+        deleteById: (id: import("@strapi/types/dist/types/core/entity").ID) => Promise<import("../../../shared/contracts/shared").AdminUser | null>;
+        deleteByIds: (ids: (string | number)[]) => Promise<import("../../../shared/contracts/shared").AdminUser[]>;
+        countUsersWithoutRole: () => Promise<number>;
+        count: (where?: {}) => Promise<number>;
+        assignARoleToAll: (roleId: import("@strapi/types/dist/types/core/entity").ID) => Promise<void>;
+        displayWarningIfUsersDontHaveRole: () => Promise<void>;
+        resetPasswordByEmail: (email: string, password: string) => Promise<void>;
+        getLanguagesInUse: () => Promise<string[]>;
+    };
+    role: {
+        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>;
+            };
+        };
+        sanitizeRole: <T extends object>(obj: T) => Omit<T, "users" | "permissions">;
+        create: (attributes: Partial<import("../../../shared/contracts/shared").AdminRole>) => Promise<import("../../../shared/contracts/shared").AdminRole>;
+        findOne: (params?: {}, populate?: unknown) => Promise<import("../../../shared/contracts/shared").AdminRole>;
+        findOneWithUsersCount: (params?: {}, populate?: unknown) => Promise<import("./role").AdminRoleWithUsersCount>;
+        find: (params: {} | undefined, populate: unknown) => Promise<import("../../../shared/contracts/shared").AdminRole[]>;
+        findAllWithUsersCount: (params: any) => Promise<import("./role").AdminRoleWithUsersCount[]>;
+        update: (params: any, attributes: Partial<import("../../../shared/contracts/shared").AdminRole>) => Promise<import("../../../shared/contracts/shared").AdminRole>;
+        exists: (params?: unknown) => Promise<boolean>;
+        count: (params?: any) => Promise<number>;
+        deleteByIds: (ids?: import("@strapi/types/dist/types/core/entity").ID[]) => Promise<import("../../../shared/contracts/shared").AdminRole[]>;
+        getUsersCount: (roleId: import("@strapi/types/dist/types/core/entity").ID) => Promise<number>;
+        getSuperAdmin: () => Promise<import("../../../shared/contracts/shared").AdminRole | undefined>;
+        getSuperAdminWithUsersCount: () => Promise<import("./role").AdminRoleWithUsersCount>;
+        createRolesIfNoneExist: () => Promise<void>;
+        displayWarningIfNoSuperAdmin: () => Promise<void>;
+        addPermissions: (roleId: import("@strapi/types/dist/types/core/entity").ID, permissions: any) => Promise<import("../../../shared/contracts/shared").Permission[]>;
+        hasSuperAdminRole: (user: import("../../../shared/contracts/shared").AdminUser) => boolean;
+        assignPermissions: (roleId: import("@strapi/types/dist/types/core/entity").ID, permissions?: Pick<import("../../../shared/contracts/shared").Permission, "action" | "subject" | "conditions">[]) => Promise<import("../../../shared/contracts/shared").Permission[]>;
+        resetSuperAdminPermissions: () => Promise<void>;
+        checkRolesIdForDeletion: (ids?: import("@strapi/types/dist/types/core/entity").ID[]) => Promise<void>;
+        constants: {
+            superAdminCode: string;
+        };
+    };
+    passport: {
+        init: () => import("koa").Middleware;
+        getPassportStrategies: () => import("passport-local").Strategy[];
+        authEventsMapper: {
+            onConnectionSuccess: string;
+            onConnectionError: string;
+        };
+    };
+    token: typeof token;
+    permission: typeof permission;
+    metrics: typeof metrics;
+    'content-type': typeof contentType;
+    constants: typeof constants;
+    condition: typeof condition;
+    action: typeof action;
+    'api-token': typeof apiToken;
+    transfer: typeof transfer;
+    'project-settings': typeof projectSettings;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/services/index.ts"],"names":[],"mappings":";AAKA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,QAAQ,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,eAAe,MAAM,oBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGtD,wBAeE"}

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

@@ -0,0 +1,8 @@
+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, };
+//# sourceMappingURL=metrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../../../server/src/services/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAG5C,QAAA,MAAM,iBAAiB,qBAMtB,CAAC;AAEF,QAAA,MAAM,4BAA4B,qBAEjC,CAAC;AAEF,QAAA,MAAM,8BAA8B,qBAInC,CAAC;AAEF,QAAA,MAAM,4BAA4B,qBAOjC,CAAC;AAEF,QAAA,MAAM,SAAS,WAAY,MAAM,SAIhC,CAAC;AAEF,OAAO,EACL,iBAAiB,EACjB,4BAA4B,EAC5B,8BAA8B,EAC9B,4BAA4B,EAC5B,SAAS,GACV,CAAC"}

package/dist/server/src/services/passport/local-strategy.d.ts

@@ -0,0 +1,5 @@
+import { Strategy as LocalStrategy } from 'passport-local';
+import type { Strapi } from '@strapi/types';
+declare const createLocalStrategy: (strapi: Strapi, middleware?: any) => LocalStrategy;
+export default createLocalStrategy;
+//# sourceMappingURL=local-strategy.d.ts.map

package/dist/server/src/services/passport/local-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-strategy.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/passport/local-strategy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,IAAI,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAG5C,QAAA,MAAM,mBAAmB,WAAY,MAAM,eAAe,GAAG,kBAoB5D,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/server/src/services/passport.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="koa" />
+import type { Strategy } from 'passport-local';
+declare const _default: {
+    init: () => import("koa").Middleware;
+    getPassportStrategies: () => Strategy[];
+    authEventsMapper: {
+        onConnectionSuccess: string;
+        onConnectionError: string;
+    };
+};
+export default _default;
+//# sourceMappingURL=passport.d.ts.map

package/dist/server/src/services/passport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"passport.d.ts","sourceRoot":"","sources":["../../../../server/src/services/passport.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;;;;;;;;;AAwC/C,wBAAiE"}

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

@@ -0,0 +1,20 @@
+/// <reference types="lodash" />
+import { type engine } from '@strapi/permissions';
+import type { Ability } from '@casl/ability';
+import type { AdminUser, Permission } from '../../../../shared/contracts/shared';
+declare const _default: (params: {
+    providers: engine.EngineParams['providers'];
+}) => {
+    readonly hooks: import("@strapi/permissions/dist/engine/hooks").PermissionEngineHooks;
+    /**
+     * Generate an ability based on the given user (using associated roles & permissions)
+     * @param user
+     */
+    generateUserAbility(user: AdminUser): Promise<Ability>;
+    /**
+     * Check many permissions based on an ability
+     */
+    checkMany: import("lodash").CurriedFunction2<Ability<import("@casl/ability").AbilityTuple, any>, Permission[], boolean[]>;
+};
+export default _default;
+//# sourceMappingURL=engine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/permission/engine.ts"],"names":[],"mappings":";AACA,OAAoB,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAI7C,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;iCAEzD;IAAE,SAAS,EAAE,OAAO,YAAY,CAAC,WAAW,CAAC,CAAA;CAAE;;IA4DnE;;;OAGG;8BAC6B,SAAS,GAAG,QAAQ,OAAO,CAAC;IAM5D;;OAEG;;;AAxEP,wBA8EE"}

package/dist/server/src/services/permission/permissions-manager/index.d.ts

@@ -0,0 +1,17 @@
+declare const _default: ({ ability, action, model }: any) => {
+    validateQuery: (data: any, options?: {}) => any;
+    validateInput: (data: any, options?: {}) => any;
+    sanitizeOutput: (data: unknown, options?: any) => any;
+    sanitizeInput: (data: unknown, options?: any) => any;
+    sanitizeQuery: (data: unknown, options?: any) => any;
+    ability: any;
+    action: any;
+    model: any;
+    isAllowed: unknown;
+    toSubject(target: any, subjectType?: any): any;
+    pickPermittedFieldsOf(data: unknown, options?: {}): any;
+    getQuery(queryAction?: any): unknown;
+    addPermissionsQueryTo(query: any, action: unknown): any;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/services/permission/permissions-manager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/permission/permissions-manager/index.ts"],"names":[],"mappings":"qDAQ4C,GAAG;;;;;;;;;;sBAS3B,GAAG;gCAIO,OAAO;;8CAac,OAAO;;AA1B1D,wBA2CG"}

package/dist/server/src/services/permission/permissions-manager/query-builders.d.ts

@@ -0,0 +1,4 @@
+declare const buildCaslQuery: (ability: unknown, action: unknown, model: unknown) => import("@casl/ability/extra").AbilityQuery<object> | null;
+declare const buildStrapiQuery: (caslQuery: unknown) => unknown;
+export { buildCaslQuery, buildStrapiQuery };
+//# sourceMappingURL=query-builders.d.ts.map

package/dist/server/src/services/permission/permissions-manager/query-builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-builders.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/permission/permissions-manager/query-builders.ts"],"names":[],"mappings":"AA0BA,QAAA,MAAM,cAAc,YAAa,OAAO,UAAU,OAAO,SAAS,OAAO,8DAGxE,CAAC;AAEF,QAAA,MAAM,gBAAgB,cAAe,OAAO,YAE3C,CAAC;AAkCF,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/server/src/services/permission/permissions-manager/sanitize.d.ts

@@ -0,0 +1,7 @@
+declare const _default: ({ action, ability, model }: any) => {
+    sanitizeOutput: (data: unknown, options?: any) => any;
+    sanitizeInput: (data: unknown, options?: any) => any;
+    sanitizeQuery: (data: unknown, options?: any) => any;
+};
+export default _default;
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/server/src/services/permission/permissions-manager/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/permission/permissions-manager/sanitize.ts"],"names":[],"mappings":"qDA6C4C,GAAG;2BAkHN,OAAO;0BAAP,OAAO;0BAAP,OAAO;;AAlHhD,wBAqPE"}

package/dist/server/src/services/permission/permissions-manager/validate.d.ts

@@ -0,0 +1,6 @@
+declare const _default: ({ action, ability, model }: any) => {
+    validateQuery: (data: any, options?: {}) => any;
+    validateInput: (data: any, options?: {}) => any;
+};
+export default _default;
+//# sourceMappingURL=validate.d.ts.map

package/dist/server/src/services/permission/permissions-manager/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/permission/permissions-manager/validate.ts"],"names":[],"mappings":"qDA0C4C,GAAG;;;;AAA/C,wBA0KE"}

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

@@ -0,0 +1,43 @@
+import { Entity } from '@strapi/types';
+import { CreatePermissionPayload } from '../../domain/permission';
+import type { AdminUser, Permission } from '../../../../shared/contracts/shared';
+type ID = Entity.ID;
+/**
+ * Delete permissions of roles in database
+ * @param rolesIds ids of roles
+ */
+export declare const deleteByRolesIds: (rolesIds: ID[]) => Promise<void>;
+/**
+ * Delete permissions
+ * @param ids ids of permissions
+ */
+export declare const deleteByIds: (ids: ID[]) => Promise<void>;
+/**
+ * Create many permissions
+ * @param permissions
+ */
+export declare const createMany: (permissions: CreatePermissionPayload[]) => Promise<Permission[]>;
+/**
+ * Find assigned permissions in the database
+ * @param params query params to find the permissions
+ */
+export declare const findMany: (params?: {}) => Promise<Permission[]>;
+/**
+ * Find all permissions for a user
+ * @param user - user
+ */
+export declare const findUserPermissions: (user: AdminUser) => Promise<Permission[]>;
+/**
+ * Removes permissions in database that don't exist anymore
+ */
+export declare const cleanPermissionsInDatabase: () => Promise<void>;
+declare const _default: {
+    createMany: (permissions: CreatePermissionPayload[]) => Promise<Permission[]>;
+    findMany: (params?: {}) => Promise<Permission[]>;
+    deleteByRolesIds: (rolesIds: Entity.ID[]) => Promise<void>;
+    deleteByIds: (ids: Entity.ID[]) => Promise<void>;
+    findUserPermissions: (user: AdminUser) => Promise<Permission[]>;
+    cleanPermissionsInDatabase: () => Promise<void>;
+};
+export default _default;
+//# sourceMappingURL=queries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/permission/queries.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAGvC,OAAyB,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACpF,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAGjF,KAAK,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC;AAEpB;;;GAGG;AACH,eAAO,MAAM,gBAAgB,aAAoB,EAAE,EAAE,KAAG,QAAQ,IAAI,CAWnE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,QAAe,EAAE,EAAE,KAAG,QAAQ,IAAI,CAOzD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,gBAAuB,uBAAuB,EAAE,KAAG,QAAQ,UAAU,EAAE,CAW7F,CAAC;AAkBF;;;GAGG;AACH,eAAO,MAAM,QAAQ,mBAAwB,QAAQ,UAAU,EAAE,CAIhE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,SAAgB,SAAS,KAAG,QAAQ,UAAU,EAAE,CAE/E,CAAC;AAqCF;;GAEG;AACH,eAAO,MAAM,0BAA0B,QAAa,QAAQ,IAAI,CAiD/D,CAAC;;;;;;;;;AAEF,wBAOE"}

package/dist/server/src/services/permission/sections-builder/builder.d.ts

@@ -0,0 +1,38 @@
+import { Action } from '../../../domain/action';
+import { SectionOptions } from './section';
+/**
+ * Create a new section builder with its own sections registry
+ */
+declare const createSectionBuilder: () => {
+    /**
+     * Create & add a section to the builder's registry
+     * @param sectionName - The unique name of the section
+     * @param options - The options used to build a {@link Section}
+     */
+    createSection(sectionName: string, options: SectionOptions): any;
+    /**
+     * Removes a section from the builder's registry using its unique name
+     * @param sectionName - The name of the section to delete
+     */
+    deleteSection(sectionName: string): any;
+    /**
+     * Register a handler function for a given section
+     * @param  sectionName - The name of the section
+     * @param  handler - The handler to register
+     */
+    addHandler(sectionName: string, handler: () => unknown): any;
+    /**
+     * Register a matcher function for a given section
+     * @param sectionName - The name of the section
+     * @param matcher - The handler to register
+
+     */
+    addMatcher(sectionName: string, matcher: () => unknown): any;
+    /**
+     * Build a section tree based on the registered actions and the given actions
+     * @param actions - The actions used to build each section
+     */
+    build(actions?: Action[]): Promise<any>;
+};
+export default createSectionBuilder;
+//# sourceMappingURL=builder.d.ts.map

package/dist/server/src/services/permission/sections-builder/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/permission/sections-builder/builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAsB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE1D;;GAEG;AACH,QAAA,MAAM,oBAAoB;IAMtB;;;;OAIG;+BACwB,MAAM,WAAW,cAAc;IAQ1D;;;OAGG;+BACwB,MAAM;IAMjC;;;;OAIG;4BACqB,MAAM,WAAW,MAAM,OAAO;IAQtD;;;;;OAKG;4BACqB,MAAM,WAAW,MAAM,OAAO;IAQtD;;;OAGG;;CAWN,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/dist/server/src/services/permission/sections-builder/handlers.d.ts

@@ -0,0 +1,55 @@
+import type { Action } from '../../../domain/action';
+export type ContentTypesSection = {
+    actions: Action[];
+    subjects: any[];
+};
+export type ActionArraySection = Action[];
+/**
+ * Transforms & adds the given  setting action to the section
+ * Note: The action is transformed to a setting specific format
+ * @param options
+ * @param options.action
+ * @param section
+ */
+declare const settings: ({ action, section }: {
+    action: Action;
+    section: ActionArraySection;
+}) => void;
+/**
+ * Transforms & adds the given plugin action to the section
+ * Note: The action is transformed to a plugin specific format
+ * @param {object} options
+ * @param {Action} options.action
+ * @param {ActionArraySection} section
+ */
+declare const plugins: ({ action, section }: {
+    action: Action;
+    section: ActionArraySection;
+}) => void;
+/**
+ * Transforms & adds the given action to the section's actions field
+ * Note: The action is transformed to a content-type specific format
+ * @param {object} options
+ * @param {Action} options.action
+ * @param {ContentTypesSection} section
+ */
+declare const contentTypesBase: ({ action, section, }: {
+    action: Action;
+    section: ContentTypesSection;
+}) => void;
+/**
+ * Initialize the subjects array of a section based on the action's subjects
+ */
+declare const subjectsHandlerFor: (kind: string) => ({ action, section: contentTypesSection }: {
+    action: Action;
+    section: ContentTypesSection;
+}) => void;
+/**
+ * Create and populate the fields property for section's subjects based on the action's subjects list
+ */
+declare const fieldsProperty: ({ action, section }: {
+    action: Action;
+    section: ContentTypesSection;
+}) => void;
+export { plugins, settings, subjectsHandlerFor, contentTypesBase, fieldsProperty };
+//# sourceMappingURL=handlers.d.ts.map

package/dist/server/src/services/permission/sections-builder/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/permission/sections-builder/handlers.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAIrD,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,GAAG,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,MAAM,EAAE,CAAC;AAE1C;;;;;;GAMG;AACH,QAAA,MAAM,QAAQ;YAAmC,MAAM;;UAWtD,CAAC;AAEF;;;;;;GAMG;AACH,QAAA,MAAM,OAAO;YAAmC,MAAM;;UAUrD,CAAC;AAEF;;;;;;GAMG;AACH,QAAA,MAAM,gBAAgB;YAIZ,MAAM;aACL,mBAAmB;UAW7B,CAAC;AAEF;;GAEG;AACH,QAAA,MAAM,kBAAkB,SACf,MAAM;YACwC,MAAM;aAAW,mBAAmB;UAkBxF,CAAC;AA2BJ;;GAEG;AACH,QAAA,MAAM,cAAc;YAAmC,MAAM;aAAW,mBAAmB;UAkB1F,CAAC;AAEF,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,cAAc,EAAE,CAAC"}

package/dist/server/src/services/permission/sections-builder/index.d.ts

@@ -0,0 +1,9 @@
+declare const createDefaultSectionBuilder: () => {
+    createSection(sectionName: string, options: import("./section").SectionOptions): any;
+    deleteSection(sectionName: string): any;
+    addHandler(sectionName: string, handler: () => unknown): any;
+    addMatcher(sectionName: string, matcher: () => unknown): any;
+    build(actions?: import("../../../domain/action").Action[]): Promise<any>;
+};
+export default createDefaultSectionBuilder;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/services/permission/sections-builder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/permission/sections-builder/index.ts"],"names":[],"mappings":"AAiBA,QAAA,MAAM,2BAA2B;;;;;;CA4BhC,CAAC;AAEF,eAAe,2BAA2B,CAAC"}

package/dist/server/src/services/permission/sections-builder/section.d.ts

@@ -0,0 +1,38 @@
+import { hooks } from '@strapi/utils';
+import type { Action } from '../../../domain/action';
+export type SectionOptions = {
+    initialStateFactory?: (...args: any) => unknown;
+    handlers?: ((...args: any) => unknown)[];
+    matchers?: ((...args: any) => unknown)[];
+};
+/**
+ * Upon call, creates a new section object
+ */
+declare const createSection: ({ initialStateFactory, handlers, matchers }?: SectionOptions) => {
+    hooks: {
+        handlers: {
+            call(context: unknown): Promise<void>;
+            getHandlers(): hooks.Handler[];
+            register(handler: hooks.Handler): hooks.Hook<hooks.Handler>;
+            delete(handler: hooks.Handler): hooks.Hook<hooks.Handler>;
+        };
+        matchers: {
+            call(context: unknown): Promise<any[]>;
+            getHandlers(): hooks.Handler[];
+            register(handler: hooks.Handler): hooks.Hook<hooks.Handler>;
+            delete(handler: hooks.Handler): hooks.Hook<hooks.Handler>;
+        };
+    };
+    /**
+     * Verifies if an action can be applied to the section by running the matchers hook.
+     * If any of the registered matcher functions returns true, then the condition applies.
+     */
+    appliesToAction(action: Action): Promise<boolean>;
+    /**
+     * Init, build and returns a section object based on the given actions
+     * @param  actions - A list of actions used to populate the section
+     */
+    build(actions?: Action[]): Promise<unknown>;
+};
+export default createSection;
+//# sourceMappingURL=section.d.ts.map

package/dist/server/src/services/permission/sections-builder/section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"section.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/permission/sections-builder/section.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,MAAM,cAAc,GAAG;IAC3B,mBAAmB,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC;IAChD,QAAQ,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,EAAE,CAAC;IACzC,QAAQ,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,EAAE,CAAC;CAC1C,CAAC;AAIF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;IAiBf;;;OAGG;4BAC2B,MAAM,GAAG,QAAQ,OAAO,CAAC;IAMvD;;;OAGG;;CAeN,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/server/src/services/permission/sections-builder/utils.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="lodash" />
+declare const isOfKind: (kind: unknown) => (value: any) => boolean;
+declare const resolveContentType: (uid: any) => import("@strapi/types/dist/types/core/schemas").ContentType;
+declare const isNotInSubjects: (subjects: any) => (uid: unknown) => boolean;
+declare const hasProperty: import("lodash").CurriedFunction2<unknown, any, boolean>;
+declare const getValidOptions: import("lodash/fp").LodashPick2x1;
+declare const toSubjectTemplate: (ct: any) => {
+    uid: any;
+    label: any;
+    properties: never[];
+};
+export { isOfKind, resolveContentType, isNotInSubjects, hasProperty, getValidOptions, toSubjectTemplate, };
+//# sourceMappingURL=utils.d.ts.map

package/dist/server/src/services/permission/sections-builder/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/permission/sections-builder/utils.ts"],"names":[],"mappings":";AAEA,QAAA,MAAM,QAAQ,SAAU,OAAO,4BAAkC,CAAC;AAElE,QAAA,MAAM,kBAAkB,QAAS,GAAG,gEAA6B,CAAC;AAElE,QAAA,MAAM,eAAe,aAAc,GAAG,WAAW,OAAO,YACD,CAAC;AAExD,QAAA,MAAM,WAAW,0DAEf,CAAC;AAEH,QAAA,MAAM,eAAe,mCAA8B,CAAC;AAEpD,QAAA,MAAM,iBAAiB,OAAQ,GAAG;;;;CAIhC,CAAC;AAEH,OAAO,EACL,QAAQ,EACR,kBAAkB,EAClB,eAAe,EACf,WAAW,EACX,eAAe,EACf,iBAAiB,GAClB,CAAC"}

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

@@ -0,0 +1,68 @@
+/// <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 | null | undefined): 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: import("./permission/sections-builder/section").SectionOptions): any;
+    deleteSection(sectionName: string): any;
+    addHandler(sectionName: string, handler: () => unknown): any;
+    addMatcher(sectionName: string, matcher: () => unknown): any;
+    build(actions?: import("../domain/action").Action[]): Promise<any>;
+};
+declare const sanitizePermission: (p: import("../../../shared/contracts/shared").Permission) => import("../../../shared/contracts/roles").SanitizedPermission;
+declare const engine: {
+    readonly hooks: import("@strapi/permissions/dist/engine/hooks").PermissionEngineHooks;
+    generateUserAbility(user: import("../../../shared/contracts/shared").AdminUser): Promise<import("@casl/ability").Ability<import("@casl/ability").AbilityTuple, any>>;
+    checkMany: import("lodash").CurriedFunction2<import("@casl/ability").Ability<import("@casl/ability").AbilityTuple, any>, import("../../../shared/contracts/shared").Permission[], boolean[]>;
+};
+export { cleanPermissionsInDatabase, createMany, deleteByIds, deleteByRolesIds, findMany, findUserPermissions, createPermissionsManager, sectionsBuilder, sanitizePermission, engine, actionProvider, conditionProvider, };
+//# sourceMappingURL=permission.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permission.d.ts","sourceRoot":"","sources":["../../../../server/src/services/permission.ts"],"names":[],"mappings":";AAGA,OAAO,wBAAwB,MAAM,kCAAkC,CAAC;AAGxE,OAAO,EACL,0BAA0B,EAC1B,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,QAAQ,EACR,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAE9B,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyB,CAAC;AAC9C,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;CAA4B,CAAC;AACpD,QAAA,MAAM,eAAe;;;;;;CAA0B,CAAC;AAEhD,QAAA,MAAM,kBAAkB,6HAAkC,CAAC;AAE3D,QAAA,MAAM,MAAM;;;;CAEV,CAAC;AAEH,OAAO,EAEL,0BAA0B,EAC1B,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,QAAQ,EACR,mBAAmB,EAEnB,wBAAwB,EACxB,eAAe,EACf,kBAAkB,EAElB,MAAM,EAEN,cAAc,EACd,iBAAiB,GAClB,CAAC"}

package/dist/server/src/services/project-settings.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import fs from 'fs';
+import { GetProjectSettings, UpdateProjectSettings } from '../../../shared/contracts/admin';
+interface UploadFile {
+    name: string;
+    path: string;
+    type: string;
+    size: number;
+    stream: fs.ReadStream;
+    tmpPath: string;
+    hash: string;
+    url: string;
+    width: number;
+    height: number;
+    ext: string;
+    provider: unknown;
+}
+type FormattedFiles = Partial<Record<keyof UpdateProjectSettings.Request['files'], Partial<UploadFile>>>;
+declare const parseFilesData: (files: UpdateProjectSettings.Request['files']) => Promise<Partial<Record<"menuLogo" | "authLogo", Partial<UploadFile>>>>;
+declare const getProjectSettings: () => Promise<GetProjectSettings.Response>;
+declare const deleteOldFiles: ({ previousSettings, newSettings }: any) => Promise<void[]>;
+type LogoFiles = {
+    [K in keyof FormattedFiles]: FormattedFiles[K] | null;
+};
+declare const updateProjectSettings: (newSettings: Omit<UpdateProjectSettings.Request['body'], 'menuLogo' | 'authLogo'> & LogoFiles) => Promise<GetProjectSettings.Response>;
+export { deleteOldFiles, parseFilesData, getProjectSettings, updateProjectSettings };
+//# sourceMappingURL=project-settings.d.ts.map

package/dist/server/src/services/project-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-settings.d.ts","sourceRoot":"","sources":["../../../../server/src/services/project-settings.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,MAAM,IAAI,CAAC;AAEpB,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAI5F,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,KAAK,cAAc,GAAG,OAAO,CAC3B,MAAM,CAAC,MAAM,qBAAqB,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAC1E,CAAC;AAEF,QAAA,MAAM,cAAc,UAAiB,sBAAsB,OAAO,CAAC,OAAO,CAAC,2EA0C1E,CAAC;AAEF,QAAA,MAAM,kBAAkB,QAAa,QAAQ,mBAAmB,QAAQ,CAgCvE,CAAC;AAWF,QAAA,MAAM,cAAc,sCAA6C,GAAG,oBAiCnE,CAAC;AAEF,KAAK,SAAS,GAAG;KAAG,CAAC,IAAI,MAAM,cAAc,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI;CAAE,CAAC;AAE3E,QAAA,MAAM,qBAAqB,gBACZ,KAAK,sBAAsB,OAAO,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC,GAAG,SAAS,yCA2C9F,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,CAAC"}

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

@@ -0,0 +1,41 @@
+import { hooks as hooksUtils } from '@strapi/utils';
+import { Entity } from '@strapi/types';
+import type { AdminUser, AdminRole, Permission } from '../../../shared/contracts/shared';
+export type AdminRoleWithUsersCount = AdminRole & {
+    usersCount: number;
+};
+declare const _default: {
+    hooks: {
+        willResetSuperAdminPermissions: {
+            call(param: unknown): Promise<unknown>;
+            getHandlers(): hooksUtils.Handler[];
+            register(handler: hooksUtils.Handler): hooksUtils.Hook<hooksUtils.Handler>;
+            delete(handler: hooksUtils.Handler): hooksUtils.Hook<hooksUtils.Handler>;
+        };
+    };
+    sanitizeRole: <T extends object>(obj: T) => Omit<T, "users" | "permissions">;
+    create: (attributes: Partial<AdminRole>) => Promise<AdminRole>;
+    findOne: (params?: {}, populate?: unknown) => Promise<AdminRole>;
+    findOneWithUsersCount: (params?: {}, populate?: unknown) => Promise<AdminRoleWithUsersCount>;
+    find: (params: {} | undefined, populate: unknown) => Promise<AdminRole[]>;
+    findAllWithUsersCount: (params: any) => Promise<AdminRoleWithUsersCount[]>;
+    update: (params: any, attributes: Partial<AdminRole>) => Promise<AdminRole>;
+    exists: (params?: unknown) => Promise<boolean>;
+    count: (params?: any) => Promise<number>;
+    deleteByIds: (ids?: Entity.ID[]) => Promise<AdminRole[]>;
+    getUsersCount: (roleId: Entity.ID) => Promise<number>;
+    getSuperAdmin: () => Promise<AdminRole | undefined>;
+    getSuperAdminWithUsersCount: () => Promise<AdminRoleWithUsersCount>;
+    createRolesIfNoneExist: () => Promise<void>;
+    displayWarningIfNoSuperAdmin: () => Promise<void>;
+    addPermissions: (roleId: Entity.ID, permissions: any) => Promise<Permission[]>;
+    hasSuperAdminRole: (user: AdminUser) => boolean;
+    assignPermissions: (roleId: Entity.ID, permissions?: Pick<Permission, "action" | "subject" | "conditions">[]) => Promise<Permission[]>;
+    resetSuperAdminPermissions: () => Promise<void>;
+    checkRolesIdForDeletion: (ids?: Entity.ID[]) => Promise<void>;
+    constants: {
+        superAdminCode: string;
+    };
+};
+export default _default;
+//# sourceMappingURL=role.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"role.d.ts","sourceRoot":"","sources":["../../../../server/src/services/role.ts"],"names":[],"mappings":"AAMA,OAAO,EAAyC,KAAK,IAAI,UAAU,EAAU,MAAM,eAAe,CAAC;AACnG,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAGvC,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AA0BzF,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqazE,wBAuBE"}