@strapi/content-manager 5.0.0-beta.6 → 5.0.0-beta.8

package/dist/server/src/controllers/collection-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collection-types.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/collection-types.ts"],"names":[],"mappings":";cA+GkB,GAAG;iBAuDA,GAAG;gBAuDJ,GAAG;gBA2BH,GAAG;eAaJ,GAAG;mBA6CC,GAAG;gBAmBN,GAAG;IAoCrB;;;OAGG;iBACgB,GAAG;qBA4CC,GAAG;uBAwCD,GAAG;mBAsCP,GAAG;iBAyDL,GAAG;oBAyCA,GAAG;6BA+BM,GAAG;wCAkCQ,GAAG;;AA5hB/C,wBA6jBE"}
+{"version":3,"file":"collection-types.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/collection-types.ts"],"names":[],"mappings":";cAgHkB,GAAG;iBAuDA,GAAG;gBAyDJ,GAAG;gBA0BH,GAAG;eAYJ,GAAG;mBA4CC,GAAG;gBAmBN,GAAG;IAoCrB;;;OAGG;iBACgB,GAAG;qBAiDC,GAAG;uBA2CD,GAAG;mBAuCP,GAAG;iBAyDL,GAAG;oBAwCA,GAAG;6BA6CM,GAAG;wCAkCQ,GAAG;;AAjjB/C,wBAklBE"}

package/dist/server/src/controllers/single-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"single-types.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/single-types.ts"],"names":[],"mappings":";cAyFkB,GAAG;wBA+CO,GAAG;gBAYX,GAAG;iBAsCF,GAAG;mBAkCD,GAAG;iBAkDL,GAAG;6BAkCS,GAAG;;AAxNpC,wBAoPE"}
+{"version":3,"file":"single-types.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/single-types.ts"],"names":[],"mappings":";cA0FkB,GAAG;wBAgDO,GAAG;gBAWX,GAAG;iBAsCF,GAAG;mBAmCD,GAAG;iBAiDL,GAAG;6BAiCS,GAAG;;AAvNpC,wBAmPE"}

package/dist/server/src/controllers/utils/metadata.d.ts

@@ -0,0 +1,8 @@
+import { UID } from '@strapi/types';
+import { DocumentVersion, GetMetadataOptions } from '../../services/document-metadata';
+/**
+ * Format a document with metadata. Making sure the metadata response is
+ * correctly sanitized for the current user
+ */
+export declare const formatDocumentWithMetadata: (permissionChecker: any, uid: UID.ContentType, document: DocumentVersion, opts?: GetMetadataOptions) => Promise<any>;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/server/src/controllers/utils/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../../../server/src/controllers/utils/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAKpC,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAOvF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,sBAClB,GAAG,OACjB,IAAI,WAAW,YACV,eAAe,SACnB,kBAAkB,iBA6BzB,CAAC"}

package/dist/server/src/controllers/validation/dimensions.d.ts

@@ -0,0 +1,9 @@
+interface Options {
+    allowMultipleLocales?: boolean;
+}
+/**
+ * From a request or query object, validates and returns the locale and status of the document
+ */
+export declare const getDocumentLocaleAndStatus: (request: any, opts?: Options) => Promise<any>;
+export {};
+//# sourceMappingURL=dimensions.d.ts.map

package/dist/server/src/controllers/validation/dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensions.d.ts","sourceRoot":"","sources":["../../../../../server/src/controllers/validation/dimensions.ts"],"names":[],"mappings":"AAEA,UAAU,OAAO;IACf,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAUD;;GAEG;AACH,eAAO,MAAM,0BAA0B,YAC5B,GAAG,SACN,OAAO,iBAiBd,CAAC"}

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

@@ -4,7 +4,7 @@ declare const validateUIDField: (contentTypeUID: any, field: any) => void;
 declare const validatePagination: ({ page, pageSize }: any) => void;
 declare const validateKind: (body: unknown, errorMessage?: string | undefined) => Promise<string | null | undefined>;
 declare const validateBulkActionInput: (body: unknown, errorMessage?: string | undefined) => Promise<import("yup/lib/object").AssertsShape<{
-    ids: import("yup/lib/array").RequiredArraySchema<yup.StrapiIDSchema, import("yup/lib/types").AnyObject, any[] | undefined>;
+    documentIds: import("yup/lib/array").RequiredArraySchema<yup.StrapiIDSchema, import("yup/lib/types").AnyObject, any[] | undefined>;
 }>>;
 declare const validateGenerateUIDInput: (body: unknown, errorMessage?: string | undefined) => Promise<import("yup/lib/object").AssertsShape<{
     contentTypeUID: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;

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

@@ -1,18 +1,16 @@
 /// <reference types="node" />
-import type { Core, Modules, Data } from '@strapi/types';
+import type { Core, Data } from '@strapi/types';
 import type { HistoryVersions } from '../../../../shared/contracts';
 import { CreateHistoryVersion, HistoryVersionDataResponse } from '../../../../shared/contracts/history-versions';
 declare const createHistoryService: ({ strapi }: {
     strapi: Core.Strapi;
 }) => {
-    bootstrap(): Promise<void>;
-    destroy(): Promise<void>;
     createVersion(historyVersionData: HistoryVersions.CreateHistoryVersion): Promise<void>;
     findVersionsPage(params: HistoryVersions.GetHistoryVersions.Request): Promise<{
         results: HistoryVersions.HistoryVersionDataResponse[];
         pagination: HistoryVersions.Pagination;
     }>;
-    restoreVersion(versionId: Data.ID): Promise<Modules.Documents.AnyDocument>;
+    restoreVersion(versionId: Data.ID): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
 };
 export { createHistoryService };
 //# sourceMappingURL=history.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../../../server/src/history/services/history.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAO,IAAI,EAAkB,MAAM,eAAe,CAAC;AAO9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC3B,MAAM,+CAA+C,CAAC;AAUvD,QAAA,MAAM,oBAAoB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;;sCA+NrB,oCAAoC;6BAU7C,gBAAgB,kBAAkB,QAAQ,GAAG,QAAQ;QAClF,OAAO,EAAE,0CAA0C,EAAE,CAAC;QACtD,UAAU,EAAE,gBAAgB,UAAU,CAAC;KACxC,CAAC;8BAoN8B,KAAK,EAAE;CA6G1C,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../../../server/src/history/services/history.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAkB,MAAM,eAAe,CAAC;AAKhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC3B,MAAM,+CAA+C,CAAC;AAQvD,QAAA,MAAM,oBAAoB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;sCAKrB,oCAAoC;6BAU7C,gBAAgB,kBAAkB,QAAQ,GAAG,QAAQ;QAClF,OAAO,EAAE,0CAA0C,EAAE,CAAC;QACtD,UAAU,EAAE,gBAAgB,UAAU,CAAC;KACxC,CAAC;8BAsI8B,KAAK,EAAE;CAqE1C,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

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

@@ -2,8 +2,6 @@ export declare const services: {
     history: ({ strapi }: {
         strapi: import("@strapi/types/dist/core").Strapi;
     }) => {
-        bootstrap(): Promise<void>;
-        destroy(): Promise<void>;
         createVersion(historyVersionData: import("../../../../shared/contracts/history-versions").CreateHistoryVersion): Promise<void>;
         findVersionsPage(params: import("../../../../shared/contracts/history-versions").GetHistoryVersions.Request): Promise<{
             results: import("../../../../shared/contracts/history-versions").HistoryVersionDataResponse[];
@@ -11,5 +9,11 @@ export declare const services: {
         }>;
         restoreVersion(versionId: import("@strapi/types/dist/data").ID): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
     };
+    lifecycles: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        bootstrap(): Promise<void>;
+        destroy(): Promise<void>;
+    };
 };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/history/services/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;CAEsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/history/services/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;CAGsB,CAAC"}

package/dist/server/src/history/services/lifecycles.d.ts

@@ -0,0 +1,9 @@
+import type { Core } from '@strapi/types';
+declare const createLifecyclesService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    bootstrap(): Promise<void>;
+    destroy(): Promise<void>;
+};
+export { createLifecyclesService };
+//# sourceMappingURL=lifecycles.d.ts.map

package/dist/server/src/history/services/lifecycles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycles.d.ts","sourceRoot":"","sources":["../../../../../server/src/history/services/lifecycles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAW,MAAM,eAAe,CAAC;AAYnD,QAAA,MAAM,uBAAuB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;;CAwInE,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/server/src/history/services/utils.d.ts

@@ -1,12 +1,44 @@
-import type { Struct } from '@strapi/types';
+import type { Struct, UID } from '@strapi/types';
+import { Core, Data, Modules, Schema } from '@strapi/types';
 import { CreateHistoryVersion } from '../../../../shared/contracts/history-versions';
-/**
- * @description
- * Get the difference between the version schema and the content type schema
- * @returns the attributes with their original shape
- */
-export declare const getSchemaAttributesDiff: (versionSchemaAttributes: CreateHistoryVersion['schema'], contentTypeSchemaAttributes: Struct.SchemaAttributes) => {
-    added: Struct.SchemaAttributes;
-    removed: Struct.SchemaAttributes;
+import { HistoryVersions } from '../../../../shared/contracts';
+import { RelationResult } from '../../../../shared/contracts/relations';
+type RelationResponse = {
+    results: RelationResult[];
+    meta: {
+        missingCount: number;
+    };
 };
+export declare const createServiceUtils: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getSchemaAttributesDiff: (versionSchemaAttributes: CreateHistoryVersion['schema'], contentTypeSchemaAttributes: Struct.SchemaAttributes) => {
+        added: Struct.SchemaAttributes;
+        removed: Struct.SchemaAttributes;
+    };
+    getRelationRestoreValue: (versionRelationData: Data.Entity, attribute: Schema.Attribute.RelationWithTarget) => Promise<Modules.Documents.AnyDocument | Modules.Documents.AnyDocument[] | ({
+        id: Data.ID;
+    } & Pick<{
+        [x: string]: any;
+    }, string> & any[]) | null>;
+    getMediaRestoreValue: (versionRelationData: Data.Entity, attribute: Schema.Attribute.Media<any, boolean>) => Promise<any>;
+    getDefaultLocale: () => Promise<any>;
+    getLocaleDictionary: () => Promise<{
+        [key: string]: {
+            name: string;
+            code: string;
+        };
+    }>;
+    getRetentionDays: () => number;
+    getVersionStatus: (contentTypeUid: HistoryVersions.CreateHistoryVersion['contentType'], document: Modules.Documents.AnyDocument | null) => Promise<any>;
+    getDeepPopulate: (uid: UID.Schema) => any;
+    buildMediaResponse: (values: {
+        id: Data.ID;
+    }[]) => Promise<RelationResponse>;
+    buildRelationReponse: (values: {
+        documentId: string;
+        locale: string | null;
+    }[], attributeSchema: Schema.Attribute.RelationWithTarget) => Promise<RelationResponse>;
+};
+export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/server/src/history/services/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../server/src/history/services/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,+CAA+C,CAAC;AAGrF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,4BACT,oBAAoB,CAAC,QAAQ,CAAC,+BAC1B,OAAO,gBAAgB;;;CA6BrD,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../server/src/history/services/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,+CAA+C,CAAC;AAErF,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAIxE,KAAK,gBAAgB,GAAG;IACtB,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,IAAI,EAAE;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;CAChC,CAAC;AAEF,eAAO,MAAM,kBAAkB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;uDAMzC,oBAAoB,CAAC,QAAQ,CAAC,+BAC1B,OAAO,gBAAgB;;;;mDA4C/B,KAAK,MAAM,aACrB,OAAO,SAAS,CAAC,kBAAkB;;;;;gDAgCzB,KAAK,MAAM,aACrB,OAAO,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC;;+BA2BX,QAAQ;QAC5C,CAAC,GAAG,EAAE,MAAM,GAAG;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC;KAC/C,CAAC;;uCAsCgB,oCAAoC,CAAC,aAAa,CAAC,YACzD,QAAQ,SAAS,CAAC,WAAW,GAAG,IAAI;2BAalB,IAAI,MAAM;iCAkDE;QAAE,EAAE,EAAE,KAAK,EAAE,CAAA;KAAE,EAAE,KAAG,QAAQ,gBAAgB,CAAC;mCAwC7E;QACN,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;KACvB,EAAE,mBACc,OAAO,SAAS,CAAC,kBAAkB,KACnD,QAAQ,gBAAgB,CAAC;CAkD7B,CAAC"}

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

@@ -4,8 +4,6 @@ declare function getService<T extends keyof HistoryServices>(strapi: Core.Strapi
     history: ({ strapi }: {
         strapi: Core.Strapi;
     }) => {
-        bootstrap(): Promise<void>;
-        destroy(): Promise<void>;
         createVersion(historyVersionData: import("../../../shared/contracts/history-versions").CreateHistoryVersion): Promise<void>;
         findVersionsPage(params: import("../../../shared/contracts/history-versions").GetHistoryVersions.Request): Promise<{
             results: import("../../../shared/contracts/history-versions").HistoryVersionDataResponse[];
@@ -13,6 +11,12 @@ declare function getService<T extends keyof HistoryServices>(strapi: Core.Strapi
         }>;
         restoreVersion(versionId: import("@strapi/types/dist/data").ID): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
     };
+    lifecycles: ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => {
+        bootstrap(): Promise<void>;
+        destroy(): Promise<void>;
+    };
 }[T]>;
 export { getService };
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../server/src/history/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,KAAK,eAAe,GAAG,cAAc,YAAY,EAAE,QAAQ,CAAC;AAE5D,iBAAS,UAAU,CAAC,CAAC,SAAS,MAAM,eAAe,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC;;;;;;;;;;;;;MAGhF;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../server/src/history/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,KAAK,eAAe,GAAG,cAAc,YAAY,EAAE,QAAQ,CAAC;AAE5D,iBAAS,UAAU,CAAC,CAAC,SAAS,MAAM,eAAe,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC;;;;;;;;;;;;;;;;;MAGhF;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

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

@@ -167,46 +167,25 @@ declare const _default: () => {
         'document-metadata': ({ strapi }: {
             strapi: import("@strapi/types/dist/core").Strapi;
         }) => {
-            getAvailableLocales(uid: import("@strapi/types/dist/uid").ContentType, version: import("./services/document-metadata").DocumentVersion, allVersions: import("./services/document-metadata").DocumentVersion[]): (Partial<import("./services/document-metadata").DocumentVersion> | {
-                status: string;
-                id?: string | undefined;
-                documentId?: string | undefined;
-                locale?: string | undefined;
-                updatedAt?: string | Date | null | undefined;
-                publishedAt?: string | Date | null | undefined;
-            } | undefined)[];
+            getAvailableLocales(uid: import("@strapi/types/dist/uid").ContentType, version: import("./services/document-metadata").DocumentVersion, allVersions: import("./services/document-metadata").DocumentVersion[], validatableFields?: string[]): Promise<import("../../shared/contracts/collection-types").AvailableLocaleDocument[]>;
             getAvailableStatus(version: import("./services/document-metadata").DocumentVersion, allVersions: import("./services/document-metadata").DocumentVersion[]): Partial<import("./services/document-metadata").DocumentVersion> | undefined;
-            getManyAvailableStatus(uid: import("@strapi/types/dist/uid").ContentType, documents: import("./services/document-metadata").DocumentVersion[]): Promise<Pick<import("@strapi/types/dist/modules/documents").AnyDocument, "id" | ("createdAt" | "updatedAt" | "publishedAt") | ("createdBy" | "updatedBy" | "publishedBy")>[]>;
-            getStatus(version: import("./services/document-metadata").DocumentVersion, otherDocumentStatuses?: Pick<import("@strapi/types/dist/modules/documents").AnyDocument, "id" | ("createdAt" | "updatedAt" | "publishedAt") | ("createdBy" | "updatedBy" | "publishedBy")>[] | undefined): string;
+            getManyAvailableStatus(uid: import("@strapi/types/dist/uid").ContentType, documents: import("./services/document-metadata").DocumentVersion[]): Promise<import("../../shared/contracts/collection-types").AvailableStatusDocument[]>;
+            getStatus(version: import("./services/document-metadata").DocumentVersion, otherDocumentStatuses?: import("../../shared/contracts/collection-types").AvailableStatusDocument[] | undefined): string;
             getMetadata(uid: import("@strapi/types/dist/uid").ContentType, version: import("./services/document-metadata").DocumentVersion, { availableLocales, availableStatus }?: import("./services/document-metadata").GetMetadataOptions): Promise<{
-                availableLocales: (Partial<import("./services/document-metadata").DocumentVersion> | {
-                    status: string;
-                    id?: string | undefined;
-                    documentId?: string | undefined;
-                    locale?: string | undefined;
-                    updatedAt?: string | Date | null | undefined;
-                    publishedAt?: string | Date | null | undefined;
-                } | undefined)[];
+                availableLocales: import("../../shared/contracts/collection-types").AvailableLocaleDocument[];
                 availableStatus: Partial<import("./services/document-metadata").DocumentVersion>[];
             }>;
             formatDocumentWithMetadata(uid: import("@strapi/types/dist/uid").ContentType, document: import("./services/document-metadata").DocumentVersion, opts?: import("./services/document-metadata").GetMetadataOptions): Promise<{
                 data: {
                     status: string | undefined;
-                    id: string;
+                    id: number;
                     documentId: string;
                     locale: string;
                     updatedAt: string | Date | null;
                     publishedAt: string | Date | null;
                 };
                 meta: {
-                    availableLocales: (Partial<import("./services/document-metadata").DocumentVersion> | {
-                        status: string;
-                        id?: string | undefined;
-                        documentId?: string | undefined;
-                        locale?: string | undefined;
-                        updatedAt?: string | Date | null | undefined;
-                        publishedAt?: string | Date | null | undefined;
-                    } | undefined)[];
+                    availableLocales: import("../../shared/contracts/collection-types").AvailableLocaleDocument[];
                     availableStatus: Partial<import("./services/document-metadata").DocumentVersion>[];
                 };
             }>;
@@ -215,37 +194,37 @@ declare const _default: () => {
             strapi: import("@strapi/types/dist/core").Strapi;
         }) => {
             findOne(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").FindOne<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
-            findLocales(id: string | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts: {
+            findLocales(id: string | string[] | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts: {
                 populate?: {
                     populate?: import("@strapi/types/dist/modules/documents/params/populate").Any<any> | undefined;
                 } | undefined;
                 locale?: string | string[] | undefined;
+                isPublished?: boolean | undefined;
             }): Promise<any[]>;
             findMany(opts: import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
             findPage(opts: import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<{
                 results: import("@strapi/types/dist/modules/documents").AnyDocument[];
-                pagination: {
-                    page: number;
-                    pageSize: number;
-                    pageCount: number;
-                    total: number;
-                };
+                pagination: import("@strapi/utils/dist/pagination").PagePatinationInformation;
             }>;
             create(uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: import("@strapi/types/dist/modules/documents/params/document-engine").Create<import("@strapi/types/dist/uid").ContentType>): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
             update(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Update<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
             clone(id: string, body: Partial<import("@strapi/types/dist/modules/documents/params/data").Input<`admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`>>, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
             exists(uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, id?: string | undefined): Promise<boolean>;
             delete(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Delete<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<{}>;
-            deleteMany(opts: import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<{
+            deleteMany(documentIds: string[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: (import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined) & {
+                locale?: string | undefined;
+            }): Promise<{
+                count: number;
+            }>;
+            publish(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Publish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+            publishMany(uid: import("@strapi/types/dist/uid").ContentType, documentIds: string[], locale?: string | string[] | undefined): Promise<number>;
+            unpublishMany(documentIds: string[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Unpublish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<{
                 count: number;
             }>;
-            publish(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Publish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
-            publishMany(entities: import("@strapi/types/dist/modules/documents").AnyDocument[], uid: import("@strapi/types/dist/uid").ContentType): Promise<import("@strapi/database/dist/types").CountResult | null>;
-            unpublishMany(documents: import("@strapi/types/dist/modules/documents").AnyDocument[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<import("@strapi/database/dist/types").CountResult | null>;
             unpublish(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Unpublish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
             discardDraft(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").DiscardDraft<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
             countDraftRelations(id: string, uid: import("@strapi/types/dist/uid").ContentType, locale: string): Promise<number>;
-            countManyEntriesDraftRelations(ids: number[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, locale: string): Promise<number>;
+            countManyEntriesDraftRelations(documentIds: string[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, locale: string | string[]): Promise<number>;
         };
         'field-sizes': ({ strapi }: {
             strapi: import("@strapi/types/dist/core").Strapi;

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

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

package/dist/server/src/services/document-manager.d.ts

@@ -1,3 +1,4 @@
+import { pagination } from '@strapi/utils';
 import type { Core, Modules, UID } from '@strapi/types';
 type DocService = Modules.Documents.ServiceInstance;
 type DocServiceParams<TAction extends keyof DocService> = Parameters<DocService[TAction]>[0];
@@ -9,19 +10,15 @@ declare const documentManager: ({ strapi }: {
     /**
      * Find multiple (or all) locales for a document
      */
-    findLocales(id: string | undefined, uid: UID.CollectionType, opts: {
+    findLocales(id: string | string[] | undefined, uid: UID.CollectionType, opts: {
         populate?: Modules.Documents.Params.Pick<any, 'populate'>;
         locale?: string | string[] | '*';
+        isPublished?: boolean;
     }): Promise<any[]>;
     findMany(opts: DocServiceParams<'findMany'>, uid: UID.CollectionType): Promise<Modules.Documents.AnyDocument[]>;
     findPage(opts: DocServiceParams<'findMany'>, uid: UID.CollectionType): Promise<{
         results: Modules.Documents.AnyDocument[];
-        pagination: {
-            page: number;
-            pageSize: number;
-            pageCount: number;
-            total: number;
-        };
+        pagination: pagination.PagePatinationInformation;
     }>;
     create(uid: UID.CollectionType, opts?: DocServiceParams<'create'>): Promise<Modules.Documents.AnyDocument>;
     update(id: Modules.Documents.ID, uid: UID.CollectionType, opts?: Omit<DocServiceParams<'update'>, 'documentId'>): Promise<Modules.Documents.AnyDocument | null>;
@@ -31,16 +28,20 @@ declare const documentManager: ({ strapi }: {
      */
     exists(uid: UID.CollectionType, id?: string): Promise<boolean>;
     delete(id: Modules.Documents.ID, uid: UID.CollectionType, opts?: Omit<DocServiceParams<'delete'>, 'documentId'>): Promise<{}>;
-    deleteMany(opts: DocServiceParams<'findMany'>, uid: UID.CollectionType): Promise<{
+    deleteMany(documentIds: Modules.Documents.ID[], uid: UID.CollectionType, opts?: DocServiceParams<'findMany'> & {
+        locale?: string;
+    }): Promise<{
+        count: number;
+    }>;
+    publish(id: Modules.Documents.ID, uid: UID.CollectionType, opts?: Omit<DocServiceParams<'publish'>, 'documentId'>): Promise<Modules.Documents.AnyDocument[]>;
+    publishMany(uid: UID.ContentType, documentIds: string[], locale?: string | string[]): Promise<number>;
+    unpublishMany(documentIds: Modules.Documents.ID[], uid: UID.CollectionType, opts?: Omit<DocServiceParams<'unpublish'>, 'documentId'>): Promise<{
         count: number;
     }>;
-    publish(id: Modules.Documents.ID, uid: UID.CollectionType, opts?: Omit<DocServiceParams<'publish'>, 'documentId'>): Promise<Modules.Documents.AnyDocument | undefined>;
-    publishMany(entities: Document[], uid: UID.ContentType): Promise<import("@strapi/database/dist/types").CountResult | null>;
-    unpublishMany(documents: Document[], uid: UID.CollectionType): Promise<import("@strapi/database/dist/types").CountResult | null>;
     unpublish(id: Modules.Documents.ID, uid: UID.CollectionType, opts?: Omit<DocServiceParams<'unpublish'>, 'documentId'>): Promise<Modules.Documents.AnyDocument | undefined>;
     discardDraft(id: Modules.Documents.ID, uid: UID.CollectionType, opts?: Omit<DocServiceParams<'discardDraft'>, 'documentId'>): Promise<Modules.Documents.AnyDocument | undefined>;
     countDraftRelations(id: string, uid: UID.ContentType, locale: string): Promise<number>;
-    countManyEntriesDraftRelations(ids: number[], uid: UID.CollectionType, locale: string): Promise<number>;
+    countManyEntriesDraftRelations(documentIds: Modules.Documents.ID[], uid: UID.CollectionType, locale: string | string[]): Promise<number>;
 };
 export type DocumentManagerService = typeof documentManager;
 export default documentManager;

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

@@ -1 +1 @@
-{"version":3,"file":"document-manager.d.ts","sourceRoot":"","sources":["../../../../server/src/services/document-manager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAMxD,KAAK,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC;AACpD,KAAK,gBAAgB,CAAC,OAAO,SAAS,MAAM,UAAU,IAAI,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7F,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;AA2BjE,QAAA,MAAM,eAAe,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;gBAGlD,MAAM,OACL,IAAI,cAAc,SACjB,KAAK,iBAAiB,SAAS,CAAC,EAAE,YAAY,CAAC;IAKvD;;OAEG;oBAEG,MAAM,GAAG,SAAS,OACjB,IAAI,cAAc,QACjB;QACJ,QAAQ,CAAC,EAAE,QAAQ,SAAS,CAAC,MAAM,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAC1D,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,GAAG,CAAC;KAClC;mBAqBkB,iBAAiB,UAAU,CAAC,OAAO,IAAI,cAAc;mBAKrD,iBAAiB,UAAU,CAAC,OAAO,IAAI,cAAc;;;;;;;;;gBAqBxD,IAAI,cAAc,SAAQ,iBAAiB,QAAQ,CAAC;eAQhE,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,QAAQ,CAAC,EAAE,YAAY,CAAC;cAUhD,QAAQ,SAAS,CAAC,EAAE,QAClB,QAAQ,QAAQ,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,cAAc,CAAC,CAAC,OACjE,IAAI,cAAc;IAiBzB;;OAEG;gBACe,IAAI,cAAc,OAAO,MAAM;eAa3C,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,QAAQ,CAAC,EAAE,YAAY,CAAC;qBAa/B,iBAAiB,UAAU,CAAC,OAAO,IAAI,cAAc;;;gBAWtE,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,SAAS,CAAC,EAAE,YAAY,CAAC;0BAW3B,QAAQ,EAAE,OAAO,IAAI,WAAW;6BA8C7B,QAAQ,EAAE,OAAO,IAAI,cAAc;kBAoC5D,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,WAAW,CAAC,EAAE,YAAY,CAAC;qBAYnD,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,cAAc,CAAC,EAAE,YAAY,CAAC;4BAW9B,MAAM,OAAO,IAAI,WAAW,UAAU,MAAM;wCAehC,MAAM,EAAE,OAAO,IAAI,cAAc,UAAU,MAAM;CAuB9F,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,eAAe,CAAC;AAE5D,eAAe,eAAe,CAAC"}
+{"version":3,"file":"document-manager.d.ts","sourceRoot":"","sources":["../../../../server/src/services/document-manager.ts"],"names":[],"mappings":"AAEA,OAAO,EAAwB,UAAU,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAKxD,KAAK,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC;AACpD,KAAK,gBAAgB,CAAC,OAAO,SAAS,MAAM,UAAU,IAAI,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7F,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;AAQjE,QAAA,MAAM,eAAe,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;gBAGlD,MAAM,OACL,IAAI,cAAc,SACjB,KAAK,iBAAiB,SAAS,CAAC,EAAE,YAAY,CAAC;IAKvD;;OAEG;oBAEG,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,OAC5B,IAAI,cAAc,QACjB;QACJ,QAAQ,CAAC,EAAE,QAAQ,SAAS,CAAC,MAAM,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAC1D,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,GAAG,CAAC;QACjC,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;mBA0BkB,iBAAiB,UAAU,CAAC,OAAO,IAAI,cAAc;mBAKrD,iBAAiB,UAAU,CAAC,OAAO,IAAI,cAAc;;;;gBAgBxD,IAAI,cAAc,SAAQ,iBAAiB,QAAQ,CAAC;eAQhE,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,QAAQ,CAAC,EAAE,YAAY,CAAC;cAUhD,QAAQ,SAAS,CAAC,EAAE,QAClB,QAAQ,QAAQ,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,cAAc,CAAC,CAAC,OACjE,IAAI,cAAc;IAiBzB;;OAEG;gBACe,IAAI,cAAc,OAAO,MAAM;eAa3C,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,QAAQ,CAAC,EAAE,YAAY,CAAC;4BAcvC,QAAQ,SAAS,CAAC,EAAE,EAAE,OAC9B,IAAI,cAAc,SACjB,iBAAiB,UAAU,CAAC,GAAG;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;;;gBAUpD,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,SAAS,CAAC,EAAE,YAAY,CAAC;qBAWhC,IAAI,WAAW,eAAe,MAAM,EAAE,WAAW,MAAM,GAAG,MAAM,EAAE;+BAY1E,QAAQ,SAAS,CAAC,EAAE,EAAE,OAC9B,IAAI,cAAc,SACjB,KAAK,iBAAiB,WAAW,CAAC,EAAE,YAAY,CAAC;;;kBAoBnD,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,WAAW,CAAC,EAAE,YAAY,CAAC;qBAYnD,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,cAAc,CAAC,EAAE,YAAY,CAAC;4BAW9B,MAAM,OAAO,IAAI,WAAW,UAAU,MAAM;gDAiB3D,QAAQ,SAAS,CAAC,EAAE,EAAE,OAC9B,IAAI,cAAc,UACf,MAAM,GAAG,MAAM,EAAE;CA6B9B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,eAAe,CAAC;AAE5D,eAAe,eAAe,CAAC"}

package/dist/server/src/services/document-metadata.d.ts

@@ -1,8 +1,8 @@
-import type { Core, UID } from '@strapi/types';
+import type { Core, UID, Modules } from '@strapi/types';
 import type { DocumentMetadata } from '../../../shared/contracts/collection-types';
 export interface DocumentVersion {
-    id: string;
-    documentId: string;
+    id: number;
+    documentId: Modules.Documents.ID;
     locale: string;
     updatedAt: string | null | Date;
     publishedAt: string | null | Date;
@@ -26,14 +26,7 @@ declare const _default: ({ strapi }: {
     /**
      * Returns available locales of a document for the current status
      */
-    getAvailableLocales(uid: UID.ContentType, version: DocumentVersion, allVersions: DocumentVersion[]): (Partial<DocumentVersion> | {
-        status: string;
-        id?: string | undefined;
-        documentId?: string | undefined;
-        locale?: string | undefined;
-        updatedAt?: string | Date | null | undefined;
-        publishedAt?: string | Date | null | undefined;
-    } | undefined)[];
+    getAvailableLocales(uid: UID.ContentType, version: DocumentVersion, allVersions: DocumentVersion[], validatableFields?: string[]): Promise<import("../../../shared/contracts/collection-types").AvailableLocaleDocument[]>;
     /**
      * Returns available status of a document for the current locale
      */
@@ -44,17 +37,10 @@ declare const _default: ({ strapi }: {
      * @param documents
      * @returns
      */
-    getManyAvailableStatus(uid: UID.ContentType, documents: DocumentVersion[]): Promise<Pick<import("@strapi/types/dist/modules/documents").AnyDocument, "id" | ("createdAt" | "updatedAt" | "publishedAt") | ("createdBy" | "updatedBy" | "publishedBy")>[]>;
+    getManyAvailableStatus(uid: UID.ContentType, documents: DocumentVersion[]): Promise<import("../../../shared/contracts/collection-types").AvailableStatusDocument[]>;
     getStatus(version: DocumentVersion, otherDocumentStatuses?: DocumentMetadata['availableStatus']): string;
     getMetadata(uid: UID.ContentType, version: DocumentVersion, { availableLocales, availableStatus }?: GetMetadataOptions): Promise<{
-        availableLocales: (Partial<DocumentVersion> | {
-            status: string;
-            id?: string | undefined;
-            documentId?: string | undefined;
-            locale?: string | undefined;
-            updatedAt?: string | Date | null | undefined;
-            publishedAt?: string | Date | null | undefined;
-        } | undefined)[];
+        availableLocales: import("../../../shared/contracts/collection-types").AvailableLocaleDocument[];
         availableStatus: Partial<DocumentVersion>[];
     }>;
     /**
@@ -65,21 +51,14 @@ declare const _default: ({ strapi }: {
     formatDocumentWithMetadata(uid: UID.ContentType, document: DocumentVersion, opts?: GetMetadataOptions): Promise<{
         data: {
             status: string | undefined;
-            id: string;
+            id: number;
             documentId: string;
             locale: string;
             updatedAt: string | Date | null;
             publishedAt: string | Date | null;
         };
         meta: {
-            availableLocales: (Partial<DocumentVersion> | {
-                status: string;
-                id?: string | undefined;
-                documentId?: string | undefined;
-                locale?: string | undefined;
-                updatedAt?: string | Date | null | undefined;
-                publishedAt?: string | Date | null | undefined;
-            } | undefined)[];
+            availableLocales: import("../../../shared/contracts/collection-types").AvailableLocaleDocument[];
             availableStatus: Partial<DocumentVersion>[];
         };
     }>;

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

@@ -1 +1 @@
-{"version":3,"file":"document-metadata.d.ts","sourceRoot":"","sources":["../../../../server/src/services/document-metadata.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAEnF,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;CACnC;AA4CD;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;qCAE2B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;IACjD;;OAEG;6BAEI,IAAI,WAAW,WACX,eAAe,eACX,eAAe,EAAE;;;;;;;;IAgChC;;OAEG;gCACyB,eAAe,eAAe,eAAe,EAAE;IAmB3E;;;;;OAKG;gCAC+B,IAAI,WAAW,aAAa,eAAe,EAAE;uBAkB5D,eAAe,0BAA0B,gBAAgB,CAAC,iBAAiB,CAAC;qBA0BxF,IAAI,WAAW,WACX,eAAe,0CAC6B,kBAAkB;;;;;;;;;;;IA+BzE;;;;OAIG;oCAEI,IAAI,WAAW,YACV,eAAe,SACnB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;AAxJ5B,wBAiLG"}
+{"version":3,"file":"document-metadata.d.ts","sourceRoot":"","sources":["../../../../server/src/services/document-metadata.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAGnF,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;CACnC;AA4BD;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;qCAoB2B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;IACjD;;OAEG;6BAEI,IAAI,WAAW,WACX,eAAe,eACX,eAAe,EAAE,sBACX,MAAM,EAAE;IA+D7B;;OAEG;gCACyB,eAAe,eAAe,eAAe,EAAE;IAmB3E;;;;;OAKG;gCAC+B,IAAI,WAAW,aAAa,eAAe,EAAE;uBAkB5D,eAAe,0BAA0B,gBAAgB,CAAC,iBAAiB,CAAC;qBAgCxF,IAAI,WAAW,WACX,eAAe,0CAC6B,kBAAkB;;;;IAkCzE;;;;OAIG;oCAEI,IAAI,WAAW,YACV,eAAe,SACnB,kBAAkB;;;;;;;;;;;;;;;AAjM5B,wBA2NG"}

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

@@ -60,46 +60,25 @@ declare const _default: {
     'document-metadata': ({ strapi }: {
         strapi: import("@strapi/types/dist/core").Strapi;
     }) => {
-        getAvailableLocales(uid: import("@strapi/types/dist/uid").ContentType, version: import("./document-metadata").DocumentVersion, allVersions: import("./document-metadata").DocumentVersion[]): (Partial<import("./document-metadata").DocumentVersion> | {
-            status: string;
-            id?: string | undefined;
-            documentId?: string | undefined;
-            locale?: string | undefined;
-            updatedAt?: string | Date | null | undefined;
-            publishedAt?: string | Date | null | undefined;
-        } | undefined)[];
+        getAvailableLocales(uid: import("@strapi/types/dist/uid").ContentType, version: import("./document-metadata").DocumentVersion, allVersions: import("./document-metadata").DocumentVersion[], validatableFields?: string[]): Promise<import("../../../shared/contracts/collection-types").AvailableLocaleDocument[]>;
         getAvailableStatus(version: import("./document-metadata").DocumentVersion, allVersions: import("./document-metadata").DocumentVersion[]): Partial<import("./document-metadata").DocumentVersion> | undefined;
-        getManyAvailableStatus(uid: import("@strapi/types/dist/uid").ContentType, documents: import("./document-metadata").DocumentVersion[]): Promise<Pick<import("@strapi/types/dist/modules/documents").AnyDocument, "id" | ("createdAt" | "updatedAt" | "publishedAt") | ("createdBy" | "updatedBy" | "publishedBy")>[]>;
-        getStatus(version: import("./document-metadata").DocumentVersion, otherDocumentStatuses?: Pick<import("@strapi/types/dist/modules/documents").AnyDocument, "id" | ("createdAt" | "updatedAt" | "publishedAt") | ("createdBy" | "updatedBy" | "publishedBy")>[] | undefined): string;
+        getManyAvailableStatus(uid: import("@strapi/types/dist/uid").ContentType, documents: import("./document-metadata").DocumentVersion[]): Promise<import("../../../shared/contracts/collection-types").AvailableStatusDocument[]>;
+        getStatus(version: import("./document-metadata").DocumentVersion, otherDocumentStatuses?: import("../../../shared/contracts/collection-types").AvailableStatusDocument[] | undefined): string;
         getMetadata(uid: import("@strapi/types/dist/uid").ContentType, version: import("./document-metadata").DocumentVersion, { availableLocales, availableStatus }?: import("./document-metadata").GetMetadataOptions): Promise<{
-            availableLocales: (Partial<import("./document-metadata").DocumentVersion> | {
-                status: string;
-                id?: string | undefined;
-                documentId?: string | undefined;
-                locale?: string | undefined;
-                updatedAt?: string | Date | null | undefined;
-                publishedAt?: string | Date | null | undefined;
-            } | undefined)[];
+            availableLocales: import("../../../shared/contracts/collection-types").AvailableLocaleDocument[];
             availableStatus: Partial<import("./document-metadata").DocumentVersion>[];
         }>;
         formatDocumentWithMetadata(uid: import("@strapi/types/dist/uid").ContentType, document: import("./document-metadata").DocumentVersion, opts?: import("./document-metadata").GetMetadataOptions): Promise<{
             data: {
                 status: string | undefined;
-                id: string;
+                id: number;
                 documentId: string;
                 locale: string;
                 updatedAt: string | Date | null;
                 publishedAt: string | Date | null;
             };
             meta: {
-                availableLocales: (Partial<import("./document-metadata").DocumentVersion> | {
-                    status: string;
-                    id?: string | undefined;
-                    documentId?: string | undefined;
-                    locale?: string | undefined;
-                    updatedAt?: string | Date | null | undefined;
-                    publishedAt?: string | Date | null | undefined;
-                } | undefined)[];
+                availableLocales: import("../../../shared/contracts/collection-types").AvailableLocaleDocument[];
                 availableStatus: Partial<import("./document-metadata").DocumentVersion>[];
             };
         }>;
@@ -108,37 +87,37 @@ declare const _default: {
         strapi: import("@strapi/types/dist/core").Strapi;
     }) => {
         findOne(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").FindOne<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
-        findLocales(id: string | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts: {
+        findLocales(id: string | string[] | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts: {
             populate?: {
                 populate?: import("@strapi/types/dist/modules/documents/params/populate").Any<any> | undefined;
             } | undefined;
             locale?: string | string[] | undefined;
+            isPublished?: boolean | undefined;
         }): Promise<any[]>;
         findMany(opts: import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
         findPage(opts: import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<{
             results: import("@strapi/types/dist/modules/documents").AnyDocument[];
-            pagination: {
-                page: number;
-                pageSize: number;
-                pageCount: number;
-                total: number;
-            };
+            pagination: import("@strapi/utils/dist/pagination").PagePatinationInformation;
         }>;
         create(uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: import("@strapi/types/dist/modules/documents/params/document-engine").Create<import("@strapi/types/dist/uid").ContentType>): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
         update(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Update<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
         clone(id: string, body: Partial<import("@strapi/types/dist/modules/documents/params/data").Input<`admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`>>, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
         exists(uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, id?: string | undefined): Promise<boolean>;
         delete(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Delete<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<{}>;
-        deleteMany(opts: import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<{
+        deleteMany(documentIds: string[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: (import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined) & {
+            locale?: string | undefined;
+        }): Promise<{
+            count: number;
+        }>;
+        publish(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Publish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+        publishMany(uid: import("@strapi/types/dist/uid").ContentType, documentIds: string[], locale?: string | string[] | undefined): Promise<number>;
+        unpublishMany(documentIds: string[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Unpublish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<{
             count: number;
         }>;
-        publish(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Publish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
-        publishMany(entities: import("@strapi/types/dist/modules/documents").AnyDocument[], uid: import("@strapi/types/dist/uid").ContentType): Promise<import("@strapi/database/dist/types").CountResult | null>;
-        unpublishMany(documents: import("@strapi/types/dist/modules/documents").AnyDocument[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<import("@strapi/database/dist/types").CountResult | null>;
         unpublish(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Unpublish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
         discardDraft(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").DiscardDraft<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
         countDraftRelations(id: string, uid: import("@strapi/types/dist/uid").ContentType, locale: string): Promise<number>;
-        countManyEntriesDraftRelations(ids: number[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, locale: string): Promise<number>;
+        countManyEntriesDraftRelations(documentIds: string[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, locale: string | string[]): Promise<number>;
     };
     'field-sizes': ({ strapi }: {
         strapi: import("@strapi/types/dist/core").Strapi;

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

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