@webiny/app-record-locking 0.0.0-unstable.0156a4c312

package/features/forceUnlock/ForceUnlockUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/forceUnlock/ForceUnlockUseCase.js","sources":["../../../src/features/forceUnlock/ForceUnlockUseCase.ts"],"sourcesContent":["import {\n    ForceUnlockUseCase as UseCaseAbstraction,\n    ForceUnlockGateway,\n    type IForceUnlockParams\n} from \"./abstractions.js\";\n\nclass ForceUnlockUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: ForceUnlockGateway.Interface) {}\n\n    async execute(params: IForceUnlockParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const ForceUnlockUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ForceUnlockUseCaseImpl,\n    dependencies: [ForceUnlockGateway]\n});\n"],"names":["ForceUnlockUseCaseImpl","gateway","params","ForceUnlockUseCase","UseCaseAbstraction","ForceUnlockGateway"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,OAAqC,CAAE;aAAvCA,OAAO,GAAPA;IAAwC;IAE5D,MAAM,QAAQC,MAA0B,EAAE;QACtC,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;IAChC;AACJ;AAEO,MAAMC,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBJ;IAChB,cAAc;QAACK;KAAmB;AACtC"}

package/features/forceUnlock/abstractions.d.ts

@@ -0,0 +1,19 @@
+import type { IRecordLockingLockRecord } from "../../types.js";
+export interface IForceUnlockParams {
+    id: string;
+    type: string;
+}
+export interface IForceUnlockGateway {
+    execute(params: IForceUnlockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const ForceUnlockGateway: import("@webiny/di").Abstraction<IForceUnlockGateway>;
+export declare namespace ForceUnlockGateway {
+    type Interface = IForceUnlockGateway;
+}
+export interface IForceUnlockUseCase {
+    execute(params: IForceUnlockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const ForceUnlockUseCase: import("@webiny/di").Abstraction<IForceUnlockUseCase>;
+export declare namespace ForceUnlockUseCase {
+    type Interface = IForceUnlockUseCase;
+}

package/features/forceUnlock/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const ForceUnlockGateway = createAbstraction("ForceUnlockGateway");
+const ForceUnlockUseCase = createAbstraction("ForceUnlockUseCase");
+export { ForceUnlockGateway, ForceUnlockUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/forceUnlock/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/forceUnlock/abstractions.js","sources":["../../../src/features/forceUnlock/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { IRecordLockingLockRecord } from \"~/types.js\";\n\nexport interface IForceUnlockParams {\n    id: string;\n    type: string;\n}\n\nexport interface IForceUnlockGateway {\n    execute(params: IForceUnlockParams): Promise<IRecordLockingLockRecord>;\n}\n\nexport const ForceUnlockGateway = createAbstraction<IForceUnlockGateway>(\"ForceUnlockGateway\");\n\nexport namespace ForceUnlockGateway {\n    export type Interface = IForceUnlockGateway;\n}\n\nexport interface IForceUnlockUseCase {\n    execute(params: IForceUnlockParams): Promise<IRecordLockingLockRecord>;\n}\n\nexport const ForceUnlockUseCase = createAbstraction<IForceUnlockUseCase>(\"ForceUnlockUseCase\");\n\nexport namespace ForceUnlockUseCase {\n    export type Interface = IForceUnlockUseCase;\n}\n"],"names":["ForceUnlockGateway","createAbstraction","ForceUnlockUseCase"],"mappings":";AAYO,MAAMA,qBAAqBC,kBAAuC;AAUlE,MAAMC,qBAAqBD,kBAAuC"}

package/features/forceUnlock/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const ForceUnlockFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").IForceUnlockUseCase;
+}, []>;

package/features/forceUnlock/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ForceUnlockUseCase } from "./abstractions.js";
+import { ForceUnlockUseCase as external_ForceUnlockUseCase_js_ForceUnlockUseCase } from "./ForceUnlockUseCase.js";
+import { ForceUnlockGateway } from "./ForceUnlockGateway.js";
+const ForceUnlockFeature = createFeature({
+    name: "RecordLocking/ForceUnlock",
+    register (container) {
+        container.register(external_ForceUnlockUseCase_js_ForceUnlockUseCase);
+        container.register(ForceUnlockGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(ForceUnlockUseCase)
+        };
+    }
+});
+export { ForceUnlockFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/forceUnlock/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/forceUnlock/feature.js","sources":["../../../src/features/forceUnlock/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ForceUnlockUseCase as UseCase } from \"./abstractions.js\";\nimport { ForceUnlockUseCase } from \"./ForceUnlockUseCase.js\";\nimport { ForceUnlockGateway } from \"./ForceUnlockGateway.js\";\n\nexport const ForceUnlockFeature = createFeature({\n    name: \"RecordLocking/ForceUnlock\",\n    register(container) {\n        container.register(ForceUnlockUseCase);\n        container.register(ForceUnlockGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["ForceUnlockFeature","createFeature","container","ForceUnlockUseCase","ForceUnlockGateway","UseCase"],"mappings":";;;;AAKO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,oBAAoB,gBAAgB;IAC3D;IACA,SAAQF,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACG;QAC/B;IACJ;AACJ"}

package/features/graphqlFields.d.ts

@@ -0,0 +1,2 @@
+export declare const LOCK_RECORD_FIELDS = "\n    id\n    lockedBy {\n        id\n        displayName\n        type\n    }\n    lockedOn\n    updatedOn\n    expiresOn\n    targetId\n    type\n    actions {\n        type\n        message\n        createdBy {\n            id\n            displayName\n            type\n        }\n        createdOn\n    }\n";
+export declare const ERROR_FIELDS = "\n    message\n    code\n    data\n";

package/features/graphqlFields.js

@@ -0,0 +1,31 @@
+const LOCK_RECORD_FIELDS = `
+    id
+    lockedBy {
+        id
+        displayName
+        type
+    }
+    lockedOn
+    updatedOn
+    expiresOn
+    targetId
+    type
+    actions {
+        type
+        message
+        createdBy {
+            id
+            displayName
+            type
+        }
+        createdOn
+    }
+`;
+const ERROR_FIELDS = `
+    message
+    code
+    data
+`;
+export { ERROR_FIELDS, LOCK_RECORD_FIELDS };
+
+//# sourceMappingURL=graphqlFields.js.map

package/features/graphqlFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/graphqlFields.js","sources":["../../src/features/graphqlFields.ts"],"sourcesContent":["export const LOCK_RECORD_FIELDS = /* GraphQL */ `\n    id\n    lockedBy {\n        id\n        displayName\n        type\n    }\n    lockedOn\n    updatedOn\n    expiresOn\n    targetId\n    type\n    actions {\n        type\n        message\n        createdBy {\n            id\n            displayName\n            type\n        }\n        createdOn\n    }\n`;\n\nexport const ERROR_FIELDS = /* GraphQL */ `\n    message\n    code\n    data\n`;\n"],"names":["LOCK_RECORD_FIELDS","ERROR_FIELDS"],"mappings":"AAAO,MAAMA,qBAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;AAsBjD,CAAC;AAEM,MAAMC,eAA6B,CAAC;;;;AAI3C,CAAC"}

package/features/listLockRecords/ListLockRecordsGateway.d.ts

@@ -0,0 +1,12 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { ListLockRecordsGateway as GatewayAbstraction, type IListLockRecordsParams } from "./abstractions.js";
+import type { IRecordLockingLockRecord } from "../../types.js";
+declare class ListLockRecordsGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: MainGraphQLClient.Interface);
+    execute(params: IListLockRecordsParams): Promise<IRecordLockingLockRecord[]>;
+}
+export declare const ListLockRecordsGateway: typeof ListLockRecordsGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListLockRecordsGateway>;
+};
+export {};

package/features/listLockRecords/ListLockRecordsGateway.js

@@ -0,0 +1,48 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { ERROR_FIELDS, LOCK_RECORD_FIELDS } from "../graphqlFields.js";
+import { ListLockRecordsGateway } from "./abstractions.js";
+const LIST_LOCK_RECORDS_QUERY = `
+    query RecordLockingListLockedRecords(
+        $where: RecordLockingListWhereInput
+        $sort: [RecordLockingListSorter!]
+        $limit: Int
+        $after: String
+    ) {
+        recordLocking {
+            listLockRecords(where: $where, sort: $sort, limit: $limit, after: $after) {
+                data {
+                    ${LOCK_RECORD_FIELDS}
+                }
+                error {
+                    ${ERROR_FIELDS}
+                }
+            }
+        }
+    }
+`;
+class ListLockRecordsGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const response = await this.client.execute({
+            query: LIST_LOCK_RECORDS_QUERY,
+            variables: {
+                where: params.where,
+                limit: params.limit ?? 100
+            }
+        });
+        const { data, error } = response.recordLocking.listLockRecords;
+        if (error) throw new Error(error.message);
+        return data || [];
+    }
+}
+const ListLockRecordsGateway_ListLockRecordsGateway = ListLockRecordsGateway.createImplementation({
+    implementation: ListLockRecordsGatewayImpl,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { ListLockRecordsGateway_ListLockRecordsGateway as ListLockRecordsGateway };
+
+//# sourceMappingURL=ListLockRecordsGateway.js.map

package/features/listLockRecords/ListLockRecordsGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/listLockRecords/ListLockRecordsGateway.js","sources":["../../../src/features/listLockRecords/ListLockRecordsGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/abstractions.js\";\nimport { LOCK_RECORD_FIELDS, ERROR_FIELDS } from \"~/features/graphqlFields.js\";\nimport {\n    ListLockRecordsGateway as GatewayAbstraction,\n    type IListLockRecordsParams\n} from \"./abstractions.js\";\nimport type { IRecordLockingError, IRecordLockingLockRecord } from \"~/types.js\";\n\ninterface ListLockRecordsResponse {\n    recordLocking: {\n        listLockRecords: {\n            data: IRecordLockingLockRecord[] | null;\n            error: IRecordLockingError | null;\n        };\n    };\n}\n\nconst LIST_LOCK_RECORDS_QUERY = /* GraphQL */ `\n    query RecordLockingListLockedRecords(\n        $where: RecordLockingListWhereInput\n        $sort: [RecordLockingListSorter!]\n        $limit: Int\n        $after: String\n    ) {\n        recordLocking {\n            listLockRecords(where: $where, sort: $sort, limit: $limit, after: $after) {\n                data {\n                    ${LOCK_RECORD_FIELDS}\n                }\n                error {\n                    ${ERROR_FIELDS}\n                }\n            }\n        }\n    }\n`;\n\nclass ListLockRecordsGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async execute(params: IListLockRecordsParams) {\n        const response = await this.client.execute<ListLockRecordsResponse>({\n            query: LIST_LOCK_RECORDS_QUERY,\n            variables: {\n                where: params.where,\n                limit: params.limit ?? 100\n            }\n        });\n\n        const { data, error } = response.recordLocking.listLockRecords;\n\n        if (error) {\n            throw new Error(error.message);\n        }\n\n        return data || [];\n    }\n}\n\nexport const ListLockRecordsGateway = GatewayAbstraction.createImplementation({\n    implementation: ListLockRecordsGatewayImpl,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["LIST_LOCK_RECORDS_QUERY","LOCK_RECORD_FIELDS","ERROR_FIELDS","ListLockRecordsGatewayImpl","client","params","response","data","error","Error","ListLockRecordsGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;;AAiBA,MAAMA,0BAAwC,CAAC;;;;;;;;;;oBAU3B,EAAEC,mBAAmB;;;oBAGrB,EAAEC,aAAa;;;;;AAKnC,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,QAAQC,MAA8B,EAAE;QAC1C,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA0B;YAChE,OAAON;YACP,WAAW;gBACP,OAAOK,OAAO,KAAK;gBACnB,OAAOA,OAAO,KAAK,IAAI;YAC3B;QACJ;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,aAAa,CAAC,eAAe;QAE9D,IAAIE,OACA,MAAM,IAAIC,MAAMD,MAAM,OAAO;QAGjC,OAAOD,QAAQ,EAAE;IACrB;AACJ;AAEO,MAAMG,gDAAyBC,uBAAAA,oBAAuC,CAAC;IAC1E,gBAAgBR;IAChB,cAAc;QAACS;KAAkB;AACrC"}

package/features/listLockRecords/ListLockRecordsUseCase.d.ts

@@ -0,0 +1,10 @@
+import { ListLockRecordsUseCase as UseCaseAbstraction, ListLockRecordsGateway, type IListLockRecordsParams } from "./abstractions.js";
+declare class ListLockRecordsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private gateway;
+    constructor(gateway: ListLockRecordsGateway.Interface);
+    execute(params: IListLockRecordsParams): Promise<import("../../types.js").IRecordLockingLockRecord[]>;
+}
+export declare const ListLockRecordsUseCase: typeof ListLockRecordsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListLockRecordsUseCase>;
+};
+export {};

package/features/listLockRecords/ListLockRecordsUseCase.js

@@ -0,0 +1,18 @@
+import { ListLockRecordsGateway, ListLockRecordsUseCase } from "./abstractions.js";
+class ListLockRecordsUseCaseImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        return this.gateway.execute(params);
+    }
+}
+const ListLockRecordsUseCase_ListLockRecordsUseCase = ListLockRecordsUseCase.createImplementation({
+    implementation: ListLockRecordsUseCaseImpl,
+    dependencies: [
+        ListLockRecordsGateway
+    ]
+});
+export { ListLockRecordsUseCase_ListLockRecordsUseCase as ListLockRecordsUseCase };
+
+//# sourceMappingURL=ListLockRecordsUseCase.js.map

package/features/listLockRecords/ListLockRecordsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/listLockRecords/ListLockRecordsUseCase.js","sources":["../../../src/features/listLockRecords/ListLockRecordsUseCase.ts"],"sourcesContent":["import {\n    ListLockRecordsUseCase as UseCaseAbstraction,\n    ListLockRecordsGateway,\n    type IListLockRecordsParams\n} from \"./abstractions.js\";\n\nclass ListLockRecordsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: ListLockRecordsGateway.Interface) {}\n\n    async execute(params: IListLockRecordsParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const ListLockRecordsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListLockRecordsUseCaseImpl,\n    dependencies: [ListLockRecordsGateway]\n});\n"],"names":["ListLockRecordsUseCaseImpl","gateway","params","ListLockRecordsUseCase","UseCaseAbstraction","ListLockRecordsGateway"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,OAAyC,CAAE;aAA3CA,OAAO,GAAPA;IAA4C;IAEhE,MAAM,QAAQC,MAA8B,EAAE;QAC1C,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;IAChC;AACJ;AAEO,MAAMC,gDAAyBC,uBAAAA,oBAAuC,CAAC;IAC1E,gBAAgBJ;IAChB,cAAc;QAACK;KAAuB;AAC1C"}

package/features/listLockRecords/abstractions.d.ts

@@ -0,0 +1,22 @@
+import type { IRecordLockingLockRecord } from "../../types.js";
+export interface IListLockRecordsParams {
+    where?: {
+        id_in?: string[];
+        type?: string;
+    };
+    limit?: number;
+}
+export interface IListLockRecordsGateway {
+    execute(params: IListLockRecordsParams): Promise<IRecordLockingLockRecord[]>;
+}
+export declare const ListLockRecordsGateway: import("@webiny/di").Abstraction<IListLockRecordsGateway>;
+export declare namespace ListLockRecordsGateway {
+    type Interface = IListLockRecordsGateway;
+}
+export interface IListLockRecordsUseCase {
+    execute(params: IListLockRecordsParams): Promise<IRecordLockingLockRecord[]>;
+}
+export declare const ListLockRecordsUseCase: import("@webiny/di").Abstraction<IListLockRecordsUseCase>;
+export declare namespace ListLockRecordsUseCase {
+    type Interface = IListLockRecordsUseCase;
+}

package/features/listLockRecords/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const ListLockRecordsGateway = createAbstraction("ListLockRecordsGateway");
+const ListLockRecordsUseCase = createAbstraction("ListLockRecordsUseCase");
+export { ListLockRecordsGateway, ListLockRecordsUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/listLockRecords/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/listLockRecords/abstractions.js","sources":["../../../src/features/listLockRecords/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { IRecordLockingLockRecord } from \"~/types.js\";\n\nexport interface IListLockRecordsParams {\n    where?: {\n        id_in?: string[];\n        type?: string;\n    };\n    limit?: number;\n}\n\nexport interface IListLockRecordsGateway {\n    execute(params: IListLockRecordsParams): Promise<IRecordLockingLockRecord[]>;\n}\n\nexport const ListLockRecordsGateway =\n    createAbstraction<IListLockRecordsGateway>(\"ListLockRecordsGateway\");\n\nexport namespace ListLockRecordsGateway {\n    export type Interface = IListLockRecordsGateway;\n}\n\nexport interface IListLockRecordsUseCase {\n    execute(params: IListLockRecordsParams): Promise<IRecordLockingLockRecord[]>;\n}\n\nexport const ListLockRecordsUseCase =\n    createAbstraction<IListLockRecordsUseCase>(\"ListLockRecordsUseCase\");\n\nexport namespace ListLockRecordsUseCase {\n    export type Interface = IListLockRecordsUseCase;\n}\n"],"names":["ListLockRecordsGateway","createAbstraction","ListLockRecordsUseCase"],"mappings":";AAeO,MAAMA,yBACTC,kBAA2C;AAUxC,MAAMC,yBACTD,kBAA2C"}

package/features/listLockRecords/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const ListLockRecordsFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").IListLockRecordsUseCase;
+}, []>;

package/features/listLockRecords/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ListLockRecordsUseCase } from "./abstractions.js";
+import { ListLockRecordsUseCase as external_ListLockRecordsUseCase_js_ListLockRecordsUseCase } from "./ListLockRecordsUseCase.js";
+import { ListLockRecordsGateway } from "./ListLockRecordsGateway.js";
+const ListLockRecordsFeature = createFeature({
+    name: "RecordLocking/ListLockRecords",
+    register (container) {
+        container.register(external_ListLockRecordsUseCase_js_ListLockRecordsUseCase);
+        container.register(ListLockRecordsGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(ListLockRecordsUseCase)
+        };
+    }
+});
+export { ListLockRecordsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/listLockRecords/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/listLockRecords/feature.js","sources":["../../../src/features/listLockRecords/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ListLockRecordsUseCase as UseCase } from \"./abstractions.js\";\nimport { ListLockRecordsUseCase } from \"./ListLockRecordsUseCase.js\";\nimport { ListLockRecordsGateway } from \"./ListLockRecordsGateway.js\";\n\nexport const ListLockRecordsFeature = createFeature({\n    name: \"RecordLocking/ListLockRecords\",\n    register(container) {\n        container.register(ListLockRecordsUseCase);\n        container.register(ListLockRecordsGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["ListLockRecordsFeature","createFeature","container","ListLockRecordsUseCase","ListLockRecordsGateway","UseCase"],"mappings":";;;;AAKO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,wBAAwB,gBAAgB;IAC/D;IACA,SAAQF,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACG;QAC/B;IACJ;AACJ"}

package/features/permissions/abstractions.d.ts

@@ -0,0 +1,17 @@
+import type { Permissions } from "@webiny/app-admin/exports/admin/security.js";
+import { RECORD_LOCKING_PERMISSIONS_SCHEMA } from "../../permissions/permissionsSchema.js";
+export declare const RecordLockingPermissions: import("@webiny/di").Abstraction<{
+    canAccess: (entityId: never) => boolean;
+    canAction: (action: string, entityId: never) => boolean;
+} & {
+    canRead: (entityId: string) => boolean;
+    canCreate: (entityId: string) => boolean;
+    canEdit: (entityId: string, item?: import("@webiny/app-admin/permissions").OwnableItem) => boolean;
+    canDelete: (entityId: string, item?: import("@webiny/app-admin/permissions").OwnableItem) => boolean;
+} & {
+    canPublish: (entityId: string) => boolean;
+    canUnpublish: (entityId: string) => boolean;
+}>;
+export declare namespace RecordLockingPermissions {
+    type Interface = Permissions<typeof RECORD_LOCKING_PERMISSIONS_SCHEMA>;
+}

package/features/permissions/abstractions.js

@@ -0,0 +1,6 @@
+import { createPermissionsAbstraction } from "@webiny/app-admin/exports/admin/security.js";
+import { RECORD_LOCKING_PERMISSIONS_SCHEMA } from "../../permissions/permissionsSchema.js";
+const RecordLockingPermissions = createPermissionsAbstraction(RECORD_LOCKING_PERMISSIONS_SCHEMA);
+export { RecordLockingPermissions };
+
+//# sourceMappingURL=abstractions.js.map

package/features/permissions/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/permissions/abstractions.js","sources":["../../../src/features/permissions/abstractions.ts"],"sourcesContent":["import { createPermissionsAbstraction } from \"@webiny/app-admin/exports/admin/security.js\";\nimport type { Permissions } from \"@webiny/app-admin/exports/admin/security.js\";\nimport { RECORD_LOCKING_PERMISSIONS_SCHEMA } from \"~/permissions/permissionsSchema.js\";\n\nexport const RecordLockingPermissions = createPermissionsAbstraction(\n    RECORD_LOCKING_PERMISSIONS_SCHEMA\n);\n\nexport namespace RecordLockingPermissions {\n    export type Interface = Permissions<typeof RECORD_LOCKING_PERMISSIONS_SCHEMA>;\n}\n"],"names":["RecordLockingPermissions","createPermissionsAbstraction","RECORD_LOCKING_PERMISSIONS_SCHEMA"],"mappings":";;AAIO,MAAMA,2BAA2BC,6BACpCC"}

package/features/permissions/feature.d.ts

@@ -0,0 +1,14 @@
+export declare const RecordLockingPermissionsFeature: import("@webiny/feature/admin/createFeature.js").FeatureDefinition<{
+    permissions: {
+        canAccess: (entityId: never) => boolean;
+        canAction: (action: string, entityId: never) => boolean;
+    } & {
+        canRead: (entityId: string) => boolean;
+        canCreate: (entityId: string) => boolean;
+        canEdit: (entityId: string, item?: import("@webiny/app-admin/index.js").OwnableItem) => boolean;
+        canDelete: (entityId: string, item?: import("@webiny/app-admin/index.js").OwnableItem) => boolean;
+    } & {
+        canPublish: (entityId: string) => boolean;
+        canUnpublish: (entityId: string) => boolean;
+    };
+}, []>;

package/features/permissions/feature.js

@@ -0,0 +1,7 @@
+import { createPermissionsFeature } from "@webiny/app-admin/exports/admin/security.js";
+import { RECORD_LOCKING_PERMISSIONS_SCHEMA } from "../../permissions/permissionsSchema.js";
+import { RecordLockingPermissions } from "./abstractions.js";
+const RecordLockingPermissionsFeature = createPermissionsFeature(RECORD_LOCKING_PERMISSIONS_SCHEMA, RecordLockingPermissions);
+export { RecordLockingPermissionsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/permissions/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/permissions/feature.js","sources":["../../../src/features/permissions/feature.ts"],"sourcesContent":["import { createPermissionsFeature } from \"@webiny/app-admin/exports/admin/security.js\";\nimport { RECORD_LOCKING_PERMISSIONS_SCHEMA } from \"~/permissions/permissionsSchema.js\";\nimport { RecordLockingPermissions } from \"./abstractions.js\";\n\nexport const RecordLockingPermissionsFeature = createPermissionsFeature(\n    RECORD_LOCKING_PERMISSIONS_SCHEMA,\n    RecordLockingPermissions\n);\n"],"names":["RecordLockingPermissionsFeature","createPermissionsFeature","RECORD_LOCKING_PERMISSIONS_SCHEMA","RecordLockingPermissions"],"mappings":";;;AAIO,MAAMA,kCAAkCC,yBAC3CC,mCACAC"}

package/features/releaseLock/ReleaseLockGateway.d.ts

@@ -0,0 +1,12 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { ReleaseLockGateway as GatewayAbstraction, type IReleaseLockParams } from "./abstractions.js";
+import type { IRecordLockingLockRecord } from "../../types.js";
+declare class ReleaseLockGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: MainGraphQLClient.Interface);
+    execute(params: IReleaseLockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const ReleaseLockGateway: typeof ReleaseLockGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IReleaseLockGateway>;
+};
+export {};

package/features/releaseLock/ReleaseLockGateway.js

@@ -0,0 +1,44 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { ERROR_FIELDS, LOCK_RECORD_FIELDS } from "../graphqlFields.js";
+import { ReleaseLockGateway } from "./abstractions.js";
+const RELEASE_LOCK_MUTATION = `
+    mutation RecordLockingUnlockEntry($id: ID!, $type: String!, $force: Boolean) {
+        recordLocking {
+            unlockEntry(id: $id, type: $type, force: $force) {
+                data {
+                    ${LOCK_RECORD_FIELDS}
+                }
+                error {
+                    ${ERROR_FIELDS}
+                }
+            }
+        }
+    }
+`;
+class ReleaseLockGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const response = await this.client.execute({
+            query: RELEASE_LOCK_MUTATION,
+            variables: {
+                id: params.id,
+                type: params.type,
+                force: false
+            }
+        });
+        const { data, error } = response.recordLocking.unlockEntry;
+        if (!data) throw new Error(error?.message || "Failed to release lock");
+        return data;
+    }
+}
+const ReleaseLockGateway_ReleaseLockGateway = ReleaseLockGateway.createImplementation({
+    implementation: ReleaseLockGatewayImpl,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { ReleaseLockGateway_ReleaseLockGateway as ReleaseLockGateway };
+
+//# sourceMappingURL=ReleaseLockGateway.js.map

package/features/releaseLock/ReleaseLockGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/releaseLock/ReleaseLockGateway.js","sources":["../../../src/features/releaseLock/ReleaseLockGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/abstractions.js\";\nimport { LOCK_RECORD_FIELDS, ERROR_FIELDS } from \"~/features/graphqlFields.js\";\nimport {\n    ReleaseLockGateway as GatewayAbstraction,\n    type IReleaseLockParams\n} from \"./abstractions.js\";\nimport type { IRecordLockingError, IRecordLockingLockRecord } from \"~/types.js\";\n\ninterface ReleaseLockResponse {\n    recordLocking: {\n        unlockEntry: {\n            data: IRecordLockingLockRecord | null;\n            error: IRecordLockingError | null;\n        };\n    };\n}\n\nconst RELEASE_LOCK_MUTATION = /* GraphQL */ `\n    mutation RecordLockingUnlockEntry($id: ID!, $type: String!, $force: Boolean) {\n        recordLocking {\n            unlockEntry(id: $id, type: $type, force: $force) {\n                data {\n                    ${LOCK_RECORD_FIELDS}\n                }\n                error {\n                    ${ERROR_FIELDS}\n                }\n            }\n        }\n    }\n`;\n\nclass ReleaseLockGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async execute(params: IReleaseLockParams) {\n        const response = await this.client.execute<ReleaseLockResponse>({\n            query: RELEASE_LOCK_MUTATION,\n            variables: { id: params.id, type: params.type, force: false }\n        });\n\n        const { data, error } = response.recordLocking.unlockEntry;\n\n        if (!data) {\n            throw new Error(error?.message || \"Failed to release lock\");\n        }\n\n        return data;\n    }\n}\n\nexport const ReleaseLockGateway = GatewayAbstraction.createImplementation({\n    implementation: ReleaseLockGatewayImpl,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["RELEASE_LOCK_MUTATION","LOCK_RECORD_FIELDS","ERROR_FIELDS","ReleaseLockGatewayImpl","client","params","response","data","error","Error","ReleaseLockGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;;AAiBA,MAAMA,wBAAsC,CAAC;;;;;oBAKzB,EAAEC,mBAAmB;;;oBAGrB,EAAEC,aAAa;;;;;AAKnC,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,QAAQC,MAA0B,EAAE;QACtC,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAsB;YAC5D,OAAON;YACP,WAAW;gBAAE,IAAIK,OAAO,EAAE;gBAAE,MAAMA,OAAO,IAAI;gBAAE,OAAO;YAAM;QAChE;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,aAAa,CAAC,WAAW;QAE1D,IAAI,CAACC,MACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBR;IAChB,cAAc;QAACS;KAAkB;AACrC"}

package/features/releaseLock/ReleaseLockUseCase.d.ts

@@ -0,0 +1,10 @@
+import { ReleaseLockUseCase as UseCaseAbstraction, ReleaseLockGateway, type IReleaseLockParams } from "./abstractions.js";
+declare class ReleaseLockUseCaseImpl implements UseCaseAbstraction.Interface {
+    private gateway;
+    constructor(gateway: ReleaseLockGateway.Interface);
+    execute(params: IReleaseLockParams): Promise<import("../../types.js").IRecordLockingLockRecord>;
+}
+export declare const ReleaseLockUseCase: typeof ReleaseLockUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IReleaseLockUseCase>;
+};
+export {};

package/features/releaseLock/ReleaseLockUseCase.js

@@ -0,0 +1,18 @@
+import { ReleaseLockGateway, ReleaseLockUseCase } from "./abstractions.js";
+class ReleaseLockUseCaseImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        return this.gateway.execute(params);
+    }
+}
+const ReleaseLockUseCase_ReleaseLockUseCase = ReleaseLockUseCase.createImplementation({
+    implementation: ReleaseLockUseCaseImpl,
+    dependencies: [
+        ReleaseLockGateway
+    ]
+});
+export { ReleaseLockUseCase_ReleaseLockUseCase as ReleaseLockUseCase };
+
+//# sourceMappingURL=ReleaseLockUseCase.js.map

package/features/releaseLock/ReleaseLockUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/releaseLock/ReleaseLockUseCase.js","sources":["../../../src/features/releaseLock/ReleaseLockUseCase.ts"],"sourcesContent":["import {\n    ReleaseLockUseCase as UseCaseAbstraction,\n    ReleaseLockGateway,\n    type IReleaseLockParams\n} from \"./abstractions.js\";\n\nclass ReleaseLockUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: ReleaseLockGateway.Interface) {}\n\n    async execute(params: IReleaseLockParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const ReleaseLockUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ReleaseLockUseCaseImpl,\n    dependencies: [ReleaseLockGateway]\n});\n"],"names":["ReleaseLockUseCaseImpl","gateway","params","ReleaseLockUseCase","UseCaseAbstraction","ReleaseLockGateway"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,OAAqC,CAAE;aAAvCA,OAAO,GAAPA;IAAwC;IAE5D,MAAM,QAAQC,MAA0B,EAAE;QACtC,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;IAChC;AACJ;AAEO,MAAMC,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBJ;IAChB,cAAc;QAACK;KAAmB;AACtC"}

package/features/releaseLock/abstractions.d.ts

@@ -0,0 +1,19 @@
+import type { IRecordLockingLockRecord } from "../../types.js";
+export interface IReleaseLockParams {
+    id: string;
+    type: string;
+}
+export interface IReleaseLockGateway {
+    execute(params: IReleaseLockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const ReleaseLockGateway: import("@webiny/di").Abstraction<IReleaseLockGateway>;
+export declare namespace ReleaseLockGateway {
+    type Interface = IReleaseLockGateway;
+}
+export interface IReleaseLockUseCase {
+    execute(params: IReleaseLockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const ReleaseLockUseCase: import("@webiny/di").Abstraction<IReleaseLockUseCase>;
+export declare namespace ReleaseLockUseCase {
+    type Interface = IReleaseLockUseCase;
+}

package/features/releaseLock/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const ReleaseLockGateway = createAbstraction("ReleaseLockGateway");
+const ReleaseLockUseCase = createAbstraction("ReleaseLockUseCase");
+export { ReleaseLockGateway, ReleaseLockUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/releaseLock/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/releaseLock/abstractions.js","sources":["../../../src/features/releaseLock/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { IRecordLockingLockRecord } from \"~/types.js\";\n\nexport interface IReleaseLockParams {\n    id: string;\n    type: string;\n}\n\nexport interface IReleaseLockGateway {\n    execute(params: IReleaseLockParams): Promise<IRecordLockingLockRecord>;\n}\n\nexport const ReleaseLockGateway = createAbstraction<IReleaseLockGateway>(\"ReleaseLockGateway\");\n\nexport namespace ReleaseLockGateway {\n    export type Interface = IReleaseLockGateway;\n}\n\nexport interface IReleaseLockUseCase {\n    execute(params: IReleaseLockParams): Promise<IRecordLockingLockRecord>;\n}\n\nexport const ReleaseLockUseCase = createAbstraction<IReleaseLockUseCase>(\"ReleaseLockUseCase\");\n\nexport namespace ReleaseLockUseCase {\n    export type Interface = IReleaseLockUseCase;\n}\n"],"names":["ReleaseLockGateway","createAbstraction","ReleaseLockUseCase"],"mappings":";AAYO,MAAMA,qBAAqBC,kBAAuC;AAUlE,MAAMC,qBAAqBD,kBAAuC"}

package/features/releaseLock/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const ReleaseLockFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").IReleaseLockUseCase;
+}, []>;

package/features/releaseLock/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ReleaseLockUseCase } from "./abstractions.js";
+import { ReleaseLockUseCase as external_ReleaseLockUseCase_js_ReleaseLockUseCase } from "./ReleaseLockUseCase.js";
+import { ReleaseLockGateway } from "./ReleaseLockGateway.js";
+const ReleaseLockFeature = createFeature({
+    name: "RecordLocking/ReleaseLock",
+    register (container) {
+        container.register(external_ReleaseLockUseCase_js_ReleaseLockUseCase);
+        container.register(ReleaseLockGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(ReleaseLockUseCase)
+        };
+    }
+});
+export { ReleaseLockFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/releaseLock/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/releaseLock/feature.js","sources":["../../../src/features/releaseLock/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ReleaseLockUseCase as UseCase } from \"./abstractions.js\";\nimport { ReleaseLockUseCase } from \"./ReleaseLockUseCase.js\";\nimport { ReleaseLockGateway } from \"./ReleaseLockGateway.js\";\n\nexport const ReleaseLockFeature = createFeature({\n    name: \"RecordLocking/ReleaseLock\",\n    register(container) {\n        container.register(ReleaseLockUseCase);\n        container.register(ReleaseLockGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["ReleaseLockFeature","createFeature","container","ReleaseLockUseCase","ReleaseLockGateway","UseCase"],"mappings":";;;;AAKO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,oBAAoB,gBAAgB;IAC3D;IACA,SAAQF,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACG;QAC/B;IACJ;AACJ"}

package/index.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const RecordLocking: () => React.JSX.Element | null;

package/index.js

@@ -0,0 +1,24 @@
+import react from "react";
+import { RegisterFeature, useFeatureFlags } from "@webiny/app-admin";
+import { RecordLockingFeature } from "./features/feature.js";
+import { RecordLockingPermissionsFeature } from "./features/permissions/feature.js";
+import { RecordLockingPresenterFeature } from "./presentation/entryLocking/feature.js";
+import { ListLockRecordsPresenterFeature } from "./presentation/listLocking/feature.js";
+import { SecurityPermissions } from "./SecurityPermissions.js";
+import { RecordLockingModule } from "./RecordLockingModule.js";
+const RecordLocking = ()=>{
+    const featureFlags = useFeatureFlags();
+    if (!featureFlags.isEnabled("recordLocking")) return null;
+    return /*#__PURE__*/ react.createElement(react.Fragment, null, /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: RecordLockingPermissionsFeature
+    }), /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: RecordLockingFeature
+    }), /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: RecordLockingPresenterFeature
+    }), /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: ListLockRecordsPresenterFeature
+    }), /*#__PURE__*/ react.createElement(SecurityPermissions, null), /*#__PURE__*/ react.createElement(RecordLockingModule, null));
+};
+export { RecordLocking };
+
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/index.tsx"],"sourcesContent":["import React from \"react\";\nimport { RegisterFeature } from \"@webiny/app-admin\";\nimport { useFeatureFlags } from \"@webiny/app-admin\";\nimport { RecordLockingFeature } from \"~/features/feature.js\";\nimport { RecordLockingPermissionsFeature } from \"~/features/permissions/feature.js\";\nimport { RecordLockingPresenterFeature } from \"~/presentation/entryLocking/feature.js\";\nimport { ListLockRecordsPresenterFeature } from \"~/presentation/listLocking/feature.js\";\nimport { SecurityPermissions } from \"~/SecurityPermissions.js\";\nimport { RecordLockingModule } from \"~/RecordLockingModule.js\";\n\nexport const RecordLocking = () => {\n    const featureFlags = useFeatureFlags();\n\n    if (!featureFlags.isEnabled(\"recordLocking\")) {\n        return null;\n    }\n\n    return (\n        <>\n            <RegisterFeature feature={RecordLockingPermissionsFeature} />\n            <RegisterFeature feature={RecordLockingFeature} />\n            <RegisterFeature feature={RecordLockingPresenterFeature} />\n            <RegisterFeature feature={ListLockRecordsPresenterFeature} />\n            <SecurityPermissions />\n            <RecordLockingModule />\n        </>\n    );\n};\n"],"names":["RecordLocking","featureFlags","useFeatureFlags","RegisterFeature","RecordLockingPermissionsFeature","RecordLockingFeature","RecordLockingPresenterFeature","ListLockRecordsPresenterFeature","SecurityPermissions","RecordLockingModule"],"mappings":";;;;;;;;AAUO,MAAMA,gBAAgB;IACzB,MAAMC,eAAeC;IAErB,IAAI,CAACD,aAAa,SAAS,CAAC,kBACxB,OAAO;IAGX,OAAO,WAAP,GACI,wDACI,oBAACE,iBAAeA;QAAC,SAASC;sBAC1B,oBAACD,iBAAeA;QAAC,SAASE;sBAC1B,oBAACF,iBAAeA;QAAC,SAASG;sBAC1B,oBAACH,iBAAeA;QAAC,SAASI;sBAC1B,oBAACC,qBAAmBA,OAAAA,WAAAA,GACpB,oBAACC,qBAAmBA;AAGhC"}

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@webiny/app-record-locking",
+	"version": "0.0.0-unstable.0156a4c312",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git"
+	},
+	"contributors": [
+		"Pavel Denisjuk <pavel@webiny.com>",
+		"Sven Al Hamad <sven@webiny.com>",
+		"Adrian Smijulj <adrian@webiny.com>"
+	],
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/admin-ui": "0.0.0-unstable.0156a4c312",
+		"@webiny/app": "0.0.0-unstable.0156a4c312",
+		"@webiny/app-admin": "0.0.0-unstable.0156a4c312",
+		"@webiny/app-headless-cms": "0.0.0-unstable.0156a4c312",
+		"@webiny/app-websockets": "0.0.0-unstable.0156a4c312",
+		"@webiny/feature": "0.0.0-unstable.0156a4c312",
+		"@webiny/icons": "0.0.0-unstable.0156a4c312",
+		"@webiny/utils": "0.0.0-unstable.0156a4c312",
+		"mobx": "7.1.4",
+		"mobx-react-lite": "5.1.2",
+		"react": "19.3.1",
+		"react-dom": "19.3.1"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "0.0.0-unstable.0156a4c312",
+		"rimraf": "6.1.3",
+		"typescript": "7.0.2"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"gitHead": "8476da73b653c89cc1474d968baf55c1b0ae0e5f",
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

package/permissions/permissionsSchema.d.ts

@@ -0,0 +1,6 @@
+export declare const RECORD_LOCKING_PERMISSIONS_SCHEMA: {
+    readonly prefix: "recordLocking";
+    readonly fullAccess: {
+        readonly canForceUnlock: true;
+    };
+};

package/permissions/permissionsSchema.js

@@ -0,0 +1,10 @@
+import { createPermissionSchema } from "@webiny/app-admin";
+const RECORD_LOCKING_PERMISSIONS_SCHEMA = createPermissionSchema({
+    prefix: "recordLocking",
+    fullAccess: {
+        canForceUnlock: true
+    }
+});
+export { RECORD_LOCKING_PERMISSIONS_SCHEMA };
+
+//# sourceMappingURL=permissionsSchema.js.map