@strapi/content-releases 0.0.0-experimental.check-license → 4.16.0

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

@@ -1,4 +1,301 @@
+/// <reference types="koa" />
 declare const _default: {
-    register: () => void;
+    register: ({ strapi }: {
+        strapi: Required<import("@strapi/types").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;
+                    };
+                    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;
+                    };
+                    entry: {
+                        type: string;
+                        relation: string;
+                        configurable: boolean;
+                    };
+                    contentType: {
+                        type: string;
+                        required: boolean;
+                    };
+                    release: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        inversedBy: string;
+                    };
+                };
+            };
+        };
+    };
+    services: {
+        release: ({ strapi }: {
+            strapi: Required<import("@strapi/types").Strapi>;
+        }) => {
+            create(releaseData: {
+                name: string;
+            }, { user }: {
+                user: import("../../shared/types").UserInfo;
+            }): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string>>;
+            findOne(id: import("@strapi/types/dist/types/core/entity").ID, query?: {}): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string> | null>;
+            findPage(query?: Partial<Pick<import("../../shared/contracts/releases").Pagination, "page" | "pageSize">> | undefined): Promise<import("@strapi/types/dist/modules/entity-service").PaginatedResult<"plugin::content-releases.release", {
+                sort?: import("@strapi/types/dist/modules/entity-service/params/sort").Any<"plugin::content-releases.release"> | undefined;
+            } & {
+                fields?: import("@strapi/types/dist/modules/entity-service/params/fields").Any<"plugin::content-releases.release"> | undefined;
+            } & {
+                filters?: import("@strapi/types/dist/modules/entity-service/params/filters").Any<"plugin::content-releases.release"> | undefined;
+            } & {
+                populate?: import("@strapi/types/dist/modules/entity-service/params/populate").Any<"plugin::content-releases.release"> | undefined;
+            } & ((import("@strapi/types/dist/types/utils").Without<import("@strapi/types/dist/modules/entity-service/params/pagination").PageNotation, import("@strapi/types/dist/modules/entity-service/params/pagination").OffsetNotation> & import("@strapi/types/dist/modules/entity-service/params/pagination").OffsetNotation) | (import("@strapi/types/dist/types/utils").Without<import("@strapi/types/dist/modules/entity-service/params/pagination").OffsetNotation, import("@strapi/types/dist/modules/entity-service/params/pagination").PageNotation> & import("@strapi/types/dist/modules/entity-service/params/pagination").PageNotation)) & {
+                publicationState?: import("@strapi/types/dist/modules/entity-service/params/publication-state").Kind | undefined;
+            } & {
+                _q?: string | undefined;
+            }>>;
+            findManyForContentTypeEntry(contentTypeUid: import("@strapi/types/dist/types/core/common/uid").ContentType, entryId: import("@strapi/types/dist/types/core/entity").ID, { hasEntryAttached, }?: {
+                hasEntryAttached?: boolean | undefined;
+            }): Promise<any[]>;
+            update(id: number, releaseData: {
+                name: string;
+            }, { user }: {
+                user: import("../../shared/types").UserInfo;
+            }): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string>>;
+            createAction(releaseId: import("@strapi/types/dist/types/core/entity").ID, action: Pick<{
+                type: "publish" | "unpublish";
+                entry: {
+                    id: import("@strapi/types/dist/types/core/entity").ID;
+                    contentType: import("@strapi/types/dist/types/core/common/uid").ContentType;
+                };
+            }, "type" | "entry">): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release-action", string>>;
+            findActions(releaseId: import("@strapi/types/dist/types/core/entity").ID, query?: Partial<Pick<import("../../shared/contracts/releases").Pagination, "page" | "pageSize">> | undefined): Promise<import("@strapi/types/dist/modules/entity-service").PaginatedResult<"plugin::content-releases.release-action", {
+                populate: {
+                    entry: true;
+                };
+                filters: {
+                    release: import("@strapi/types/dist/types/core/entity").ID;
+                };
+                page?: number | undefined;
+                pageSize?: number | undefined;
+            }>>;
+            countActions(query: {
+                filters?: import("@strapi/types/dist/modules/entity-service/params/filters").Any<"plugin::content-releases.release-action"> | undefined;
+            }): Promise<number>;
+            getAllContentTypeUids(releaseId: import("@strapi/types/dist/types/core/entity").ID): Promise<(`admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`)[]>;
+            getContentTypesDataForActions(releaseId: import("@strapi/types/dist/types/core/entity").ID): Promise<Record<`admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, {
+                mainField: string;
+                displayName: string;
+            }>>;
+            delete(releaseId: import("@strapi/types/dist/types/core/entity").ID): Promise<import("../../shared/contracts/releases").Release>;
+            publish(releaseId: import("@strapi/types/dist/types/core/entity").ID): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string> | null>;
+            updateAction(actionId: import("@strapi/types/dist/types/core/entity").ID, releaseId: import("@strapi/types/dist/types/core/entity").ID, update: {
+                type: "publish" | "unpublish";
+            }): Promise<any>;
+            deleteAction(actionId: import("@strapi/types/dist/types/core/entity").ID, releaseId: import("@strapi/types/dist/types/core/entity").ID): Promise<any>;
+        };
+        'release-validation': ({ strapi }: {
+            strapi: Required<import("@strapi/types").Strapi>;
+        }) => {
+            validateUniqueEntry(releaseId: import("@strapi/types/dist/types/core/entity").ID, releaseActionArgs: {
+                type: "publish" | "unpublish";
+                entry: {
+                    id: import("@strapi/types/dist/types/core/entity").ID;
+                    contentType: import("@strapi/types/dist/types/core/common/uid").ContentType;
+                };
+            }): Promise<void>;
+            validateEntryContentType(contentTypeUid: import("@strapi/types/dist/types/core/common/uid").ContentType): void;
+        };
+    };
+    controllers: {
+        release: {
+            findMany(ctx: import("koa").Context): Promise<void>;
+            findOne(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>;
+            findMany(ctx: import("koa").Context): Promise<void>;
+            update(ctx: import("koa").Context): Promise<void>;
+            delete(ctx: import("koa").Context): Promise<void>;
+        };
+    };
+    routes: {
+        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[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+    };
+} | {
+    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;
+                    };
+                    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;
+                    };
+                    entry: {
+                        type: string;
+                        relation: string;
+                        configurable: boolean;
+                    };
+                    contentType: {
+                        type: string;
+                        required: boolean;
+                    };
+                    release: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        inversedBy: string;
+                    };
+                };
+            };
+        };
+    };
+    register?: 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,wBAA2B"}

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

@@ -1 +1,5 @@
-export declare const register: () => void;
+import type { LoadedStrapi } from '@strapi/types';
+export declare const register: ({ strapi }: {
+    strapi: LoadedStrapi;
+}) => Promise<void>;
+//# 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":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAKlD,eAAO,MAAM,QAAQ;YAAgC,YAAY;mBAOhE,CAAC"}

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

@@ -0,0 +1,35 @@
+export declare const routes: {
+    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[];
+                    };
+                })[];
+            };
+        }[];
+    };
+};
+//# 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":"AAGA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGlB,CAAC"}

package/dist/server/src/routes/release-action.d.ts

@@ -0,0 +1,18 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: (string | {
+                name: string;
+                config: {
+                    actions: string[];
+                };
+            })[];
+        };
+    }[];
+};
+export default _default;
+//# sourceMappingURL=release-action.d.ts.map

package/dist/server/src/routes/release-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-action.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/release-action.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wBAoEE"}

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

@@ -0,0 +1,18 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: (string | {
+                name: string;
+                config: {
+                    actions: string[];
+                };
+            })[];
+        };
+    }[];
+};
+export default _default;
+//# sourceMappingURL=release.d.ts.map

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

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

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

@@ -0,0 +1,77 @@
+export declare const services: {
+    release: ({ strapi }: {
+        strapi: Required<import("@strapi/types").Strapi>;
+    }) => {
+        create(releaseData: {
+            name: string;
+        }, { user }: {
+            user: import("../../../shared/types").UserInfo;
+        }): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string>>;
+        findOne(id: import("@strapi/types/dist/types/core/entity").ID, query?: {}): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string> | null>;
+        findPage(query?: Partial<Pick<import("../../../shared/contracts/releases").Pagination, "page" | "pageSize">> | undefined): Promise<import("@strapi/types/dist/modules/entity-service").PaginatedResult<"plugin::content-releases.release", {
+            sort?: import("@strapi/types/dist/modules/entity-service/params/sort").Any<"plugin::content-releases.release"> | undefined;
+        } & {
+            fields?: import("@strapi/types/dist/modules/entity-service/params/fields").Any<"plugin::content-releases.release"> | undefined;
+        } & {
+            filters?: import("@strapi/types/dist/modules/entity-service/params/filters").Any<"plugin::content-releases.release"> | undefined;
+        } & {
+            populate?: import("@strapi/types/dist/modules/entity-service/params/populate").Any<"plugin::content-releases.release"> | undefined;
+        } & ((import("@strapi/types/dist/types/utils").Without<import("@strapi/types/dist/modules/entity-service/params/pagination").PageNotation, import("@strapi/types/dist/modules/entity-service/params/pagination").OffsetNotation> & import("@strapi/types/dist/modules/entity-service/params/pagination").OffsetNotation) | (import("@strapi/types/dist/types/utils").Without<import("@strapi/types/dist/modules/entity-service/params/pagination").OffsetNotation, import("@strapi/types/dist/modules/entity-service/params/pagination").PageNotation> & import("@strapi/types/dist/modules/entity-service/params/pagination").PageNotation)) & {
+            publicationState?: import("@strapi/types/dist/modules/entity-service/params/publication-state").Kind | undefined;
+        } & {
+            _q?: string | undefined;
+        }>>;
+        findManyForContentTypeEntry(contentTypeUid: import("@strapi/types/dist/types/core/common/uid").ContentType, entryId: import("@strapi/types/dist/types/core/entity").ID, { hasEntryAttached, }?: {
+            hasEntryAttached?: boolean | undefined;
+        }): Promise<any[]>;
+        update(id: number, releaseData: {
+            name: string;
+        }, { user }: {
+            user: import("../../../shared/types").UserInfo;
+        }): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string>>;
+        createAction(releaseId: import("@strapi/types/dist/types/core/entity").ID, action: Pick<{
+            type: "publish" | "unpublish";
+            entry: {
+                id: import("@strapi/types/dist/types/core/entity").ID;
+                contentType: import("@strapi/types/dist/types/core/common/uid").ContentType;
+            };
+        }, "type" | "entry">): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release-action", string>>;
+        findActions(releaseId: import("@strapi/types/dist/types/core/entity").ID, query?: Partial<Pick<import("../../../shared/contracts/releases").Pagination, "page" | "pageSize">> | undefined): Promise<import("@strapi/types/dist/modules/entity-service").PaginatedResult<"plugin::content-releases.release-action", {
+            populate: {
+                entry: true;
+            };
+            filters: {
+                release: import("@strapi/types/dist/types/core/entity").ID;
+            };
+            page?: number | undefined;
+            pageSize?: number | undefined;
+        }>>;
+        countActions(query: {
+            filters?: import("@strapi/types/dist/modules/entity-service/params/filters").Any<"plugin::content-releases.release-action"> | undefined;
+        }): Promise<number>;
+        getAllContentTypeUids(releaseId: import("@strapi/types/dist/types/core/entity").ID): Promise<(`admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`)[]>;
+        getContentTypesDataForActions(releaseId: import("@strapi/types/dist/types/core/entity").ID): Promise<Record<`admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, {
+            mainField: string;
+            displayName: string;
+        }>>;
+        delete(releaseId: import("@strapi/types/dist/types/core/entity").ID): Promise<import("../../../shared/contracts/releases").Release>;
+        publish(releaseId: import("@strapi/types/dist/types/core/entity").ID): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string> | null>;
+        updateAction(actionId: import("@strapi/types/dist/types/core/entity").ID, releaseId: import("@strapi/types/dist/types/core/entity").ID, update: {
+            type: "publish" | "unpublish";
+        }): Promise<any>;
+        deleteAction(actionId: import("@strapi/types/dist/types/core/entity").ID, releaseId: import("@strapi/types/dist/types/core/entity").ID): Promise<any>;
+    };
+    'release-validation': ({ strapi }: {
+        strapi: Required<import("@strapi/types").Strapi>;
+    }) => {
+        validateUniqueEntry(releaseId: import("@strapi/types/dist/types/core/entity").ID, releaseActionArgs: {
+            type: "publish" | "unpublish";
+            entry: {
+                id: import("@strapi/types/dist/types/core/entity").ID;
+                contentType: import("@strapi/types/dist/types/core/common/uid").ContentType;
+            };
+        }): Promise<void>;
+        validateEntryContentType(contentTypeUid: import("@strapi/types/dist/types/core/common/uid").ContentType): void;
+    };
+};
+//# 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":"AAGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAuD,CAAC"}

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

@@ -0,0 +1,55 @@
+import type { LoadedStrapi, EntityService } from '@strapi/types';
+import { RELEASE_ACTION_MODEL_UID } from '../constants';
+import type { GetReleases, CreateRelease, UpdateRelease, PublishRelease, GetRelease, Release, DeleteRelease, GetContentTypeEntryReleases } from '../../../shared/contracts/releases';
+import type { CreateReleaseAction, GetReleaseActions, UpdateReleaseAction, DeleteReleaseAction } from '../../../shared/contracts/release-actions';
+import type { UserInfo } from '../../../shared/types';
+declare const createReleaseService: ({ strapi }: {
+    strapi: LoadedStrapi;
+}) => {
+    create(releaseData: CreateRelease.Request['body'], { user }: {
+        user: UserInfo;
+    }): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string>>;
+    findOne(id: GetRelease.Request['params']['id'], query?: {}): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string> | null>;
+    findPage(query?: GetReleases.Request['query']): Promise<EntityService.PaginatedResult<"plugin::content-releases.release", {
+        sort?: EntityService.Params.Sort.Any<"plugin::content-releases.release"> | undefined;
+    } & {
+        fields?: EntityService.Params.Fields.Any<"plugin::content-releases.release"> | undefined;
+    } & {
+        filters?: EntityService.Params.Filters.Any<"plugin::content-releases.release"> | undefined;
+    } & {
+        populate?: EntityService.Params.Populate.Any<"plugin::content-releases.release"> | undefined;
+    } & ((import("@strapi/types/dist/types/utils").Without<EntityService.Params.Pagination.PageNotation, EntityService.Params.Pagination.OffsetNotation> & EntityService.Params.Pagination.OffsetNotation) | (import("@strapi/types/dist/types/utils").Without<EntityService.Params.Pagination.OffsetNotation, EntityService.Params.Pagination.PageNotation> & EntityService.Params.Pagination.PageNotation)) & {
+        publicationState?: EntityService.Params.PublicationState.Kind | undefined;
+    } & {
+        _q?: string | undefined;
+    }>>;
+    findManyForContentTypeEntry(contentTypeUid: GetContentTypeEntryReleases.Request['query']['contentTypeUid'], entryId: GetContentTypeEntryReleases.Request['query']['entryId'], { hasEntryAttached, }?: {
+        hasEntryAttached?: GetContentTypeEntryReleases.Request['query']['hasEntryAttached'];
+    }): Promise<any[]>;
+    update(id: number, releaseData: UpdateRelease.Request['body'], { user }: {
+        user: UserInfo;
+    }): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string>>;
+    createAction(releaseId: CreateReleaseAction.Request['params']['releaseId'], action: Pick<CreateReleaseAction.Request['body'], 'type' | 'entry'>): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release-action", string>>;
+    findActions(releaseId: GetReleaseActions.Request['params']['releaseId'], query?: GetReleaseActions.Request['query']): Promise<EntityService.PaginatedResult<"plugin::content-releases.release-action", {
+        populate: {
+            entry: true;
+        };
+        filters: {
+            release: import("@strapi/types/dist/types/core/entity").ID;
+        };
+        page?: number | undefined;
+        pageSize?: number | undefined;
+    }>>;
+    countActions(query: EntityService.Params.Pick<typeof RELEASE_ACTION_MODEL_UID, 'filters'>): Promise<number>;
+    getAllContentTypeUids(releaseId: Release['id']): Promise<(`admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`)[]>;
+    getContentTypesDataForActions(releaseId: Release['id']): Promise<Record<`admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, {
+        mainField: string;
+        displayName: string;
+    }>>;
+    delete(releaseId: DeleteRelease.Request['params']['id']): Promise<Release>;
+    publish(releaseId: PublishRelease.Request['params']['id']): Promise<import("@strapi/types/dist/types/core/attributes").GetValues<"plugin::content-releases.release", string> | null>;
+    updateAction(actionId: UpdateReleaseAction.Request['params']['actionId'], releaseId: UpdateReleaseAction.Request['params']['releaseId'], update: UpdateReleaseAction.Request['body']): Promise<any>;
+    deleteAction(actionId: DeleteReleaseAction.Request['params']['actionId'], releaseId: DeleteReleaseAction.Request['params']['releaseId']): Promise<any>;
+};
+export default createReleaseService;
+//# sourceMappingURL=release.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../../../../server/src/services/release.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAO,MAAM,eAAe,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAqB,MAAM,cAAc,CAAC;AAC3E,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,aAAa,EACb,cAAc,EACd,UAAU,EACV,OAAO,EACP,aAAa,EACb,2BAA2B,EAC5B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EAEjB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD,QAAA,MAAM,oBAAoB;YAA0B,YAAY;;wBACpC,qBAAqB,CAAC,MAAM,CAAC;cAAoB,QAAQ;;gBAQjE,kBAAkB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC;qBAQnC,mBAAmB,CAAC,OAAO,CAAC;;;;;;;;;;;;;gDAa3B,mCAAmC,CAAC,OAAO,CAAC,CAAC,gBAAgB,CAAC,WACrE,mCAAmC,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC;2BAGxC,mCAAmC,CAAC,OAAO,CAAC,CAAC,kBAAkB,CAAC;;eAsEpF,MAAM,eACG,qBAAqB,CAAC,MAAM,CAAC;cACxB,QAAQ;;4BAqBf,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,UACrD,KAAK,2BAA2B,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;2BA6BxD,yBAAyB,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,UACnD,yBAAyB,CAAC,OAAO,CAAC;;;;;;;;;;wBAmBlB,cAAc,MAAM,KAAK,CAAC,+BAA+B,EAAE,SAAS,CAAC;qCAIxD,OAAO,CAAC,IAAI,CAAC;6CAiBL,OAAO,CAAC,IAAI,CAAC;mBAS3C,MAAM;qBAAe,MAAM;;sBAgBpB,qBAAqB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC;uBAiCpC,sBAAsB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC;2BAsFnD,2BAA2B,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,aAChD,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,UACrD,2BAA2B,CAAC,MAAM,CAAC;2BAoBjC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,aAChD,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC;CAiB/D,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

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

@@ -0,0 +1,10 @@
+import { LoadedStrapi } from '@strapi/types';
+import type { CreateReleaseAction } from '../../../shared/contracts/release-actions';
+declare const createReleaseValidationService: ({ strapi }: {
+    strapi: LoadedStrapi;
+}) => {
+    validateUniqueEntry(releaseId: CreateReleaseAction.Request['params']['releaseId'], releaseActionArgs: CreateReleaseAction.Request['body']): Promise<void>;
+    validateEntryContentType(contentTypeUid: CreateReleaseAction.Request['body']['entry']['contentType']): void;
+};
+export default createReleaseValidationService;
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../server/src/services/validation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAGrF,QAAA,MAAM,8BAA8B;YAA0B,YAAY;;mCAE3D,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,qBAC1C,2BAA2B,CAAC,MAAM,CAAC;6CA2BtC,2BAA2B,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,aAAa,CAAC;CAe7E,CAAC;AAEH,eAAe,8BAA8B,CAAC"}

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

@@ -0,0 +1,4 @@
+export declare const getService: (name: 'release' | 'release-validation', { strapi }?: {
+    strapi: Required<import("@strapi/types").Strapi>;
+}) => import("@strapi/types/dist/types/core/common").Service;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/utils/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,SACf,SAAS,GAAG,oBAAoB;;4DAIvC,CAAC"}