declare const _default: {
    register: ({ strapi }: {
        strapi: import("@strapi/types/dist/core").Strapi;
    }) => Promise<void>;
    bootstrap: ({ strapi }: {
        strapi: import("@strapi/types/dist/core").Strapi;
    }) => Promise<void>;
    destroy: ({ strapi }: {
        strapi: import("@strapi/types/dist/core").Strapi;
    }) => Promise<void>;
    contentTypes: {
        release: {
            schema: {
                collectionName: string;
                info: {
                    singularName: string;
                    pluralName: string;
                    displayName: string;
                };
                options: {
                    draftAndPublish: boolean;
                };
                pluginOptions: {
                    'content-manager': {
                        visible: boolean;
                    };
                    'content-type-builder': {
                        visible: boolean;
                    };
                };
                attributes: {
                    name: {
                        type: string;
                        required: boolean;
                    };
                    releasedAt: {
                        type: string;
                    };
                    scheduledAt: {
                        type: string;
                    };
                    timezone: {
                        type: string;
                    };
                    status: {
                        type: string;
                        enum: string[];
                        required: boolean;
                    };
                    actions: {
                        type: string;
                        relation: string;
                        target: string;
                        mappedBy: string;
                    };
                };
            };
        };
        'release-action': {
            schema: {
                collectionName: string;
                info: {
                    singularName: string;
                    pluralName: string;
                    displayName: string;
                };
                options: {
                    draftAndPublish: boolean;
                };
                pluginOptions: {
                    'content-manager': {
                        visible: boolean;
                    };
                    'content-type-builder': {
                        visible: boolean;
                    };
                };
                attributes: {
                    type: {
                        type: string;
                        enum: string[];
                        required: boolean;
                    };
                    contentType: {
                        type: string;
                        required: boolean;
                    };
                    entryDocumentId: {
                        type: string;
                    };
                    locale: {
                        type: string;
                    };
                    release: {
                        type: string;
                        relation: string;
                        target: string;
                        inversedBy: string;
                    };
                    isEntryValid: {
                        type: string;
                    };
                };
            };
        };
    };
    services: {
        homepage: ({ strapi }: {
            strapi: import("@strapi/types/dist/core").Strapi;
        }) => {
            getUpcomingReleases(): Promise<import("../../shared/contracts/homepage").GetUpcomingReleases.Response["data"]>;
        };
        release: ({ strapi }: {
            strapi: import("@strapi/types/dist/core").Strapi;
        }) => {
            create(releaseData: import("../../shared/contracts/releases").CreateRelease.Request["body"], { user }: {
                user: import("../../shared/types").UserInfo;
            }): Promise<any>;
            findOne(id: import("../../shared/contracts/releases").GetRelease.Request["params"]["id"], query?: {}): Promise<any>;
            findPage(query?: import("../../shared/contracts/releases").GetReleases.Request["query"]): Promise<{
                results: any[];
                pagination: {
                    page: number;
                    pageSize: number;
                    pageCount: number;
                    total: number;
                };
            }>;
            findMany(query?: any): Promise<any[]>;
            update(id: import("@strapi/types/dist/data").ID, releaseData: import("../../shared/contracts/releases").UpdateRelease.Request["body"], { user }: {
                user: import("../../shared/types").UserInfo;
            }): Promise<any>;
            getAllComponents(): Promise<any>;
            delete(releaseId: import("../../shared/contracts/releases").DeleteRelease.Request["params"]["id"]): Promise<import("../../shared/contracts/releases").Release>;
            publish(releaseId: import("../../shared/contracts/releases").PublishRelease.Request["params"]["id"]): Promise<Pick<import("../../shared/contracts/releases").Release, "id" | "releasedAt" | "status"> | null>;
            updateReleaseStatus(releaseId: import("../../shared/contracts/releases").Release["id"]): Promise<any>;
        };
        'release-action': ({ strapi }: {
            strapi: import("@strapi/types/dist/core").Strapi;
        }) => {
            create(releaseId: import("../../shared/contracts/release-actions").CreateReleaseAction.Request["params"]["releaseId"], action: import("../../shared/contracts/release-actions").CreateReleaseAction.Request["body"], { disableUpdateReleaseStatus }?: {
                disableUpdateReleaseStatus?: boolean;
            }): Promise<any>;
            findPage(releaseId: import("../../shared/contracts/release-actions").GetReleaseActions.Request["params"]["releaseId"], query?: import("../../shared/contracts/release-actions").GetReleaseActions.Request["query"]): Promise<{
                results: any;
                pagination: {
                    page: number;
                    pageSize: number;
                    pageCount: number;
                    total: number;
                };
            }>;
            groupActions(actions: import("../../shared/contracts/release-actions").ReleaseAction[], groupBy: import("../../shared/contracts/release-actions").ReleaseActionGroupBy): Promise<import("lodash").Dictionary<(null | undefined)[]>>;
            getContentTypeModelsFromActions(actions: import("../../shared/contracts/release-actions").ReleaseAction[]): Promise<{} | undefined>;
            countActions(query: import("@strapi/types/dist/modules/entity-service/params").Pick<typeof import("./constants").RELEASE_ACTION_MODEL_UID, "filters">): Promise<number>;
            update(actionId: import("../../shared/contracts/release-actions").UpdateReleaseAction.Request["params"]["actionId"], releaseId: import("../../shared/contracts/release-actions").UpdateReleaseAction.Request["params"]["releaseId"], update: import("../../shared/contracts/release-actions").UpdateReleaseAction.Request["body"]): Promise<any>;
            delete(actionId: import("../../shared/contracts/release-actions").DeleteReleaseAction.Request["params"]["actionId"], releaseId: import("../../shared/contracts/release-actions").DeleteReleaseAction.Request["params"]["releaseId"]): Promise<any>;
            validateActionsByContentTypes(contentTypeUids: import("@strapi/types/dist/uid").ContentType[]): Promise<void>;
        };
        'release-validation': ({ strapi }: {
            strapi: import("@strapi/types/dist/core").Strapi;
        }) => {
            validateUniqueEntry(releaseId: import("../../shared/contracts/release-actions").CreateReleaseAction.Request["params"]["releaseId"], releaseActionArgs: import("../../shared/contracts/release-actions").CreateReleaseAction.Request["body"]): Promise<void>;
            validateEntryData(contentTypeUid: import("../../shared/contracts/release-actions").CreateReleaseAction.Request["body"]["contentType"], entryDocumentId: import("../../shared/contracts/release-actions").CreateReleaseAction.Request["body"]["entryDocumentId"]): void;
            validatePendingReleasesLimit(): Promise<void>;
            validateUniqueNameForPendingRelease(name: import("../../shared/contracts/releases").CreateRelease.Request["body"]["name"], id?: import("../../shared/contracts/releases").UpdateRelease.Request["params"]["id"]): Promise<void>;
            validateScheduledAtIsLaterThanNow(scheduledAt: import("../../shared/contracts/releases").CreateRelease.Request["body"]["scheduledAt"]): Promise<void>;
        };
        scheduling: ({ strapi }: {
            strapi: import("@strapi/types/dist/core").Strapi;
        }) => {
            set(releaseId: import("../../shared/contracts/releases").Release["id"], scheduleDate: Date): Promise<Map<import("@strapi/types/dist/data").ID, string>>;
            cancel(releaseId: import("../../shared/contracts/releases").Release["id"]): Map<import("@strapi/types/dist/data").ID, string>;
            getAll(): Map<import("@strapi/types/dist/data").ID, string>;
            syncFromDatabase(): Promise<Map<import("@strapi/types/dist/data").ID, string>>;
        };
        settings: ({ strapi }: {
            strapi: import("@strapi/types/dist/core").Strapi;
        }) => {
            update({ settings }: {
                settings: import("../../shared/contracts/settings").Settings;
            }): Promise<import("../../shared/contracts/settings").Settings>;
            find(): Promise<import("../../shared/contracts/settings").Settings>;
        };
    };
    controllers: {
        homepage: () => {
            getUpcomingReleases(): Promise<import("../../shared/contracts/homepage").GetUpcomingReleases.Response>;
        };
        release: {
            findByDocumentAttached(ctx: import("koa").Context): Promise<void>;
            findPage(ctx: import("koa").Context): Promise<void>;
            findOne(ctx: import("koa").Context): Promise<void>;
            mapEntriesToReleases(ctx: import("koa").Context): Promise<void>;
            create(ctx: import("koa").Context): Promise<void>;
            update(ctx: import("koa").Context): Promise<void>;
            delete(ctx: import("koa").Context): Promise<void>;
            publish(ctx: import("koa").Context): Promise<void>;
        };
        'release-action': {
            create(ctx: import("koa").Context): Promise<void>;
            createMany(ctx: import("koa").Context): Promise<void>;
            findMany(ctx: import("koa").Context): Promise<void>;
            update(ctx: import("koa").Context): Promise<void>;
            delete(ctx: import("koa").Context): Promise<void>;
        };
        settings: {
            find(ctx: import("koa").Context): Promise<void>;
            update(ctx: import("koa").Context): Promise<void>;
        };
    };
    routes: {
        homepage: import("@strapi/types/dist/core").Router;
        settings: {
            type: string;
            routes: {
                method: string;
                path: string;
                handler: string;
                config: {
                    policies: (string | {
                        name: string;
                        config: {
                            actions: string[];
                        };
                    })[];
                };
            }[];
        };
        release: {
            type: string;
            routes: {
                method: string;
                path: string;
                handler: string;
                config: {
                    policies: (string | {
                        name: string;
                        config: {
                            actions: string[];
                        };
                    })[];
                };
            }[];
        };
        'release-action': {
            type: string;
            routes: {
                method: string;
                path: string;
                handler: string;
                config: {
                    policies: (string | {
                        name: string;
                        config: {
                            actions: string[];
                        };
                    })[];
                };
            }[];
        };
    };
} | {
    register: ({ strapi }: {
        strapi: import("@strapi/types/dist/core").Strapi;
    }) => Promise<void>;
    contentTypes: {
        release: {
            schema: {
                collectionName: string;
                info: {
                    singularName: string;
                    pluralName: string;
                    displayName: string;
                };
                options: {
                    draftAndPublish: boolean;
                };
                pluginOptions: {
                    'content-manager': {
                        visible: boolean;
                    };
                    'content-type-builder': {
                        visible: boolean;
                    };
                };
                attributes: {
                    name: {
                        type: string;
                        required: boolean;
                    };
                    releasedAt: {
                        type: string;
                    };
                    scheduledAt: {
                        type: string;
                    };
                    timezone: {
                        type: string;
                    };
                    status: {
                        type: string;
                        enum: string[];
                        required: boolean;
                    };
                    actions: {
                        type: string;
                        relation: string;
                        target: string;
                        mappedBy: string;
                    };
                };
            };
        };
        'release-action': {
            schema: {
                collectionName: string;
                info: {
                    singularName: string;
                    pluralName: string;
                    displayName: string;
                };
                options: {
                    draftAndPublish: boolean;
                };
                pluginOptions: {
                    'content-manager': {
                        visible: boolean;
                    };
                    'content-type-builder': {
                        visible: boolean;
                    };
                };
                attributes: {
                    type: {
                        type: string;
                        enum: string[];
                        required: boolean;
                    };
                    contentType: {
                        type: string;
                        required: boolean;
                    };
                    entryDocumentId: {
                        type: string;
                    };
                    locale: {
                        type: string;
                    };
                    release: {
                        type: string;
                        relation: string;
                        target: string;
                        inversedBy: string;
                    };
                    isEntryValid: {
                        type: string;
                    };
                };
            };
        };
    };
    bootstrap?: undefined;
    destroy?: undefined;
    services?: undefined;
    controllers?: undefined;
    routes?: undefined;
};
export default _default;
//# sourceMappingURL=index.d.ts.map