@strapi/content-manager 0.0.0 → 5.0.0-beta.7

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

@@ -0,0 +1,48 @@
+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];
+export type Document = Modules.Documents.Result<UID.ContentType>;
+declare const documentManager: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    findOne(id: string, uid: UID.CollectionType, opts?: Omit<DocServiceParams<'findOne'>, 'documentId'>): Promise<Modules.Documents.AnyDocument | null>;
+    /**
+     * Find multiple (or all) locales for a document
+     */
+    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: 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>;
+    clone(id: Modules.Documents.ID, body: Partial<Modules.Documents.Params.Data.Input<UID.CollectionType>>, uid: UID.CollectionType): Promise<Modules.Documents.AnyDocument | undefined>;
+    /**
+     *  Check if a document exists
+     */
+    exists(uid: UID.CollectionType, id?: string): Promise<boolean>;
+    delete(id: Modules.Documents.ID, uid: UID.CollectionType, opts?: Omit<DocServiceParams<'delete'>, 'documentId'>): Promise<{}>;
+    deleteMany(documentIds: Modules.Documents.ID[], uid: UID.CollectionType, opts: DocServiceParams<'findMany'>): Promise<{
+        count: number;
+    }>;
+    publish(id: Modules.Documents.ID, uid: UID.CollectionType, opts?: Omit<DocServiceParams<'publish'>, 'documentId'>): Promise<Modules.Documents.AnyDocument | undefined>;
+    publishMany(documentIds: Modules.Documents.ID[], uid: UID.ContentType, opts?: Omit<DocServiceParams<'publish'>, 'documentId'>): Promise<{
+        count: number;
+    }>;
+    unpublishMany(documentIds: Modules.Documents.ID[], uid: UID.CollectionType, opts?: Omit<DocServiceParams<'unpublish'>, 'documentId'>): Promise<{
+        count: number;
+    }>;
+    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(documentIds: Modules.Documents.ID[], uid: UID.CollectionType, locale: string): Promise<number>;
+};
+export type DocumentManagerService = typeof documentManager;
+export default documentManager;
+//# sourceMappingURL=document-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"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,QACjB,iBAAiB,UAAU,CAAC;;;gBAU9B,QAAQ,SAAS,CAAC,EAAE,OACnB,IAAI,cAAc,SACjB,KAAK,iBAAiB,SAAS,CAAC,EAAE,YAAY,CAAC;6BAYxC,QAAQ,SAAS,CAAC,EAAE,EAAE,OAC9B,IAAI,WAAW,SACd,KAAK,iBAAiB,SAAS,CAAC,EAAE,YAAY,CAAC;;;+BAoBxC,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;gDAgB3D,QAAQ,SAAS,CAAC,EAAE,EAAE,OAC9B,IAAI,cAAc,UACf,MAAM;CAwBnB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,eAAe,CAAC;AAE5D,eAAe,eAAe,CAAC"}

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

@@ -0,0 +1,88 @@
+import type { Core, UID } from '@strapi/types';
+import type { DocumentMetadata } from '../../../shared/contracts/collection-types';
+export interface DocumentVersion {
+    id: string;
+    documentId: string;
+    locale: string;
+    updatedAt: string | null | Date;
+    publishedAt: string | null | Date;
+}
+/**
+ * Controls the metadata properties to be returned
+ *
+ * If `availableLocales` is set to `true` (default), the returned metadata will include
+ * the available locales of the document for its current status.
+ *
+ * If `availableStatus` is set to `true` (default), the returned metadata will include
+ * the available status of the document for its current locale.
+ */
+export interface GetMetadataOptions {
+    availableLocales?: boolean;
+    availableStatus?: boolean;
+}
+declare const _default: ({ strapi }: {
+    strapi: Core.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)[];
+    /**
+     * Returns available status of a document for the current locale
+     */
+    getAvailableStatus(version: DocumentVersion, allVersions: DocumentVersion[]): Partial<DocumentVersion> | undefined;
+    /**
+     * Get the available status of many documents, useful for batch operations
+     * @param uid
+     * @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")>[]>;
+    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)[];
+        availableStatus: Partial<DocumentVersion>[];
+    }>;
+    /**
+     * Returns associated metadata of a document:
+     * - Available locales of the document for the current status
+     * - Available status of the document for the current locale
+     */
+    formatDocumentWithMetadata(uid: UID.ContentType, document: DocumentVersion, opts?: GetMetadataOptions): Promise<{
+        data: {
+            status: string | undefined;
+            id: string;
+            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)[];
+            availableStatus: Partial<DocumentVersion>[];
+        };
+    }>;
+};
+export default _default;
+//# sourceMappingURL=document-metadata.d.ts.map

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

@@ -0,0 +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"}

package/dist/server/src/services/field-sizes.d.ts

@@ -0,0 +1,19 @@
+import type { Core, Modules } from '@strapi/types';
+type FieldSize = Modules.CustomFields.CustomFieldServerOptions['inputSize'];
+declare const createFieldSizesService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getAllFieldSizes(): Record<string, {
+        default: 8 | 6 | 4 | 12;
+        isResizable: boolean;
+    } | undefined>;
+    hasFieldSize(type: string): boolean;
+    getFieldSize(type?: string): {
+        default: 8 | 6 | 4 | 12;
+        isResizable: boolean;
+    };
+    setFieldSize(type: string, size: FieldSize): void;
+    setCustomFieldInputSizes(): void;
+};
+export default createFieldSizesService;
+//# sourceMappingURL=field-sizes.d.ts.map

package/dist/server/src/services/field-sizes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-sizes.d.ts","sourceRoot":"","sources":["../../../../server/src/services/field-sizes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAInD,KAAK,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC,wBAAwB,CAAC,WAAW,CAAC,CAAC;AA+C5E,QAAA,MAAM,uBAAuB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;;;;uBAM7C,MAAM;wBAIL,MAAM;;;;uBAaP,MAAM,QAAQ,SAAS;;CA2B7C,CAAC;AAEF,eAAe,uBAAuB,CAAC"}

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

@@ -0,0 +1,266 @@
+declare const _default: {
+    components: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        findAllComponents(): unknown[];
+        findComponent(uid: `${string}.${string}`): any;
+        findConfiguration(component: import("@strapi/types/dist/struct").ComponentSchema): Promise<{
+            uid: string;
+            settings: import("../../../shared/contracts/content-types").Settings;
+            metadatas: import("../../../shared/contracts/content-types").Metadatas;
+            layouts: import("../../../shared/contracts/content-types").Layouts;
+            options?: object | undefined;
+            category: string;
+        }>;
+        updateConfiguration(component: import("@strapi/types/dist/struct").ComponentSchema, newConfiguration: import("./configuration").ConfigurationUpdate): Promise<{
+            uid: string;
+            settings: import("../../../shared/contracts/content-types").Settings;
+            metadatas: import("../../../shared/contracts/content-types").Metadatas;
+            layouts: import("../../../shared/contracts/content-types").Layouts;
+            options?: object | undefined;
+            category: string;
+        }>;
+        findComponentsConfigurations(model: import("@strapi/types/dist/struct").ComponentSchema): Promise<Record<string, import("../../../shared/contracts/content-types").Configuration & {
+            category: string;
+            isComponent: boolean;
+        }>>;
+        syncConfigurations(): Promise<void>;
+    };
+    'content-types': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        findAllContentTypes(): unknown[];
+        findContentType(uid: import("@strapi/types/dist/uid").ContentType): any;
+        findDisplayedContentTypes(): unknown[];
+        findContentTypesByKind(kind: {
+            kind: import("@strapi/types/dist/struct").ContentTypeKind | undefined;
+        }): unknown[];
+        findConfiguration(contentType: import("@strapi/types/dist/struct").ContentTypeSchema): Promise<any>;
+        updateConfiguration(contentType: import("@strapi/types/dist/struct").ContentTypeSchema, newConfiguration: import("./configuration").ConfigurationUpdate): Promise<any>;
+        findComponentsConfigurations(contentType: import("@strapi/types/dist/struct").ContentTypeSchema): any;
+        syncConfigurations(): Promise<void>;
+    };
+    'data-mapper': () => {
+        toContentManagerModel(contentType: import("@strapi/types/dist/struct").ComponentSchema): {
+            apiID: string;
+            isDisplayed: boolean;
+            attributes: any;
+            modelType: "component";
+            uid: `${string}.${string}`;
+            category: string;
+            modelName: string;
+            globalId: string;
+            pluginOptions?: import("@strapi/types/dist/struct").SchemaPluginOptions | undefined;
+            options?: import("@strapi/types/dist/struct").SchemaOptions | undefined;
+            collectionName?: string | undefined;
+            info: import("@strapi/types/dist/struct").SchemaInfo;
+        };
+        toDto: import("lodash/fp").LodashPick2x1;
+    };
+    '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)[];
+        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;
+        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)[];
+            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;
+                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)[];
+                availableStatus: Partial<import("./document-metadata").DocumentVersion>[];
+            };
+        }>;
+    };
+    'document-manager': ({ strapi }: {
+        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 | 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: 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(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): 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(documentIds: string[], uid: import("@strapi/types/dist/uid").ContentType, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Publish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<{
+            count: 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;
+        }>;
+        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(documentIds: string[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, locale: string): Promise<number>;
+    };
+    'field-sizes': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        getAllFieldSizes(): Record<string, {
+            default: 8 | 6 | 4 | 12;
+            isResizable: boolean;
+        } | undefined>;
+        hasFieldSize(type: string): boolean;
+        getFieldSize(type?: string | undefined): {
+            default: 8 | 6 | 4 | 12;
+            isResizable: boolean;
+        };
+        setFieldSize(type: string, size: {
+            default: 8 | 6 | 4 | 12;
+            isResizable: boolean;
+        } | undefined): void;
+        setCustomFieldInputSizes(): void;
+    };
+    metrics: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        sendDidConfigureListView: (contentType: import("@strapi/types/dist/struct").ContentTypeSchema, configuration: import("../../../shared/contracts/content-types").Configuration) => Promise<void>;
+    };
+    'permission-checker': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        create: ({ userAbility, model }: {
+            userAbility: any;
+            model: string;
+        }) => {
+            can: (action: string, entity?: ({
+                id: import("@strapi/types/dist/data").ID;
+            } & {
+                [key: string]: any;
+            }) | undefined, field: string) => any;
+            cannot: (action: string, entity?: ({
+                id: import("@strapi/types/dist/data").ID;
+            } & {
+                [key: string]: any;
+            }) | undefined, field: string) => any;
+            sanitizeOutput: (data: {
+                id: import("@strapi/types/dist/data").ID;
+            } & {
+                [key: string]: any;
+            }, { action }?: {
+                action?: string | undefined;
+            }) => any;
+            sanitizeQuery: (query: {
+                page?: string | undefined;
+                pageSize?: string | undefined;
+                sort?: string | undefined;
+            }, { action }?: {
+                action?: string | undefined;
+            }) => any;
+            sanitizeCreateInput: (data: any) => any;
+            sanitizeUpdateInput: (entity: {
+                id: import("@strapi/types/dist/data").ID;
+            } & {
+                [key: string]: any;
+            }) => (data: any) => any;
+            validateQuery: (query: {
+                page?: string | undefined;
+                pageSize?: string | undefined;
+                sort?: string | undefined;
+            }, { action }?: {
+                action?: string | undefined;
+            }) => any;
+            validateInput: (action: string, data: any, entity?: ({
+                id: import("@strapi/types/dist/data").ID;
+            } & {
+                [key: string]: any;
+            }) | undefined) => any;
+            sanitizedQuery: (query: {
+                page?: string | undefined;
+                pageSize?: string | undefined;
+                sort?: string | undefined;
+            }, action?: {
+                action?: string | undefined;
+            }) => Promise<any>;
+        };
+    };
+    permission: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        canConfigureContentType({ userAbility, contentType, }: {
+            userAbility: any;
+            contentType: import("@strapi/types/dist/struct").ContentTypeSchema;
+        }): any;
+        registerPermissions(): Promise<void>;
+    };
+    'populate-builder': () => (uid: import("@strapi/types/dist/uid").Schema) => {
+        populateFromQuery(query: object): any;
+        countRelations({ toMany, toOne }?: {
+            toMany: boolean;
+            toOne: boolean;
+        }): any;
+        populateDeep(level?: number): any;
+        build(): Promise<{} | undefined>;
+    };
+    uid: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        generateUIDField({ contentTypeUID, field, data, locale, }: {
+            contentTypeUID: import("@strapi/types/dist/uid").ContentType;
+            field: string;
+            data: Record<string, any>;
+            locale?: string | undefined;
+        }): Promise<string>;
+        findUniqueUID({ contentTypeUID, field, value, locale, }: {
+            contentTypeUID: import("@strapi/types/dist/uid").ContentType;
+            field: string;
+            value: string;
+            locale?: string | undefined;
+        }): Promise<string>;
+        checkUIDAvailability({ contentTypeUID, field, value, locale, }: {
+            contentTypeUID: import("@strapi/types/dist/uid").ContentType;
+            field: string;
+            value: string;
+            locale?: string | undefined;
+        }): Promise<boolean>;
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,9 @@
+import type { Core, Struct } from '@strapi/types';
+import type { Configuration } from '../../../shared/contracts/content-types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    sendDidConfigureListView: (contentType: Struct.ContentTypeSchema, configuration: Configuration) => Promise<void>;
+};
+export default _default;
+//# sourceMappingURL=metrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../../../server/src/services/metrics.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;qCAIjD;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;4CAElC,OAAO,iBAAiB,iBACtB,aAAa;;AAHhC,wBAiCE"}

package/dist/server/src/services/permission-checker.d.ts

@@ -0,0 +1,54 @@
+import type { Core } from '@strapi/types';
+type Query = {
+    page?: string;
+    pageSize?: string;
+    sort?: string;
+};
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    create: ({ userAbility, model }: {
+        userAbility: any;
+        model: string;
+    }) => {
+        can: (action: string, entity?: ({
+            id: import("@strapi/types/dist/data").ID;
+        } & {
+            [key: string]: any;
+        }) | undefined, field: string) => any;
+        cannot: (action: string, entity?: ({
+            id: import("@strapi/types/dist/data").ID;
+        } & {
+            [key: string]: any;
+        }) | undefined, field: string) => any;
+        sanitizeOutput: (data: {
+            id: import("@strapi/types/dist/data").ID;
+        } & {
+            [key: string]: any;
+        }, { action }?: {
+            action?: string | undefined;
+        }) => any;
+        sanitizeQuery: (query: Query, { action }?: {
+            action?: string | undefined;
+        }) => any;
+        sanitizeCreateInput: (data: any) => any;
+        sanitizeUpdateInput: (entity: {
+            id: import("@strapi/types/dist/data").ID;
+        } & {
+            [key: string]: any;
+        }) => (data: any) => any;
+        validateQuery: (query: Query, { action }?: {
+            action?: string | undefined;
+        }) => any;
+        validateInput: (action: string, data: any, entity?: ({
+            id: import("@strapi/types/dist/data").ID;
+        } & {
+            [key: string]: any;
+        }) | undefined) => any;
+        sanitizedQuery: (query: Query, action?: {
+            action?: string | undefined;
+        }) => Promise<any>;
+    };
+};
+export default _default;
+//# sourceMappingURL=permission-checker.d.ts.map

package/dist/server/src/services/permission-checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-checker.d.ts","sourceRoot":"","sources":["../../../../server/src/services/permission-checker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,eAAe,CAAC;AAaxD,KAAK,KAAK,GAAG;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;qCAiG0B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAnD,wBAEG"}

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

@@ -0,0 +1,12 @@
+import type { Core, Struct } from '@strapi/types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    canConfigureContentType({ userAbility, contentType, }: {
+        userAbility: any;
+        contentType: Struct.ContentTypeSchema;
+    }): any;
+    registerPermissions(): Promise<void>;
+};
+export default _default;
+//# sourceMappingURL=permission.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permission.d.ts","sourceRoot":"","sources":["../../../../server/src/services/permission.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;qCAGtB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;2DAI9C;QACD,WAAW,EAAE,GAAG,CAAC;QACjB,WAAW,EAAE,OAAO,iBAAiB,CAAC;KACvC;;;AAPH,wBAyFG"}

package/dist/server/src/services/populate-builder.d.ts

@@ -0,0 +1,30 @@
+import type { UID } from '@strapi/types';
+declare const _default: () => (uid: UID.Schema) => {
+    /**
+     * Populates all attribute fields present in a query.
+     * @param query - Strapi query object
+     */
+    populateFromQuery(query: object): any;
+    /**
+     * Populate relations as count.
+     * @param [options]
+     * @param [options.toMany] - Populate XtoMany relations as count if true.
+     * @param [options.toOne] - Populate XtoOne relations as count if true.
+     */
+    countRelations({ toMany, toOne }?: {
+        toMany: boolean;
+        toOne: boolean;
+    }): any;
+    /**
+     * Populate relations deeply, up to a certain level.
+     * @param [level=Infinity] - Max level of nested populate.
+     */
+    populateDeep(level?: number): any;
+    /**
+     * Construct the populate object based on the builder options.
+     * @returns Populate object
+     */
+    build(): Promise<{} | undefined>;
+};
+export default _default;
+//# sourceMappingURL=populate-builder.d.ts.map

package/dist/server/src/services/populate-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"populate-builder.d.ts","sourceRoot":"","sources":["../../../../server/src/services/populate-builder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;;IAwBrC;;;OAGG;;IAMH;;;;;OAKG;;;;;IAWH;;;OAGG;;IAMH;;;OAGG;;;AAeP,wBAAqC"}

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

@@ -0,0 +1,25 @@
+import type { Core, UID } from '@strapi/types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    generateUIDField({ contentTypeUID, field, data, locale, }: {
+        contentTypeUID: UID.ContentType;
+        field: string;
+        data: Record<string, any>;
+        locale?: string;
+    }): Promise<string>;
+    findUniqueUID({ contentTypeUID, field, value, locale, }: {
+        contentTypeUID: UID.ContentType;
+        field: string;
+        value: string;
+        locale?: string;
+    }): Promise<string>;
+    checkUIDAvailability({ contentTypeUID, field, value, locale, }: {
+        contentTypeUID: UID.ContentType;
+        field: string;
+        value: string;
+        locale?: string;
+    }): Promise<boolean>;
+};
+export default _default;
+//# sourceMappingURL=uid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uid.d.ts","sourceRoot":"","sources":["../../../../server/src/services/uid.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAU,GAAG,EAAE,MAAM,eAAe,CAAC;qCAE3B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;+DAM9C;QACD,cAAc,EAAE,IAAI,WAAW,CAAC;QAChC,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,OAAO,MAAM,EAAE,GAAG,CAAC,CAAC;QAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;6DAsCE;QACD,cAAc,EAAE,IAAI,WAAW,CAAC;QAChC,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;oEA6CE;QACD,cAAc,EAAE,IAAI,WAAW,CAAC;QAChC,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;;AAxGH,wBA0HG"}

package/dist/server/src/services/utils/configuration/attributes.d.ts

@@ -0,0 +1,17 @@
+declare const isListable: (schema: any, name: any) => boolean;
+declare const isSortable: (schema: any, name: any) => boolean;
+declare const isSearchable: (schema: any, name: any) => boolean;
+declare const isVisible: (schema: any, name: any) => boolean;
+declare const isRelation: (attribute: any) => boolean;
+declare const hasRelationAttribute: (schema: any, name: any) => boolean;
+declare const hasEditableAttribute: (schema: any, name: any) => boolean;
+declare const getDefaultMainField: (schema: any) => string;
+/**
+ * Returns list of all sortable attributes for a given content type schema
+ * TODO V5: Refactor non visible fields to be a part of content-manager schema so we can use isSortable instead
+ * @param {*} schema
+ * @returns
+ */
+declare const getSortableAttributes: (schema: any) => string[];
+export { isSortable, isVisible, isSearchable, isRelation, isListable, hasEditableAttribute, hasRelationAttribute, getDefaultMainField, getSortableAttributes, };
+//# sourceMappingURL=attributes.d.ts.map

package/dist/server/src/services/utils/configuration/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/utils/configuration/attributes.ts"],"names":[],"mappings":"AA4BA,QAAA,MAAM,UAAU,WAAY,GAAG,QAAQ,GAAG,YAmBzC,CAAC;AAEF,QAAA,MAAM,UAAU,WAAY,GAAG,QAAQ,GAAG,YAiBzC,CAAC;AAEF,QAAA,MAAM,YAAY,WAAY,GAAG,QAAQ,GAAG,YAE3C,CAAC;AAEF,QAAA,MAAM,SAAS,WAAY,GAAG,QAAQ,GAAG,YAsBxC,CAAC;AAkCF,QAAA,MAAM,UAAU,cAAe,GAAG,YAAkC,CAAC;AAErE,QAAA,MAAM,oBAAoB,WAAY,GAAG,QAAQ,GAAG,YAcnD,CAAC;AAEF,QAAA,MAAM,oBAAoB,WAAY,GAAG,QAAQ,GAAG,YAcnD,CAAC;AASF,QAAA,MAAM,mBAAmB,WAAY,GAAG,WAA6C,CAAC;AAEtF;;;;;GAKG;AACH,QAAA,MAAM,qBAAqB,WAAY,GAAG,aAgBzC,CAAC;AAEF,OAAO,EACL,UAAU,EACV,SAAS,EACT,YAAY,EACZ,UAAU,EACV,UAAU,EACV,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,GACtB,CAAC"}