@strapi/review-workflows 5.0.0-beta.2 → 5.0.0-beta.4

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

@@ -0,0 +1,322 @@
+/// <reference types="koa" />
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => Promise<void>;
+    bootstrap: (args: any) => Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => Promise<void>;
+    contentTypes: {
+        workflow: {
+            schema: {
+                collectionName: string;
+                info: {
+                    name: string;
+                    description: string;
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {};
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                    };
+                    stages: {
+                        type: string;
+                        target: string;
+                        relation: string;
+                        mappedBy: string;
+                    };
+                    contentTypes: {
+                        type: string;
+                        required: boolean;
+                        default: string;
+                    };
+                };
+            };
+        };
+        'workflow-stage': {
+            schema: {
+                collectionName: string;
+                info: {
+                    name: string;
+                    description: string;
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {
+                    version: string;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    color: {
+                        type: string;
+                        configurable: boolean;
+                        default: string;
+                    };
+                    workflow: {
+                        type: string;
+                        target: string;
+                        relation: string;
+                        inversedBy: string;
+                        configurable: boolean;
+                    };
+                    permissions: {
+                        type: string;
+                        target: string;
+                        relation: string;
+                        configurable: boolean;
+                    };
+                };
+            };
+        };
+    };
+    services: {
+        workflows: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            find(opts?: any): Promise<any[]>;
+            findById(id: any, opts?: {
+                populate?: any;
+            }): Promise<any>;
+            create(opts: {
+                data: any;
+            }): Promise<any>;
+            update(workflow: any, opts: any): Promise<any>;
+            delete(workflow: any, opts: any): Promise<any>;
+            count(): Promise<number>;
+            getAssignedWorkflow(uid: any, opts?: any): Promise<any>;
+            _getAssignedWorkflows(uid: any, opts?: {}): Promise<any[]>;
+            assertContentTypeBelongsToWorkflow(uid: any): Promise<any>;
+            assertStageBelongsToWorkflow(stageId: any, workflow: any): void;
+        };
+        stages: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            find({ workflowId, populate }: any): Promise<any[]>;
+            findById(id: string | number, { populate }?: any): Promise<any>;
+            createMany(stagesList: any, { fields }?: any): Promise<any[]>;
+            update(srcStage: any, destStage: any): Promise<any>;
+            delete(stage: any): Promise<any>;
+            deleteMany(stages: any): Promise<import("@strapi/database/dist/types").CountResult>;
+            deleteStagePermissions(stages: any): Promise<void>;
+            count({ workflowId }?: any): Promise<number>;
+            replaceStages(srcStages: any, destStages: any, contentTypesToMigrate?: never[]): Promise<any>;
+            updateEntity(entityInfo: any, stageId: any): Promise<any>;
+            updateEntitiesStage(contentTypeUID: any, { fromStageId, toStageId }: any): Promise<number | number[]>;
+            deleteAllEntitiesStage(contentTypeUID: any): Promise<number>;
+        };
+        'stage-permissions': ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            register({ roleId, action, fromStage }: any): Promise<any>;
+            registerMany(permissions: any): Promise<any>;
+            unregister(permissions: any): Promise<void>;
+            can(action: any, fromStage: any): any;
+        };
+        assignees: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            findEntityAssigneeId(id: string, model: import("@strapi/types/dist/uid").ContentType): Promise<any>;
+            updateEntityAssignee(documentId: string, locale: string, model: import("@strapi/types/dist/uid").ContentType, assigneeId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+            deleteEntityAssignee(documentId: string, locale: string, model: import("@strapi/types/dist/uid").ContentType): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+        };
+        validation: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            limits: {
+                numberOfWorkflows: number;
+                stagesPerWorkflow: number;
+            };
+            register({ numberOfWorkflows, stagesPerWorkflow }: any): void;
+            validateWorkflowStages(stages: any): void;
+            validateWorkflowCountStages(workflowId: any, countAddedStages?: number): Promise<void>;
+            validateWorkflowCount(countAddedWorkflows?: number): Promise<void>;
+        };
+        'document-service-middlewares': () => {
+            assignStageOnCreate: import("@strapi/types/dist/modules/documents/middleware").Middleware;
+            handleStageOnUpdate: import("@strapi/types/dist/modules/documents/middleware").Middleware;
+        };
+        'workflow-metrics': {
+            sendDidCreateStage: () => Promise<void>;
+            sendDidEditStage: () => Promise<void>;
+            sendDidDeleteStage: () => Promise<void>;
+            sendDidChangeEntryStage: () => Promise<void>;
+            sendDidCreateWorkflow: () => Promise<void>;
+            sendDidEditWorkflow: () => Promise<void>;
+            sendDidSendReviewWorkflowPropertiesOnceAWeek: (numberOfActiveWorkflows: number, avgStagesCount: number, maxStagesCount: number, activatedContentTypes: number) => Promise<void>;
+            sendDidEditAssignee: (fromId: any, toId: any) => Promise<void>;
+        };
+        'workflow-weekly-metrics': ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            computeMetrics(): Promise<{
+                numberOfActiveWorkflows: number;
+                avgStagesCount: number;
+                maxStagesCount: unknown;
+                activatedContentTypes: number;
+            }>;
+            sendMetrics(): Promise<void>;
+            ensureWeeklyStoredCronSchedule(): Promise<any>;
+            registerCron(): Promise<void>;
+        };
+    };
+    controllers: {
+        workflows: {
+            create(ctx: import("koa").Context): Promise<void>;
+            update(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            delete(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            find(ctx: import("koa").Context): Promise<void>;
+            findById(ctx: import("koa").Context): Promise<void>;
+        };
+        stages: {
+            find(ctx: import("koa").Context): Promise<void>;
+            findById(ctx: import("koa").Context): Promise<void>;
+            updateEntity(ctx: import("koa").Context): Promise<void>;
+            listAvailableStages(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+        };
+        assignees: {
+            updateEntity(ctx: import("koa").Context): Promise<void>;
+        };
+    };
+    routes: {
+        'review-workflows': {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    middlewares: ((ctx: any, next: any) => any)[];
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+    };
+} | {
+    contentTypes: {
+        workflow: {
+            schema: {
+                collectionName: string;
+                info: {
+                    name: string;
+                    description: string;
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {};
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                    };
+                    stages: {
+                        type: string;
+                        target: string;
+                        relation: string;
+                        mappedBy: string;
+                    };
+                    contentTypes: {
+                        type: string;
+                        required: boolean;
+                        default: string;
+                    };
+                };
+            };
+        };
+        'workflow-stage': {
+            schema: {
+                collectionName: string;
+                info: {
+                    name: string;
+                    description: string;
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {
+                    version: string;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    color: {
+                        type: string;
+                        configurable: boolean;
+                        default: string;
+                    };
+                    workflow: {
+                        type: string;
+                        target: string;
+                        relation: string;
+                        inversedBy: string;
+                        configurable: boolean;
+                    };
+                    permissions: {
+                        type: string;
+                        target: string;
+                        relation: string;
+                        configurable: boolean;
+                    };
+                };
+            };
+        };
+    };
+    register?: undefined;
+    bootstrap?: undefined;
+    destroy?: undefined;
+    services?: undefined;
+    controllers?: undefined;
+    routes?: undefined;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,wBAA2B"}

package/dist/server/src/middlewares/review-workflows.d.ts

@@ -0,0 +1,17 @@
+import type { Core } from '@strapi/types';
+/**
+ * A Strapi middleware function that adds support for review workflows.
+ *
+ * Why is it needed ?
+ * For now, the admin panel cannot have anything but top-level attributes in the content-type for options.
+ * But we need the CE part to be agnostics from Review Workflow (which is an EE feature).
+ * CE handle the `options` object, that's why we move the reviewWorkflows boolean to the options object.
+ *
+ * @param {object} strapi - The Strapi instance.
+ */
+export declare function contentTypeMiddleware(strapi: Core.Strapi): void;
+declare const _default: {
+    contentTypeMiddleware: typeof contentTypeMiddleware;
+};
+export default _default;
+//# sourceMappingURL=review-workflows.d.ts.map

package/dist/server/src/middlewares/review-workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-workflows.d.ts","sourceRoot":"","sources":["../../../../server/src/middlewares/review-workflows.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAI1C;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,QAqBxD;;;;AAED,wBAEE"}

package/dist/server/src/migrations/handle-deleted-ct-in-workflows.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Remove CT references from workflows if the CT is deleted
+ */
+declare function migrateDeletedCTInWorkflows({ oldContentTypes, contentTypes }: any): Promise<void>;
+export default migrateDeletedCTInWorkflows;
+//# sourceMappingURL=handle-deleted-ct-in-workflows.d.ts.map

package/dist/server/src/migrations/handle-deleted-ct-in-workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-deleted-ct-in-workflows.d.ts","sourceRoot":"","sources":["../../../../server/src/migrations/handle-deleted-ct-in-workflows.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,iBAAe,2BAA2B,CAAC,EAAE,eAAe,EAAE,YAAY,EAAE,EAAE,GAAG,iBAwBhF;AAED,eAAe,2BAA2B,CAAC"}

package/dist/server/src/migrations/multiple-workflows.d.ts

@@ -0,0 +1,3 @@
+declare function migrateWorkflowsContentTypes({ oldContentTypes, contentTypes }: any): Promise<void>;
+export default migrateWorkflowsContentTypes;
+//# sourceMappingURL=multiple-workflows.d.ts.map

package/dist/server/src/migrations/multiple-workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiple-workflows.d.ts","sourceRoot":"","sources":["../../../../server/src/migrations/multiple-workflows.ts"],"names":[],"mappings":"AAGA,iBAAe,4BAA4B,CAAC,EAAE,eAAe,EAAE,YAAY,EAAE,EAAE,GAAG,iBAqBjF;AAED,eAAe,4BAA4B,CAAC"}

package/dist/server/src/migrations/set-stages-default-color.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Set the default color for stages if the color attribute was added
+ */
+declare function migrateReviewWorkflowStagesColor({ oldContentTypes, contentTypes }: any): Promise<void>;
+export default migrateReviewWorkflowStagesColor;
+//# sourceMappingURL=set-stages-default-color.d.ts.map

package/dist/server/src/migrations/set-stages-default-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-stages-default-color.d.ts","sourceRoot":"","sources":["../../../../server/src/migrations/set-stages-default-color.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,iBAAe,gCAAgC,CAAC,EAAE,eAAe,EAAE,YAAY,EAAE,EAAE,GAAG,iBAarF;AAED,eAAe,gCAAgC,CAAC"}

package/dist/server/src/migrations/set-stages-roles.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Migrate review workflow stages to have RBAC permissions for all roles.
+ */
+declare function migrateReviewWorkflowStagesRoles({ oldContentTypes, contentTypes }: any): Promise<void>;
+export default migrateReviewWorkflowStagesRoles;
+//# sourceMappingURL=set-stages-roles.d.ts.map

package/dist/server/src/migrations/set-stages-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-stages-roles.d.ts","sourceRoot":"","sources":["../../../../server/src/migrations/set-stages-roles.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,iBAAe,gCAAgC,CAAC,EAAE,eAAe,EAAE,YAAY,EAAE,EAAE,GAAG,iBA4DrF;AAED,eAAe,gCAAgC,CAAC"}

package/dist/server/src/migrations/set-workflow-default-name.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Multiple workflows introduced the ability to name a workflow.
+ * This migration adds the default workflow name if the name attribute was added.
+ */
+declare function migrateReviewWorkflowName({ oldContentTypes, contentTypes }: any): Promise<void>;
+export default migrateReviewWorkflowName;
+//# sourceMappingURL=set-workflow-default-name.d.ts.map

package/dist/server/src/migrations/set-workflow-default-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-workflow-default-name.d.ts","sourceRoot":"","sources":["../../../../server/src/migrations/set-workflow-default-name.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,iBAAe,yBAAyB,CAAC,EAAE,eAAe,EAAE,YAAY,EAAE,EAAE,GAAG,iBAgB9E;AAED,eAAe,yBAAyB,CAAC"}

package/dist/server/src/migrations/shorten-stage-attribute.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shorten strapi stage name
+ */
+declare function migrateStageAttribute({ oldContentTypes, contentTypes }: any): Promise<void>;
+export default migrateStageAttribute;
+//# sourceMappingURL=shorten-stage-attribute.d.ts.map

package/dist/server/src/migrations/shorten-stage-attribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shorten-stage-attribute.d.ts","sourceRoot":"","sources":["../../../../server/src/migrations/shorten-stage-attribute.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,iBAAe,qBAAqB,CAAC,EAAE,eAAe,EAAE,YAAY,EAAE,EAAE,GAAG,iBAmC1E;AAED,eAAe,qBAAqB,CAAC"}

package/dist/server/src/register.d.ts

@@ -0,0 +1,6 @@
+import type { Core } from '@strapi/types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default _default;
+//# sourceMappingURL=register.d.ts.map

package/dist/server/src/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../server/src/register.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;qCAgFR;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;AAAzD,wBA2BE"}

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

@@ -0,0 +1,21 @@
+declare const _default: {
+    'review-workflows': {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                middlewares: ((ctx: any, next: any) => any)[];
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                })[];
+            };
+        }[];
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAEA,wBAEE"}

package/dist/server/src/routes/review-workflows.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            middlewares: ((ctx: any, next: any) => any)[];
+            policies: (string | {
+                name: string;
+                config: {
+                    actions: string[];
+                };
+            })[];
+        };
+    }[];
+};
+export default _default;
+//# sourceMappingURL=review-workflows.d.ts.map

package/dist/server/src/routes/review-workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-workflows.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/review-workflows.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAEA,wBA+JE"}

package/dist/server/src/routes/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const enableFeatureMiddleware: (featureName: string) => (ctx: any, next: any) => any;
+//# sourceMappingURL=utils.d.ts.map

package/dist/server/src/routes/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,gBAAiB,MAAM,WAAW,GAAG,QAAQ,GAAG,QAMnF,CAAC"}

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

@@ -0,0 +1,13 @@
+import type { Core, UID } from '@strapi/types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    findEntityAssigneeId(id: string, model: UID.ContentType): Promise<any>;
+    /**
+     * Update the assignee of an entity
+     */
+    updateEntityAssignee(documentId: string, locale: string, model: UID.ContentType, assigneeId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+    deleteEntityAssignee(documentId: string, locale: string, model: UID.ContentType): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+};
+export default _default;
+//# sourceMappingURL=assignees.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assignees.d.ts","sourceRoot":"","sources":["../../../../server/src/services/assignees.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;qCAQnB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;6BAIhB,MAAM,SAAS,IAAI,WAAW;IAU7D;;OAEG;qCAEW,MAAM,UACV,MAAM,SACP,IAAI,WAAW,cACV,MAAM;qCAuBmB,MAAM,UAAU,MAAM,SAAS,IAAI,WAAW;;AA5CzF,wBAwDE"}

package/dist/server/src/services/document-service-middleware.d.ts

@@ -0,0 +1,7 @@
+import { Modules } from '@strapi/types';
+declare const _default: () => {
+    assignStageOnCreate: Modules.Documents.Middleware.Middleware;
+    handleStageOnUpdate: Modules.Documents.Middleware.Middleware;
+};
+export default _default;
+//# sourceMappingURL=document-service-middleware.d.ts.map

package/dist/server/src/services/document-service-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-service-middleware.d.ts","sourceRoot":"","sources":["../../../../server/src/services/document-service-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;;;;;AA2HxC,wBAGG"}

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

@@ -0,0 +1,92 @@
+declare const _default: {
+    workflows: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        find(opts?: any): Promise<any[]>;
+        findById(id: any, opts?: {
+            populate?: any;
+        }): Promise<any>;
+        create(opts: {
+            data: any;
+        }): Promise<any>;
+        update(workflow: any, opts: any): Promise<any>;
+        delete(workflow: any, opts: any): Promise<any>;
+        count(): Promise<number>;
+        getAssignedWorkflow(uid: any, opts?: any): Promise<any>;
+        _getAssignedWorkflows(uid: any, opts?: {}): Promise<any[]>;
+        assertContentTypeBelongsToWorkflow(uid: any): Promise<any>;
+        assertStageBelongsToWorkflow(stageId: any, workflow: any): void;
+    };
+    stages: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        find({ workflowId, populate }: any): Promise<any[]>;
+        findById(id: string | number, { populate }?: any): Promise<any>;
+        createMany(stagesList: any, { fields }?: any): Promise<any[]>;
+        update(srcStage: any, destStage: any): Promise<any>;
+        delete(stage: any): Promise<any>;
+        deleteMany(stages: any): Promise<import("@strapi/database/dist/types").CountResult>;
+        deleteStagePermissions(stages: any): Promise<void>;
+        count({ workflowId }?: any): Promise<number>;
+        replaceStages(srcStages: any, destStages: any, contentTypesToMigrate?: never[]): Promise<any>;
+        updateEntity(entityInfo: any, stageId: any): Promise<any>;
+        updateEntitiesStage(contentTypeUID: any, { fromStageId, toStageId }: any): Promise<number | number[]>;
+        deleteAllEntitiesStage(contentTypeUID: any): Promise<number>;
+    };
+    'stage-permissions': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        register({ roleId, action, fromStage }: any): Promise<any>;
+        registerMany(permissions: any): Promise<any>;
+        unregister(permissions: any): Promise<void>;
+        can(action: any, fromStage: any): any;
+    };
+    assignees: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        findEntityAssigneeId(id: string, model: import("@strapi/types/dist/uid").ContentType): Promise<any>;
+        updateEntityAssignee(documentId: string, locale: string, model: import("@strapi/types/dist/uid").ContentType, assigneeId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+        deleteEntityAssignee(documentId: string, locale: string, model: import("@strapi/types/dist/uid").ContentType): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+    };
+    validation: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        limits: {
+            numberOfWorkflows: number;
+            stagesPerWorkflow: number;
+        };
+        register({ numberOfWorkflows, stagesPerWorkflow }: any): void;
+        validateWorkflowStages(stages: any): void;
+        validateWorkflowCountStages(workflowId: any, countAddedStages?: number): Promise<void>;
+        validateWorkflowCount(countAddedWorkflows?: number): Promise<void>;
+    };
+    'document-service-middlewares': () => {
+        assignStageOnCreate: import("@strapi/types/dist/modules/documents/middleware").Middleware;
+        handleStageOnUpdate: import("@strapi/types/dist/modules/documents/middleware").Middleware;
+    };
+    'workflow-metrics': {
+        sendDidCreateStage: () => Promise<void>;
+        sendDidEditStage: () => Promise<void>;
+        sendDidDeleteStage: () => Promise<void>;
+        sendDidChangeEntryStage: () => Promise<void>;
+        sendDidCreateWorkflow: () => Promise<void>;
+        sendDidEditWorkflow: () => Promise<void>;
+        sendDidSendReviewWorkflowPropertiesOnceAWeek: (numberOfActiveWorkflows: number, avgStagesCount: number, maxStagesCount: number, activatedContentTypes: number) => Promise<void>;
+        sendDidEditAssignee: (fromId: any, toId: any) => Promise<void>;
+    };
+    'workflow-weekly-metrics': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        computeMetrics(): Promise<{
+            numberOfActiveWorkflows: number;
+            avgStagesCount: number;
+            maxStagesCount: unknown;
+            activatedContentTypes: number;
+        }>;
+        sendMetrics(): Promise<void>;
+        ensureWeeklyStoredCronSchedule(): Promise<any>;
+        registerCron(): Promise<void>;
+    };
+};
+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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,wBASE"}

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

@@ -0,0 +1,21 @@
+import '@strapi/types';
+export declare const sendDidCreateStage: () => Promise<void>;
+export declare const sendDidEditStage: () => Promise<void>;
+export declare const sendDidDeleteStage: () => Promise<void>;
+export declare const sendDidChangeEntryStage: () => Promise<void>;
+export declare const sendDidCreateWorkflow: () => Promise<void>;
+export declare const sendDidEditWorkflow: () => Promise<void>;
+export declare const sendDidEditAssignee: (fromId: any, toId: any) => Promise<void>;
+export declare const sendDidSendReviewWorkflowPropertiesOnceAWeek: (numberOfActiveWorkflows: number, avgStagesCount: number, maxStagesCount: number, activatedContentTypes: number) => Promise<void>;
+declare const _default: {
+    sendDidCreateStage: () => Promise<void>;
+    sendDidEditStage: () => Promise<void>;
+    sendDidDeleteStage: () => Promise<void>;
+    sendDidChangeEntryStage: () => Promise<void>;
+    sendDidCreateWorkflow: () => Promise<void>;
+    sendDidEditWorkflow: () => Promise<void>;
+    sendDidSendReviewWorkflowPropertiesOnceAWeek: (numberOfActiveWorkflows: number, avgStagesCount: number, maxStagesCount: number, activatedContentTypes: number) => Promise<void>;
+    sendDidEditAssignee: (fromId: any, toId: any) => Promise<void>;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/metrics/index.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC;AAEvB,eAAO,MAAM,kBAAkB,qBAE9B,CAAC;AAEF,eAAO,MAAM,gBAAgB,qBAE5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,qBAE9B,CAAC;AAEF,eAAO,MAAM,uBAAuB,qBAEnC,CAAC;AAEF,eAAO,MAAM,qBAAqB,qBAEjC,CAAC;AAEF,eAAO,MAAM,mBAAmB,qBAE/B,CAAC;AAEF,eAAO,MAAM,mBAAmB,WAAkB,GAAG,QAAQ,GAAG,kBAE/D,CAAC;AAEF,eAAO,MAAM,4CAA4C,4BAC9B,MAAM,kBACf,MAAM,kBACN,MAAM,yBACC,MAAM,kBAU9B,CAAC;;;;;;;;;;;AAEF,wBASE"}