@strapi/content-manager 0.0.0-experimental.a65a85fdea97faae8679d3ffc5f9d79af61abd26 → 0.0.0-experimental.a687a6977f91492ccfc6771bf398a5236ece3c94

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

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../server/src/bootstrap.ts"],"names":[],"mappings":";AAIA,wBAWE"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../server/src/bootstrap.ts"],"names":[],"mappings":";AAKA,wBAYE"}

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":";cAwHkB,GAAG;iBAuDA,GAAG;gBAyDJ,GAAG;gBA0BH,GAAG;eAYJ,GAAG;mBA4CC,GAAG;gBAmBN,GAAG;IAoCrB;;;OAGG;iBACgB,GAAG;qBA6FC,GAAG;uBA6CD,GAAG;mBAyCP,GAAG;iBAyDL,GAAG;oBAwCA,GAAG;6BA6CM,GAAG;wCAkCQ,GAAG;;AAjmB/C,wBAkoBE"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/relations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,eAAe,CAAC;;uCA8Hb,GAAG,OAAO,KAAK,EAAE;IA4H1D;;;;OAIG;uBACsB,GAAG;sBAgIJ,GAAG;;AAlQ7B,wBAmVE"}
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/relations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,eAAe,CAAC;;uCA6Ib,GAAG,OAAO,KAAK,EAAE;IA4H1D;;;;OAIG;uBACsB,GAAG;sBAwIJ,GAAG;;AA1Q7B,wBAkXE"}

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":";cA4FkB,GAAG;wBAgDO,GAAG;gBAWX,GAAG;iBAsCF,GAAG;mBAmCD,GAAG;iBAiDL,GAAG;6BAiCS,GAAG;;AAvNpC,wBAmPE"}

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

@@ -1 +1 @@
-{"version":3,"file":"uid.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/uid.ts"],"names":[],"mappings":";qBAUyB,GAAG;8BAeM,GAAG;;AAhBrC,wBA0CE"}
+{"version":3,"file":"uid.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/uid.ts"],"names":[],"mappings":";qBAWyB,GAAG;8BAeM,GAAG;;AAhBrC,wBA0CE"}

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

@@ -0,0 +1,22 @@
+import { UID } from '@strapi/types';
+import { DocumentVersion, GetMetadataOptions } from '../../services/document-metadata';
+import type { AvailableLocaleDocument } from '../../../../shared/contracts/collection-types';
+/**
+ * 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<{
+    meta: {
+        availableLocales: AvailableLocaleDocument[];
+        availableStatus: Partial<DocumentVersion>[];
+    };
+    data: {
+        status: string | undefined;
+        id: string | number;
+        documentId: string;
+        locale?: string | undefined;
+        updatedAt?: string | Date | null | undefined;
+        publishedAt?: string | Date | null | undefined;
+    };
+}>;
+//# 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;AAEvF,OAAO,KAAK,EACV,uBAAuB,EAExB,MAAM,+CAA+C,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,sBAClB,GAAG,OACjB,IAAI,WAAW,YACV,eAAe,SACnB,kBAAkB;;;;;;;;;;;;;EA6BzB,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { UID } from '@strapi/types';
+interface Options {
+    allowMultipleLocales?: boolean;
+}
+/**
+ * From a request or query object, validates and returns the locale and status of the document.
+ * If the status is not provided and Draft & Publish is disabled, it defaults to 'published'.
+ */
+export declare const getDocumentLocaleAndStatus: (request: any, model: UID.Schema, 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":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAEzC,UAAU,OAAO;IACf,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAUD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,YAC5B,GAAG,SACL,IAAI,MAAM,SACX,OAAO,iBAsBd,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;8BAoJ8B,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,EAAgB,MAAM,eAAe,CAAC;AA6FxD,QAAA,MAAM,uBAAuB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;;CA8GnE,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[] | ({
+        [x: string]: any;
+        id: Data.ID;
+    } & any[]) | null>;
+    getMediaRestoreValue: (versionRelationData: Data.Entity, attribute: Schema.Attribute.Media<any, boolean>) => Promise<any>;
+    getDefaultLocale: () => Promise<any>;
+    isLocalizedContentType: (model: Schema.ContentType) => 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, useDatabaseSyntax?: boolean) => 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;;oCAuBV,OAAO,WAAW;+BAQnB,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;2BAmClB,IAAI,MAAM;iCA+DE;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;CAmD7B,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: string | number;
                     documentId: string;
-                    locale: string;
-                    updatedAt: string | Date | null;
-                    publishedAt: string | Date | null;
+                    locale?: string | undefined;
+                    updatedAt?: string | Date | null | undefined;
+                    publishedAt?: string | Date | null | undefined;
                 };
                 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/policies/hasPermissions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hasPermissions.d.ts","sourceRoot":"","sources":["../../../../server/src/policies/hasPermissions.ts"],"names":[],"mappings":";;;;;AAMA,wBAgBG"}
+{"version":3,"file":"hasPermissions.d.ts","sourceRoot":"","sources":["../../../../server/src/policies/hasPermissions.ts"],"names":[],"mappings":";;;;;AAMA,wBAqBG"}

package/dist/server/src/preview/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const FEATURE_ID = "preview";
+//# sourceMappingURL=constants.d.ts.map

package/dist/server/src/preview/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../server/src/preview/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,YAAY,CAAC"}

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

@@ -0,0 +1,2 @@
+export declare const controllers: Record<string, import("@strapi/types/dist/core").Controller>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/controllers/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,8DAM0B,CAAC"}

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

@@ -0,0 +1,13 @@
+declare const createPreviewController: () => {
+    /**
+     * Transforms an entry into a preview URL, so that it can be previewed
+     * in the Content Manager.
+     */
+    getPreviewUrl(ctx: import("koa").Context): Promise<{
+        data: {
+            url: string | undefined;
+        };
+    }>;
+};
+export { createPreviewController };
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/controllers/preview.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,uBAAuB;IAEzB;;;OAGG;;;;;;CAwBN,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import type { Core, UID } from '@strapi/types';
+import { Preview } from '../../../../../shared/contracts';
+import type { HandlerParams } from '../../services/preview-config';
+export declare const validatePreviewUrl: (strapi: Core.Strapi, uid: UID.ContentType, params: Preview.GetPreviewUrl.Request['query']) => Promise<HandlerParams>;
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../../../../../server/src/preview/controllers/validation/preview.ts"],"names":[],"mappings":";AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAYnE,eAAO,MAAM,kBAAkB,WACrB,KAAK,MAAM,OACd,IAAI,WAAW,UACZ,QAAQ,aAAa,QAAQ,CAAC,OAAO,CAAC,KAC7C,QAAQ,aAAa,CA8BvB,CAAC"}

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

@@ -0,0 +1,4 @@
+import type { Plugin } from '@strapi/types';
+declare const _default: Partial<Plugin.LoadedPlugin>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/preview/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;;AAoC5C,wBAA4B"}

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

@@ -0,0 +1,8 @@
+/**
+ * The routes will be merged with the other Content Manager routers,
+ * so we need to avoid conficts in the router name, and to prefix the path for each route.
+ */
+export declare const routes: {
+    preview: import("@strapi/types/dist/core").Router;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/routes/index.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,MAAM;;CAEsB,CAAC"}

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

@@ -0,0 +1,4 @@
+import type { Plugin } from '@strapi/types';
+declare const previewRouter: Plugin.LoadedPlugin['routes'][string];
+export { previewRouter };
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/routes/preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C,QAAA,MAAM,aAAa,EAAE,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,MAAM,CAaxD,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

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

@@ -0,0 +1,15 @@
+export declare const services: {
+    preview: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        getPreviewUrl(uid: import("@strapi/types/dist/uid").ContentType, params: import("./preview-config").HandlerParams): Promise<string | undefined>;
+    };
+    'preview-config': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        isEnabled(): boolean;
+        validate(): void;
+        getPreviewHandler(): (uid: import("@strapi/types/dist/uid").Schema, params: import("./preview-config").HandlerParams) => string | undefined;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/server/src/preview/services/preview-config.d.ts

@@ -0,0 +1,30 @@
+import type { Core, UID } from '@strapi/types';
+export type HandlerParams = {
+    documentId: string;
+    locale: string;
+    status: 'published' | 'draft';
+};
+export interface PreviewConfig {
+    enabled: boolean;
+    config: {
+        handler: (uid: UID.Schema, params: HandlerParams) => string | undefined;
+    };
+}
+/**
+ * Read configuration for static preview
+ */
+declare const createPreviewConfigService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    isEnabled(): boolean;
+    /**
+     * Validate if the configuration is valid
+     */
+    validate(): void;
+    /**
+     * Utility to get the preview handler from the configuration
+     */
+    getPreviewHandler(): PreviewConfig['config']['handler'];
+};
+export { createPreviewConfigService };
+//# sourceMappingURL=preview-config.d.ts.map

package/dist/server/src/preview/services/preview-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-config.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/services/preview-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAG/C,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE;QACN,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,KAAK,MAAM,GAAG,SAAS,CAAC;KACzE,CAAC;CACH;AAED;;GAEG;AACH,QAAA,MAAM,0BAA0B,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;IAYnE;;OAEG;;IAgBH;;OAEG;yBACkB,aAAa,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC;CAc1D,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { Core, UID } from '@strapi/types';
+import type { HandlerParams } from './preview-config';
+/**
+ * Responsible of routing an entry to a preview URL.
+ */
+declare const createPreviewService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getPreviewUrl(uid: UID.ContentType, params: HandlerParams): Promise<string | undefined>;
+};
+export { createPreviewService };
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/services/preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAI/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD;;GAEG;AACH,QAAA,MAAM,oBAAoB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;uBAIpC,IAAI,WAAW,UAAU,aAAa;CAelE,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

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

@@ -0,0 +1,18 @@
+import type { Core } from '@strapi/types';
+type PreviewServices = typeof import('./services').services;
+declare function getService<T extends keyof PreviewServices>(strapi: Core.Strapi, name: T): ReturnType<{
+    preview: ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => {
+        getPreviewUrl(uid: import("@strapi/types/dist/uid").ContentType, params: import("./services/preview-config").HandlerParams): Promise<string | undefined>;
+    };
+    'preview-config': ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => {
+        isEnabled(): boolean;
+        validate(): void;
+        getPreviewHandler(): (uid: import("@strapi/types/dist/uid").Schema, params: import("./services/preview-config").HandlerParams) => string | undefined;
+    };
+}[T]>;
+export { getService };
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../server/src/preview/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/routes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAGE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,wBAIE"}