@strapi/content-manager 0.0.0-experimental.0581774d9b26d449a40191b96482efca5664a181

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

@@ -0,0 +1,43 @@
+declare const _default: {
+    admin: {
+        type: string;
+        routes: ({
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: string[];
+                middlewares?: undefined;
+            };
+        } | {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                middlewares: ((ctx: import("koa").Context, next: import("koa").Next) => Promise<any>)[];
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                })[];
+            };
+        } | {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                middlewares: ((ctx: import("koa").Context, next: import("koa").Next) => Promise<any>)[];
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                        hasAtLeastOne: boolean;
+                    };
+                })[];
+            };
+        })[];
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,32 @@
+import type { UID, Struct, Core } from '@strapi/types';
+import type { Configuration } from '../../../shared/contracts/content-types';
+import type { ConfigurationUpdate } from './configuration';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    findAllComponents(): unknown[];
+    findComponent(uid: UID.Component): any;
+    findConfiguration(component: 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: Struct.ComponentSchema, newConfiguration: 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: Struct.ComponentSchema): Promise<Record<string, Configuration & {
+        category: string;
+        isComponent: boolean;
+    }>>;
+    syncConfigurations(): Promise<void>;
+};
+export default _default;
+//# sourceMappingURL=components.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../../server/src/services/components.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;qCAmB/B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;uBAO9B,IAAI,SAAS;iCAQG,OAAO,eAAe;;;;;;;;mCAW5C,OAAO,eAAe,oBACf,mBAAmB;;;;;;;;wCAOG,OAAO,eAAe;kBAGhC,MAAM;qBAAe,OAAO;;;;AArC9D,wBA4EG"}

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

@@ -0,0 +1,20 @@
+import type { Settings, Metadatas, Layouts } from '../../../shared/contracts/content-types';
+export type ConfigurationUpdate = {
+    settings: Settings;
+    metadatas: Metadatas;
+    layouts: Layouts;
+    options?: Record<string, unknown>;
+};
+declare const _default: ({ isComponent, prefix, storeUtils, getModels, }: {
+    isComponent?: boolean;
+    prefix: string;
+    storeUtils: any;
+    getModels: any;
+}) => {
+    getConfiguration: (uid: string) => any;
+    setConfiguration: (uid: string, input: ConfigurationUpdate) => any;
+    deleteConfiguration: (uid: string) => any;
+    syncConfigurations: () => Promise<void>;
+};
+export default _default;
+//# sourceMappingURL=configuration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"configuration.d.ts","sourceRoot":"","sources":["../../../../server/src/services/configuration.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAI5F,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;0EAOC;IACD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,GAAG,CAAC;IAChB,SAAS,EAAE,GAAG,CAAC;CAChB;4BAKgC,MAAM;4BAMN,MAAM,SAAS,mBAAmB;+BAW/B,MAAM;;;AAhC1C,wBA8EE"}

package/dist/server/src/services/content-types.d.ts

@@ -0,0 +1,18 @@
+import type { UID, Struct, Core } from '@strapi/types';
+import type { ConfigurationUpdate } from './configuration';
+declare const service: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    findAllContentTypes(): unknown[];
+    findContentType(uid: UID.ContentType): any;
+    findDisplayedContentTypes(): unknown[];
+    findContentTypesByKind(kind: {
+        kind: Struct.ContentTypeKind | undefined;
+    }): unknown[];
+    findConfiguration(contentType: Struct.ContentTypeSchema): Promise<any>;
+    updateConfiguration(contentType: Struct.ContentTypeSchema, newConfiguration: ConfigurationUpdate): Promise<any>;
+    findComponentsConfigurations(contentType: Struct.ContentTypeSchema): any;
+    syncConfigurations(): Promise<void>;
+};
+export default service;
+//# sourceMappingURL=content-types.d.ts.map

package/dist/server/src/services/content-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-types.d.ts","sourceRoot":"","sources":["../../../../server/src/services/content-types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAEvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAgB3D,QAAA,MAAM,OAAO,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;yBAO7B,IAAI,WAAW;;iCAgBP;QAAE,IAAI,EAAE,OAAO,eAAe,GAAG,SAAS,CAAA;KAAE;mCASpC,OAAO,iBAAiB;qCAU9C,OAAO,iBAAiB,oBACnB,mBAAmB;8CAOG,OAAO,iBAAiB;;CAQlE,CAAC;AAEH,eAAe,OAAO,CAAC"}

package/dist/server/src/services/data-mapper.d.ts

@@ -0,0 +1,20 @@
+import type { Struct } from '@strapi/types';
+declare const _default: () => {
+    toContentManagerModel(contentType: Struct.ComponentSchema): {
+        apiID: string;
+        isDisplayed: boolean;
+        attributes: any;
+        modelType: "component";
+        uid: `${string}.${string}`;
+        category: string;
+        modelName: string;
+        globalId: string;
+        pluginOptions?: Struct.SchemaPluginOptions | undefined;
+        options?: Struct.SchemaOptions | undefined;
+        collectionName?: string | undefined;
+        info: Struct.SchemaInfo;
+    };
+    toDto: import("lodash/fp").LodashPick2x1;
+};
+export default _default;
+//# sourceMappingURL=data-mapper.d.ts.map

package/dist/server/src/services/data-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-mapper.d.ts","sourceRoot":"","sources":["../../../../server/src/services/data-mapper.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAU,MAAM,EAAE,MAAM,eAAe,CAAC;;uCAgBf,OAAO,eAAe;;;;;;;;;;;;;;;;AAD3D,wBAgBG"}

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'> & {
+        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;
+    }>;
+    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 | 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;IAczB;;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;gDAkB3D,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

@@ -0,0 +1,69 @@
+import type { Core, UID, Modules } from '@strapi/types';
+import type { DocumentMetadata } from '../../../shared/contracts/collection-types';
+export interface DocumentVersion {
+    id: string | number;
+    documentId: Modules.Documents.ID;
+    locale?: string;
+    localizations?: DocumentVersion[];
+    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[]): Promise<import("../../../shared/contracts/collection-types").AvailableLocaleDocument[]>;
+    /**
+     * 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<any[]>;
+    getStatus(version: DocumentVersion, otherDocumentStatuses?: DocumentMetadata['availableStatus']): string;
+    getMetadata(uid: UID.ContentType, version: DocumentVersion, { availableLocales, availableStatus }?: GetMetadataOptions): Promise<{
+        availableLocales: import("../../../shared/contracts/collection-types").AvailableLocaleDocument[];
+        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 | number;
+            documentId: string;
+            locale?: string | undefined;
+            localizations?: DocumentVersion[] | undefined;
+            updatedAt?: string | Date | null | undefined;
+            publishedAt?: string | Date | null | undefined;
+        };
+        meta: {
+            availableLocales: import("../../../shared/contracts/collection-types").AvailableLocaleDocument[];
+            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,OAAO,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAGnF,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,eAAe,EAAE,CAAC;IAClC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IACjC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;CACpC;AA2BD;;;;;;;;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;IA2ChC;;OAEG;gCACyB,eAAe,eAAe,eAAe,EAAE;IAoB3E;;;;;OAKG;gCAC+B,IAAI,WAAW,aAAa,eAAe,EAAE;uBAuB5D,eAAe,0BAA0B,gBAAgB,CAAC,iBAAiB,CAAC;qBAgCxF,IAAI,WAAW,WACX,eAAe,0CAC6B,kBAAkB;;;;IAyCzE;;;;OAIG;oCAEI,IAAI,WAAW,YACV,eAAe,SACnB,kBAAkB;;;;;;;;;;;;;;;;AAzL5B,wBAsOG"}

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,246 @@
+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[]): 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<any[]>;
+        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: 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 | number;
+                documentId: string;
+                locale?: string | undefined;
+                localizations?: import("./document-metadata").DocumentVersion[] | undefined;
+                updatedAt?: string | Date | null | undefined;
+                publishedAt?: string | Date | null | undefined;
+            };
+            meta: {
+                availableLocales: import("../../../shared/contracts/collection-types").AvailableLocaleDocument[];
+                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) & {
+            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;
+        }>;
+        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 | 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcA,wBAcE"}

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;qCAoH0B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAnD,wBAEG"}