@prosopo/user-access-policy 3.12.8 → 3.12.10

package/dist/api/write/insertRules.js

@@ -1,105 +1,87 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { accessPolicyInput, policyScopeInput, sanitizeAccessPolicy } from "../../ruleInput/policyInput.js";
+import { userScopeInput } from "../../ruleInput/userScopeInput.js";
+import { z } from "zod";
 import { ApiEndpointResponseStatus } from "@prosopo/api-route";
 import { LogLevel } from "@prosopo/logger";
-import { z } from "zod";
-import { policyScopeInput, accessPolicyInput, sanitizeAccessPolicy } from "../../ruleInput/policyInput.js";
-import { userScopeInput } from "../../ruleInput/userScopeInput.js";
-class InsertRulesEndpoint {
-  constructor(accessRulesWriter, logger) {
-    this.accessRulesWriter = accessRulesWriter;
-    this.logger = logger;
-  }
-  getRequestArgsSchema() {
-    return z.array(
-      z.object({
-        accessPolicy: accessPolicyInput,
-        policyScopes: z.array(policyScopeInput).optional(),
-        groupId: z.string().optional(),
-        userScopes: z.array(userScopeInput),
-        expiresUnixTimestamp: z.number().optional()
-      })
-    );
-  }
-  async processRequest(args, logger) {
-    const log = logger ?? this.logger;
-    const timeoutPromise = new Promise((resolve) => {
-      setTimeout(() => {
-        resolve({
-          status: ApiEndpointResponseStatus.PROCESSING
-        });
-      }, 5e3);
-    });
-    const userScopesCount = args.reduce(
-      (userScopesCount2, group) => userScopesCount2 + group.userScopes.length,
-      0
-    );
-    const createRulesPromise = this.createRuleGroups(args).then((insertedIds) => {
-      log.info(() => ({
-        msg: "Endpoint inserted access rules",
-        data: {
-          userScopesCount,
-          insertedCount: insertedIds.length,
-          uniqueIdsCount: new Set(insertedIds).size
-        }
-      }));
-      log.debug(() => ({
-        msg: "Inserted access rules details",
-        data: {
-          insertedIds,
-          input: args
-        }
-      }));
-      return {
-        status: ApiEndpointResponseStatus.SUCCESS
-      };
-    }).catch((error) => {
-      if (LogLevel.enum.debug === log.getLogLevel()) {
-        log.error(() => ({
-          err: error,
-          data: { args },
-          msg: "Failed to insert access rules"
-        }));
-      }
-      return {
-        status: ApiEndpointResponseStatus.FAIL
-      };
-    });
-    return Promise.race([timeoutPromise, createRulesPromise]);
-  }
-  async createRuleGroups(groups) {
-    const ruleIdPromises = groups.map((group) => this.createRulesGroup(group));
-    const ruleIdSets = await Promise.all(ruleIdPromises);
-    return ruleIdSets.flat();
-  }
-  async createRulesGroup(group) {
-    const ruleEntries = [];
-    const policyScopes = group.policyScopes || [];
-    const sanitizedPolicy = sanitizeAccessPolicy(group.accessPolicy);
-    for (const userScope of group.userScopes) {
-      const ruleBase = {
-        ...sanitizedPolicy,
-        ...userScope,
-        ...group.groupId ? { groupId: group.groupId } : {}
-      };
-      if (policyScopes.length > 0) {
-        for (const policyScope of policyScopes) {
-          ruleEntries.push({
-            rule: {
-              ...ruleBase,
-              ...policyScope
-            },
-            expiresUnixTimestamp: group.expiresUnixTimestamp
-          });
-        }
-      } else {
-        ruleEntries.push({
-          rule: ruleBase,
-          expiresUnixTimestamp: group.expiresUnixTimestamp
-        });
-      }
-    }
-    return this.accessRulesWriter.insertRules(ruleEntries);
-  }
-}
-export {
-  InsertRulesEndpoint
+//#region src/api/write/insertRules.ts
+var InsertRulesEndpoint = class {
+	constructor(accessRulesWriter, logger) {
+		this.accessRulesWriter = accessRulesWriter;
+		this.logger = logger;
+	}
+	getRequestArgsSchema() {
+		return z.array(z.object({
+			accessPolicy: accessPolicyInput,
+			policyScopes: z.array(policyScopeInput).optional(),
+			groupId: z.string().optional(),
+			userScopes: z.array(userScopeInput),
+			expiresUnixTimestamp: z.number().optional()
+		}));
+	}
+	async processRequest(args, logger) {
+		const log = logger ?? this.logger;
+		const timeoutPromise = new Promise((resolve) => {
+			setTimeout(() => {
+				resolve({ status: ApiEndpointResponseStatus.PROCESSING });
+			}, 5e3);
+		});
+		const userScopesCount = args.reduce((userScopesCount, group) => userScopesCount + group.userScopes.length, 0);
+		const createRulesPromise = this.createRuleGroups(args).then((insertedIds) => {
+			log.info(() => ({
+				msg: "Endpoint inserted access rules",
+				data: {
+					userScopesCount,
+					insertedCount: insertedIds.length,
+					uniqueIdsCount: new Set(insertedIds).size
+				}
+			}));
+			log.debug(() => ({
+				msg: "Inserted access rules details",
+				data: {
+					insertedIds,
+					input: args
+				}
+			}));
+			return { status: ApiEndpointResponseStatus.SUCCESS };
+		}).catch((error) => {
+			if (LogLevel.enum.debug === log.getLogLevel()) log.error(() => ({
+				err: error,
+				data: { args },
+				msg: "Failed to insert access rules"
+			}));
+			return { status: ApiEndpointResponseStatus.FAIL };
+		});
+		return Promise.race([timeoutPromise, createRulesPromise]);
+	}
+	async createRuleGroups(groups) {
+		const ruleIdPromises = groups.map((group) => this.createRulesGroup(group));
+		return (await Promise.all(ruleIdPromises)).flat();
+	}
+	async createRulesGroup(group) {
+		const ruleEntries = [];
+		const policyScopes = group.policyScopes || [];
+		const sanitizedPolicy = sanitizeAccessPolicy(group.accessPolicy);
+		for (const userScope of group.userScopes) {
+			const ruleBase = {
+				...sanitizedPolicy,
+				...userScope,
+				...group.groupId ? { groupId: group.groupId } : {}
+			};
+			if (policyScopes.length > 0) for (const policyScope of policyScopes) ruleEntries.push({
+				rule: {
+					...ruleBase,
+					...policyScope
+				},
+				expiresUnixTimestamp: group.expiresUnixTimestamp
+			});
+			else ruleEntries.push({
+				rule: ruleBase,
+				expiresUnixTimestamp: group.expiresUnixTimestamp
+			});
+		}
+		return this.accessRulesWriter.insertRules(ruleEntries);
+	}
 };
+//#endregion
+export { InsertRulesEndpoint };

package/dist/api/write/rehashRules.js

@@ -1,58 +1,50 @@
+import "../../_virtual/_rolldown/runtime.js";
 import { ApiEndpointResponseStatus } from "@prosopo/api-route";
-class RehashRulesEndpoint {
-  constructor(accessRulesStorage, logger) {
-    this.accessRulesStorage = accessRulesStorage;
-    this.logger = logger;
-  }
-  getRequestArgsSchema() {
-  }
-  async processRequest(logger) {
-    const log = logger ?? this.logger;
-    await this.accessRulesStorage.fetchAllRuleIds(async (ruleIds) => {
-      log.info(() => ({
-        msg: "Fetched rule ids batch",
-        data: {
-          count: ruleIds.length,
-          ruleIds
-        }
-      }));
-      const ruleEntries = await this.accessRulesStorage.fetchRules(ruleIds);
-      log.info(() => ({
-        msg: "Fetched rules",
-        data: {
-          count: ruleEntries.length
-        }
-      }));
-      if (ruleEntries.length !== ruleIds.length) {
-        log.warn(() => ({
-          msg: "Fetched rules count is not equal to the requested count",
-          data: {
-            fetchedCount: ruleEntries.length,
-            requestedCount: ruleIds.length
-          }
-        }));
-      }
-      await this.accessRulesStorage.deleteRules(ruleIds);
-      log.info(() => ({
-        msg: "Deleted rules",
-        data: {
-          count: ruleIds.length
-        }
-      }));
-      await this.accessRulesStorage.insertRules(ruleEntries);
-      log.info(() => ({
-        msg: "Inserted rules",
-        data: {
-          count: ruleEntries.length
-        }
-      }));
-    });
-    return {
-      status: ApiEndpointResponseStatus.SUCCESS,
-      data: {}
-    };
-  }
-}
-export {
-  RehashRulesEndpoint
+//#region src/api/write/rehashRules.ts
+var RehashRulesEndpoint = class {
+	constructor(accessRulesStorage, logger) {
+		this.accessRulesStorage = accessRulesStorage;
+		this.logger = logger;
+	}
+	getRequestArgsSchema() {}
+	async processRequest(logger) {
+		const log = logger ?? this.logger;
+		await this.accessRulesStorage.fetchAllRuleIds(async (ruleIds) => {
+			log.info(() => ({
+				msg: "Fetched rule ids batch",
+				data: {
+					count: ruleIds.length,
+					ruleIds
+				}
+			}));
+			const ruleEntries = await this.accessRulesStorage.fetchRules(ruleIds);
+			log.info(() => ({
+				msg: "Fetched rules",
+				data: { count: ruleEntries.length }
+			}));
+			if (ruleEntries.length !== ruleIds.length) log.warn(() => ({
+				msg: "Fetched rules count is not equal to the requested count",
+				data: {
+					fetchedCount: ruleEntries.length,
+					requestedCount: ruleIds.length
+				}
+			}));
+			await this.accessRulesStorage.deleteRules(ruleIds);
+			log.info(() => ({
+				msg: "Deleted rules",
+				data: { count: ruleIds.length }
+			}));
+			await this.accessRulesStorage.insertRules(ruleEntries);
+			log.info(() => ({
+				msg: "Inserted rules",
+				data: { count: ruleEntries.length }
+			}));
+		});
+		return {
+			status: ApiEndpointResponseStatus.SUCCESS,
+			data: {}
+		};
+	}
 };
+//#endregion
+export { RehashRulesEndpoint };

package/dist/cjs/.export.cjs

@@ -1,24 +1,22 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./ruleInput/.export.cjs");
-const transformRule = require("./transformRule.cjs");
-const rule = require("./rule.cjs");
-const classifyOs = require("./classifyOs.cjs");
-const rulesStorage = require("./rulesStorage.cjs");
-const ruleRecord = require("./ruleRecord.cjs");
-const ruleInput = require("./ruleInput/ruleInput.cjs");
-const policyInput = require("./ruleInput/policyInput.cjs");
-const userScopeInput = require("./ruleInput/userScopeInput.cjs");
-exports.makeAccessRuleHash = transformRule.makeAccessRuleHash;
-exports.transformAccessRuleIntoRecord = transformRule.transformAccessRuleIntoRecord;
-exports.transformAccessRuleRecordIntoRule = transformRule.transformAccessRuleRecordIntoRule;
-exports.AccessPolicyType = rule.AccessPolicyType;
-exports.OS_NAMES = classifyOs.OS_NAMES;
-exports.classifyOs = classifyOs.classifyOs;
-exports.FilterScopeMatch = rulesStorage.FilterScopeMatch;
-exports.getUserScopeRecordFromAccessRuleRecord = ruleRecord.getUserScopeRecordFromAccessRuleRecord;
-exports.userScopeRecordFields = ruleRecord.userScopeRecordFields;
-exports.accessRuleInput = ruleInput.accessRuleInput;
-exports.accessPolicyInput = policyInput.accessPolicyInput;
-exports.policyScopeInput = policyInput.policyScopeInput;
-exports.userScopeInput = userScopeInput.userScopeInput;
+const require_rulesStorage = require("./rulesStorage.cjs");
+const require_rule = require("./rule.cjs");
+const require_ruleInput_policyInput = require("./ruleInput/policyInput.cjs");
+const require_ruleInput_userScopeInput = require("./ruleInput/userScopeInput.cjs");
+const require_ruleInput_ruleInput = require("./ruleInput/ruleInput.cjs");
+const require_transformRule = require("./transformRule.cjs");
+const require_classifyOs = require("./classifyOs.cjs");
+const require_ruleRecord = require("./ruleRecord.cjs");
+exports.AccessPolicyType = require_rule.AccessPolicyType;
+exports.FilterScopeMatch = require_rulesStorage.FilterScopeMatch;
+exports.OS_NAMES = require_classifyOs.OS_NAMES;
+exports.accessPolicyInput = require_ruleInput_policyInput.accessPolicyInput;
+exports.accessRuleInput = require_ruleInput_ruleInput.accessRuleInput;
+exports.classifyOs = require_classifyOs.classifyOs;
+exports.getUserScopeRecordFromAccessRuleRecord = require_ruleRecord.getUserScopeRecordFromAccessRuleRecord;
+exports.makeAccessRuleHash = require_transformRule.makeAccessRuleHash;
+exports.policyScopeInput = require_ruleInput_policyInput.policyScopeInput;
+exports.transformAccessRuleIntoRecord = require_transformRule.transformAccessRuleIntoRecord;
+exports.transformAccessRuleRecordIntoRule = require_transformRule.transformAccessRuleRecordIntoRule;
+exports.userScopeInput = require_ruleInput_userScopeInput.userScopeInput;
+exports.userScopeRecordFields = require_ruleRecord.userScopeRecordFields;

package/dist/cjs/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/dist/cjs/api/.export.cjs

@@ -1,11 +1,7 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./delete/.export.cjs");
-require("./read/.export.cjs");
-require("./write/.export.cjs");
-const ruleApiRoutes = require("./ruleApiRoutes.cjs");
-const rulesApiClient = require("./rulesApiClient.cjs");
-exports.AccessRuleApiRoutes = ruleApiRoutes.AccessRuleApiRoutes;
-exports.accessRuleApiPaths = ruleApiRoutes.accessRuleApiPaths;
-exports.getExpressApiRuleRateLimits = ruleApiRoutes.getExpressApiRuleRateLimits;
-exports.AccessRulesApiClient = rulesApiClient.AccessRulesApiClient;
+const require_api_ruleApiRoutes = require("./ruleApiRoutes.cjs");
+const require_api_rulesApiClient = require("./rulesApiClient.cjs");
+exports.AccessRuleApiRoutes = require_api_ruleApiRoutes.AccessRuleApiRoutes;
+exports.AccessRulesApiClient = require_api_rulesApiClient.AccessRulesApiClient;
+exports.accessRuleApiPaths = require_api_ruleApiRoutes.accessRuleApiPaths;
+exports.getExpressApiRuleRateLimits = require_api_ruleApiRoutes.getExpressApiRuleRateLimits;

package/dist/cjs/api/delete/.export.cjs

@@ -1 +0,0 @@
-"use strict";

package/dist/cjs/api/delete/deleteAllRules.cjs

@@ -1,26 +1,24 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const apiRoute = require("@prosopo/api-route");
-class DeleteAllRulesEndpoint {
-  constructor(accessRulesStorage, logger) {
-    this.accessRulesStorage = accessRulesStorage;
-    this.logger = logger;
-  }
-  getRequestArgsSchema() {
-  }
-  async processRequest(logger) {
-    const log = logger ?? this.logger;
-    const deletedCount = await this.accessRulesStorage.deleteAllRules();
-    log.info(() => ({
-      msg: "Endpoint deleted all access rules",
-      data: { deletedCount }
-    }));
-    return {
-      status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
-      data: {
-        deleted_count: deletedCount
-      }
-    };
-  }
-}
+let _prosopo_api_route = require("@prosopo/api-route");
+//#region src/api/delete/deleteAllRules.ts
+var DeleteAllRulesEndpoint = class {
+	constructor(accessRulesStorage, logger) {
+		this.accessRulesStorage = accessRulesStorage;
+		this.logger = logger;
+	}
+	getRequestArgsSchema() {}
+	async processRequest(logger) {
+		const log = logger ?? this.logger;
+		const deletedCount = await this.accessRulesStorage.deleteAllRules();
+		log.info(() => ({
+			msg: "Endpoint deleted all access rules",
+			data: { deletedCount }
+		}));
+		return {
+			status: _prosopo_api_route.ApiEndpointResponseStatus.SUCCESS,
+			data: { deleted_count: deletedCount }
+		};
+	}
+};
+//#endregion
 exports.DeleteAllRulesEndpoint = DeleteAllRulesEndpoint;

package/dist/cjs/api/delete/deleteRuleGroups.cjs

@@ -1,53 +1,41 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const apiRoute = require("@prosopo/api-route");
-const zod = require("zod");
-const rulesStorage = require("../../rulesStorage.cjs");
-class DeleteRuleGroupsEndpoint {
-  constructor(accessRulesStorage, logger) {
-    this.accessRulesStorage = accessRulesStorage;
-    this.logger = logger;
-  }
-  getRequestArgsSchema() {
-    return zod.z.array(
-      zod.z.object({
-        clientIds: zod.z.string().array(),
-        groupId: zod.z.string()
-      })
-    );
-  }
-  async processRequest(args, logger) {
-    const log = logger ?? this.logger;
-    const foundRuleIdPromises = args.flatMap(
-      (ruleToDelete) => ruleToDelete.clientIds.map(
-        (clientId) => this.accessRulesStorage.findRuleIds({
-          policyScope: {
-            clientId
-          },
-          policyScopeMatch: rulesStorage.FilterScopeMatch.Exact,
-          groupId: ruleToDelete.groupId
-        })
-      )
-    );
-    const foundRuleIds = await Promise.all(foundRuleIdPromises);
-    const ruleIds = foundRuleIds.flat();
-    const uniqueRuleIds = [...new Set(ruleIds)];
-    if (uniqueRuleIds.length > 0) {
-      await this.accessRulesStorage.deleteRules(uniqueRuleIds);
-    }
-    log.info(() => ({
-      msg: "Endpoint deleted rule groups",
-      data: {
-        args,
-        uniqueRuleIds
-      }
-    }));
-    return {
-      status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
-      data: {
-        deleted_count: uniqueRuleIds.length
-      }
-    };
-  }
-}
+const require_rulesStorage = require("../../rulesStorage.cjs");
+let zod = require("zod");
+let _prosopo_api_route = require("@prosopo/api-route");
+//#region src/api/delete/deleteRuleGroups.ts
+var DeleteRuleGroupsEndpoint = class {
+	constructor(accessRulesStorage, logger) {
+		this.accessRulesStorage = accessRulesStorage;
+		this.logger = logger;
+	}
+	getRequestArgsSchema() {
+		return zod.z.array(zod.z.object({
+			clientIds: zod.z.string().array(),
+			groupId: zod.z.string()
+		}));
+	}
+	async processRequest(args, logger) {
+		const log = logger ?? this.logger;
+		const foundRuleIdPromises = args.flatMap((ruleToDelete) => ruleToDelete.clientIds.map((clientId) => this.accessRulesStorage.findRuleIds({
+			policyScope: { clientId },
+			policyScopeMatch: require_rulesStorage.FilterScopeMatch.Exact,
+			groupId: ruleToDelete.groupId
+		})));
+		const ruleIds = (await Promise.all(foundRuleIdPromises)).flat();
+		const uniqueRuleIds = [...new Set(ruleIds)];
+		if (uniqueRuleIds.length > 0) await this.accessRulesStorage.deleteRules(uniqueRuleIds);
+		log.info(() => ({
+			msg: "Endpoint deleted rule groups",
+			data: {
+				args,
+				uniqueRuleIds
+			}
+		}));
+		return {
+			status: _prosopo_api_route.ApiEndpointResponseStatus.SUCCESS,
+			data: { deleted_count: uniqueRuleIds.length }
+		};
+	}
+};
+//#endregion
 exports.DeleteRuleGroupsEndpoint = DeleteRuleGroupsEndpoint;

package/dist/cjs/api/delete/deleteRules.cjs

@@ -1,44 +1,43 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const apiRoute = require("@prosopo/api-route");
-const common = require("@prosopo/common");
-const zod = require("zod");
-const ruleInput = require("../../ruleInput/ruleInput.cjs");
-class DeleteRulesEndpoint {
-  constructor(accessRulesStorage, logger) {
-    this.accessRulesStorage = accessRulesStorage;
-    this.logger = logger;
-  }
-  getRequestArgsSchema() {
-    return zod.z.array(ruleInput.accessRulesFilterInput);
-  }
-  async processRequest(args, logger) {
-    const log = logger ?? this.logger;
-    let deletedCount = 0;
-    for (const rulesFilterInput of args) {
-      const ruleFilters = ruleInput.getAccessRuleFiltersFromInput(rulesFilterInput);
-      await common.executeBatchesSequentially(ruleFilters, async (ruleFilter) => {
-        const ruleIds = await this.accessRulesStorage.findRuleIds(ruleFilter);
-        const uniqueRuleIds = [...new Set(ruleIds)];
-        if (uniqueRuleIds.length > 0) {
-          await this.accessRulesStorage.deleteRules(uniqueRuleIds);
-          deletedCount += uniqueRuleIds.length;
-          log.info(() => ({
-            msg: "Endpoint deleted rules",
-            data: {
-              rulesFilterInput,
-              uniqueRuleIds
-            }
-          }));
-        }
-      });
-    }
-    return {
-      status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
-      data: {
-        deleted_count: deletedCount
-      }
-    };
-  }
-}
+const require_ruleInput_ruleInput = require("../../ruleInput/ruleInput.cjs");
+let zod = require("zod");
+let _prosopo_api_route = require("@prosopo/api-route");
+let _prosopo_common = require("@prosopo/common");
+//#region src/api/delete/deleteRules.ts
+var DeleteRulesEndpoint = class {
+	constructor(accessRulesStorage, logger) {
+		this.accessRulesStorage = accessRulesStorage;
+		this.logger = logger;
+	}
+	getRequestArgsSchema() {
+		return zod.z.array(require_ruleInput_ruleInput.accessRulesFilterInput);
+	}
+	async processRequest(args, logger) {
+		const log = logger ?? this.logger;
+		let deletedCount = 0;
+		for (const rulesFilterInput of args) {
+			const ruleFilters = require_ruleInput_ruleInput.getAccessRuleFiltersFromInput(rulesFilterInput);
+			await (0, _prosopo_common.executeBatchesSequentially)(ruleFilters, async (ruleFilter) => {
+				const ruleIds = await this.accessRulesStorage.findRuleIds(ruleFilter);
+				const uniqueRuleIds = [...new Set(ruleIds)];
+				if (uniqueRuleIds.length > 0) {
+					await this.accessRulesStorage.deleteRules(uniqueRuleIds);
+					deletedCount += uniqueRuleIds.length;
+					log.info(() => ({
+						msg: "Endpoint deleted rules",
+						data: {
+							rulesFilterInput,
+							uniqueRuleIds
+						}
+					}));
+				}
+			});
+		}
+		return {
+			status: _prosopo_api_route.ApiEndpointResponseStatus.SUCCESS,
+			data: { deleted_count: deletedCount }
+		};
+	}
+};
+//#endregion
 exports.DeleteRulesEndpoint = DeleteRulesEndpoint;

package/dist/cjs/api/read/.export.cjs

@@ -1 +0,0 @@
-"use strict";