/// <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: {
        homepage: ({ strapi }: {
            strapi: import("@strapi/types/dist/core").Strapi;
        }) => {
            getRecentlyAssignedDocuments(): Promise<import("../../shared/contracts/homepage").RecentDocument[]>;
        };
        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, }: {
                roleId: number;
                action: string;
                fromStage: number;
            }): Promise<any>;
            registerMany(permissions: {
                roleId: number;
                action: string;
                fromStage: number;
            }[]): Promise<any>;
            registerTo({ roleId, action, toStage, }: {
                roleId: number;
                action: string;
                toStage: number;
            }): Promise<any>;
            registerManyTo(permissions: {
                roleId: number;
                action: string;
                toStage: number;
            }[]): Promise<any>;
            unregister(permissions: {
                id: number;
            }[]): Promise<void>;
            can(action: string, fromStage: number): any;
            canTransitionToStage(toStageId: number): Promise<boolean>;
            canTransitionToStageWithPermissions(stage: {
                permissions?: {
                    actionParameters?: {
                        to?: number | undefined;
                    } | undefined;
                    role?: number | {
                        id: number;
                    } | undefined;
                }[] | undefined;
            }): boolean;
        };
        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: {
        homepage: import("@strapi/types/dist/core").Router;
        '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