@strapi/review-workflows 0.0.0-experimental.74c69aeafc770d59d5b3d5d37cd249934ef395ba → 0.0.0-experimental.75b9c6babc2f67877cfc879041cfff9fb966e742

package/dist/server/src/content-types/workflow/index.d.ts

@@ -0,0 +1,47 @@
+declare const _default: {
+    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;
+            };
+            stageRequiredToPublish: {
+                type: string;
+                target: string;
+                relation: string;
+                required: boolean;
+            };
+            contentTypes: {
+                type: string;
+                required: boolean;
+                default: string;
+            };
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/content-types/workflow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/content-types/workflow/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA4CE"}

package/dist/server/src/content-types/workflow-stage/index.d.ts

@@ -0,0 +1,49 @@
+declare const _default: {
+    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;
+            };
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/content-types/workflow-stage/index.d.ts.map

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

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

@@ -0,0 +1,19 @@
+import type { Context } from 'koa';
+declare const _default: {
+    /**
+     * Updates an entity's assignee.
+     * @async
+     * @param {Object} ctx - The Koa context object.
+     * @param {Object} ctx.params - An object containing the parameters from the request URL.
+     * @param {string} ctx.params.model_uid - The model UID of the entity.
+     * @param {string} ctx.params.id - The ID of the entity to update.
+     * @param {Object} ctx.request.body.data - Optional data object containing the new assignee ID for the entity.
+     * @param {string} ctx.request.body.data.id - The ID of the new assignee for the entity.
+     * @throws {ApplicationError} If review workflows is not activated on the specified model UID.
+     * @throws {ValidationError} If the `data` object in the request body fails to pass validation.
+     * @returns {Promise<void>} A promise that resolves when the entity's assignee has been updated.
+     */
+    updateEntity(ctx: Context): Promise<void>;
+};
+export default _default;
+//# sourceMappingURL=assignees.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assignees.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/assignees.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;;IAOjC;;;;;;;;;;;;OAYG;sBACqB,OAAO;;AAdjC,wBA4DE"}

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

@@ -0,0 +1,20 @@
+/// <reference types="koa" />
+declare const _default: {
+    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>;
+    };
+    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>;
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/server/src/controllers/stages.d.ts

@@ -0,0 +1,39 @@
+import type { Context } from 'koa';
+declare const _default: {
+    /**
+     * List all stages
+     * @param {import('koa').BaseContext} ctx - koa context
+     */
+    find(ctx: Context): Promise<void>;
+    /**
+     * Get one stage
+     * @param {import('koa').BaseContext} ctx - koa context
+     */
+    findById(ctx: Context): Promise<void>;
+    /**
+     * Updates an entity's stage.
+     * @async
+     * @param {Object} ctx - The Koa context object.
+     * @param {Object} ctx.params - An object containing the parameters from the request URL.
+     * @param {string} ctx.params.model_uid - The model UID of the entity.
+     * @param {string} ctx.params.id - The ID of the entity to update.
+     * @param {Object} ctx.request.body.data - Optional data object containing the new stage ID for the entity.
+     * @param {string} ctx.request.body.data.id - The ID of the new stage for the entity.
+     * @throws {ApplicationError} If review workflows is not activated on the specified model UID.
+     * @throws {ValidationError} If the `data` object in the request body fails to pass validation.
+     * @returns {Promise<void>} A promise that resolves when the entity's stage has been updated.
+     */
+    updateEntity(ctx: Context): Promise<void>;
+    /**
+     * List all the stages that are available for a user to transition an entity to.
+     * If the user has permission to change the current stage of the entity every other stage in the workflow is returned
+     * @async
+     * @param {*} ctx
+     * @param {string} ctx.params.model_uid - The model UID of the entity.
+     * @param {string} ctx.params.id - The ID of the entity.
+     * @throws {ApplicationError} If review workflows is not activated on the specified model UID.
+     */
+    listAvailableStages(ctx: Context): Promise<Context | undefined>;
+};
+export default _default;
+//# sourceMappingURL=stages.d.ts.map

package/dist/server/src/controllers/stages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stages.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/stages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;;IA4BjC;;;OAGG;cACa,OAAO;IAevB;;;OAGG;kBACiB,OAAO;IAgB3B;;;;;;;;;;;;OAYG;sBACqB,OAAO;IAiD/B;;;;;;;;OAQG;6BAC4B,OAAO;;AA/GxC,wBA4KE"}

package/dist/server/src/controllers/workflows.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from 'koa';
+declare const _default: {
+    /**
+     * Create a new workflow
+     * @param {import('koa').BaseContext} ctx - koa context
+     */
+    create(ctx: Context): Promise<void>;
+    /**
+     * Update a workflow
+     * @param {import('koa').BaseContext} ctx - koa context
+     */
+    update(ctx: Context): Promise<Context | undefined>;
+    /**
+     * Delete a workflow
+     * @param {import('koa').BaseContext} ctx - koa context
+     */
+    delete(ctx: Context): Promise<Context | undefined>;
+    /**
+     * List all workflows
+     * @param {import('koa').BaseContext} ctx - koa context
+     */
+    find(ctx: Context): Promise<void>;
+};
+export default _default;
+//# sourceMappingURL=workflows.d.ts.map

package/dist/server/src/controllers/workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/workflows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;;IAuCjC;;;OAGG;gBACe,OAAO;IAuBzB;;;OAGG;gBACe,OAAO;IAmCzB;;;OAGG;gBACe,OAAO;IAwBzB;;;OAGG;cACa,OAAO;;AAnGzB,wBAwHE"}

package/dist/server/src/destroy.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=destroy.d.ts.map

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

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

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

@@ -0,0 +1,343 @@
+/// <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;
+                    };
+                    stageRequiredToPublish: {
+                        type: string;
+                        target: string;
+                        relation: string;
+                        required: boolean;
+                    };
+                    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(entityToUpdate: {
+                id: string | number;
+                documentId: string;
+                locale: string;
+                updatedAt: string;
+            }, model: import("@strapi/types/dist/uid").ContentType, stageId: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+            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 | number, model: import("@strapi/types/dist/uid").ContentType): Promise<any>;
+            updateEntityAssignee(entityToUpdate: {
+                id: string | number;
+                documentId: string;
+                locale: string;
+                updatedAt: string;
+            }, model: import("@strapi/types/dist/uid").ContentType, assigneeId: string | null): 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;
+            checkStageBeforePublish: import("@strapi/types/dist/modules/documents/middleware").Middleware;
+        };
+        'workflow-metrics': {
+            sendDidCreateStage: () => Promise<void>;
+            sendDidEditStage: () => Promise<void>;
+            sendDidDeleteStage: () => Promise<void>;
+            sendDidChangeEntryStage: () => Promise<void>;
+            sendDidCreateWorkflow: (workflowId: string, hasRequiredStageToPublish: boolean) => Promise<void>;
+            sendDidEditWorkflow: (workflowId: string, hasRequiredStageToPublish: boolean) => 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>;
+        };
+        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;
+                    };
+                    stageRequiredToPublish: {
+                        type: string;
+                        target: string;
+                        relation: string;
+                        required: boolean;
+                    };
+                    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"}