@prosopo/user-access-policy 3.5.19 → 3.5.28

package/dist/ruleInput/ruleInput.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { FilterScopeMatch } from "../rulesStorage.js";
+import { policyScopeInput, accessPolicyInput } from "./policyInput.js";
+import { userScopeInput } from "./userScopeInput.js";
+const ruleGroupInput = z.object({
+  groupId: z.coerce.string().optional(),
+  ruleGroupId: z.coerce.string().optional()
+}).transform((ruleGroupInput2) => {
+  const { ruleGroupId, ...ruleGroup } = ruleGroupInput2;
+  if ("string" === typeof ruleGroupId) {
+    ruleGroup.groupId = ruleGroupId;
+  }
+  return ruleGroup;
+});
+const accessRuleInput = z.object({
+  ...accessPolicyInput.shape,
+  ...policyScopeInput.shape
+}).and(userScopeInput).and(ruleGroupInput).transform((ruleInput) => ruleInput);
+const ruleEntryInput = z.object({
+  rule: accessRuleInput,
+  expiresUnixTimestamp: z.coerce.number().optional()
+});
+const accessRulesFilterInput = z.object({
+  policyScope: policyScopeInput.optional(),
+  policyScopes: z.array(policyScopeInput).optional(),
+  policyScopeMatch: z.nativeEnum(FilterScopeMatch).default(FilterScopeMatch.Exact),
+  userScope: userScopeInput.optional(),
+  userScopeMatch: z.nativeEnum(FilterScopeMatch).default(FilterScopeMatch.Exact),
+  groupId: z.string().optional()
+});
+const getAccessRuleFiltersFromInput = (filterInput) => {
+  const { policyScopes, policyScope, ...filterBase } = filterInput;
+  const allPolicyScopes = policyScopes || [];
+  if (policyScope) {
+    allPolicyScopes.push(policyScope);
+  }
+  if (allPolicyScopes.length > 0) {
+    return allPolicyScopes.map((policyScope2) => ({
+      ...filterBase,
+      policyScope: policyScope2
+    }));
+  }
+  return [filterBase];
+};
+export {
+  accessRuleInput,
+  accessRulesFilterInput,
+  getAccessRuleFiltersFromInput,
+  ruleEntryInput
+};

package/dist/ruleInput/userScopeInput.js

@@ -0,0 +1,55 @@
+import crypto from "node:crypto";
+import { getIPAddress } from "@prosopo/util";
+import { Address4 } from "ip-address";
+import { z } from "zod";
+const userAttributesSchema = z.object({
+  // coerce is used for safety, as e.g., incoming userId can be digital
+  userId: z.coerce.string().optional(),
+  ja4Hash: z.coerce.string().optional(),
+  headersHash: z.coerce.string().optional(),
+  userAgentHash: z.coerce.string().optional()
+});
+const userAttributesInput = z.object({
+  ...userAttributesSchema.shape,
+  userAgent: z.coerce.string().optional()
+}).transform((userAttributesInput2) => {
+  const { userAgent, ...userScope } = userAttributesInput2;
+  if ("string" === typeof userAgent) {
+    userScope.userAgentHash = hashUserAgent(userAgent);
+  }
+  return userScope;
+});
+const hashUserAgent = (userAgent) => crypto.createHash("sha256").update(userAgent).digest("hex");
+const userIpSchema = z.object({
+  numericIp: z.coerce.bigint().optional(),
+  numericIpMaskMin: z.coerce.bigint().optional(),
+  numericIpMaskMax: z.coerce.bigint().optional()
+});
+const userIpInput = z.object({
+  ...userIpSchema.shape,
+  ip: z.string().optional(),
+  ipMask: z.string().optional()
+}).transform((userIpInput2) => {
+  const { ip, ipMask, ...numericUserIp } = userIpInput2;
+  if ("string" === typeof ip) {
+    numericUserIp.numericIp = getIPAddress(ip).bigInt();
+  }
+  if ("string" === typeof ipMask) {
+    const ipObject = new Address4(ipMask);
+    numericUserIp.numericIpMaskMin = ipObject.startAddress().bigInt();
+    numericUserIp.numericIpMaskMax = ipObject.endAddress().bigInt();
+  }
+  return numericUserIp;
+});
+const userScopeSchema = z.object({
+  ...userIpSchema.shape,
+  ...userAttributesSchema.shape
+});
+const userScopeInput = z.object({}).and(userIpInput).and(userAttributesInput).transform(
+  // transform is used for type safety only - plain "satisfies ZodType<x>" doesn't work after ".and()"
+  (userScopeInput2) => userScopeInput2
+);
+export {
+  userScopeInput,
+  userScopeSchema
+};

package/dist/ruleRecord.js

@@ -0,0 +1,23 @@
+const userAttributesRecordFields = [
+  "userId",
+  "ja4Hash",
+  "headersHash",
+  "userAgent"
+];
+const userIpRecordFields = [
+  "ip",
+  "ipMask"
+];
+const userScopeRecordFields = [
+  ...userAttributesRecordFields,
+  ...userIpRecordFields
+];
+const getUserScopeRecordFromAccessRuleRecord = (ruleRecord) => Object.fromEntries(
+  userScopeRecordFields.map((field) => [field, ruleRecord[field]]).filter(([, value]) => value !== void 0)
+);
+export {
+  getUserScopeRecordFromAccessRuleRecord,
+  userAttributesRecordFields,
+  userIpRecordFields,
+  userScopeRecordFields
+};

package/dist/rulesStorage.js

@@ -0,0 +1,8 @@
+var FilterScopeMatch = /* @__PURE__ */ ((FilterScopeMatch2) => {
+  FilterScopeMatch2["Exact"] = "exact";
+  FilterScopeMatch2["Greedy"] = "greedy";
+  return FilterScopeMatch2;
+})(FilterScopeMatch || {});
+export {
+  FilterScopeMatch
+};

package/dist/transformRule.js

@@ -0,0 +1,77 @@
+import crypto from "node:crypto";
+import { IpRange, IpAddress } from "cidr-calc";
+import { Address4 } from "ip-address";
+import { z } from "zod";
+import { policyScopeInput, accessPolicyInput } from "./ruleInput/policyInput.js";
+import { accessRuleInput } from "./ruleInput/ruleInput.js";
+import { userScopeSchema } from "./ruleInput/userScopeInput.js";
+const RULE_HASH_ALGORITHM = "md5";
+const makeAccessRuleHash = (rule) => {
+  const valueProperties = Object.entries(rule).filter(
+    ([key, value]) => "undefined" !== typeof value
+  );
+  const orderedProperties = valueProperties.sort();
+  const objectToHash = Object.fromEntries(orderedProperties);
+  return hashObject(objectToHash, RULE_HASH_ALGORITHM);
+};
+const transformAccessRuleRecordIntoRule = (ruleRecord) => (
+  // accessRuleInput does all the record field transformations
+  accessRuleInput.parse(ruleRecord)
+);
+const transformAccessRuleIntoRecord = (rule) => accessRuleToRecordScheme.parse(rule);
+const accessRuleToRecordScheme = z.object({
+  ...accessPolicyInput.shape,
+  ...policyScopeInput.shape,
+  ...userScopeSchema.shape,
+  groupId: z.coerce.string().optional()
+}).transform((ruleInput) => {
+  const {
+    groupId,
+    numericIp,
+    numericIpMaskMin,
+    numericIpMaskMax,
+    userAgentHash,
+    ...rule
+  } = ruleInput;
+  const record = rule;
+  if ("string" === typeof groupId) {
+    record.ruleGroupId = groupId;
+  }
+  if ("string" === typeof userAgentHash) {
+    record.userAgent = userAgentHash;
+  }
+  if ("bigint" === typeof numericIp) {
+    record.ip = getStringIpFromNumeric(numericIp);
+  }
+  if ("bigint" === typeof numericIpMaskMin && "bigint" === typeof numericIpMaskMax) {
+    record.ipMask = getCidrFromNumericIpRange(
+      numericIpMaskMin,
+      numericIpMaskMax
+    );
+  }
+  return record;
+});
+const hashObject = (object, algorithm) => crypto.createHash(algorithm).update(
+  JSON.stringify(
+    object,
+    (key, value) => (
+      // JSON.stringify can't handle BigInt itself: throws "Do not know how to serialize a BigInt"
+      "bigint" === typeof value ? value.toString() : value
+    )
+  )
+).digest("hex");
+const getStringIpFromNumeric = (numericIp) => Address4.fromInteger(Number(numericIp)).address;
+const getCidrFromNumericIpRange = (startIp, endIp) => {
+  const ipRange = new IpRange(
+    IpAddress.of(getStringIpFromNumeric(startIp)),
+    IpAddress.of(getStringIpFromNumeric(endIp))
+  );
+  const cidr = ipRange.toCidrs()[0];
+  return cidr ? `${cidr.prefix.toString()}/${cidr.prefixLen}` : void 0;
+};
+export {
+  getCidrFromNumericIpRange,
+  makeAccessRuleHash,
+  transformAccessRuleIntoRecord,
+  transformAccessRuleRecordIntoRule
+};

package/entries.ts

@@ -0,0 +1,20 @@
+// Copyright 2021-2025 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+export const entries: Record<string, string> = {
+	".export": "src/.export.ts",
+	"api/.export": "src/api/.export.ts",
+	"redis/.export": "src/redis/.export.ts",
+	"mongoose/.export": "src/mongoose/.export.ts",
+};

package/package.json

@@ -1,18 +1,31 @@
 {
 	"name": "@prosopo/user-access-policy",
-	"version": "3.5.19",
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
+	"version": "3.5.28",
 	"type": "module",
 	"engines": {
-		"node": "20",
-		"npm": "10.8.2"
+		"node": ">=v20.0.0",
+		"npm": ">=10.6.0"
 	},
 	"exports": {
 		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js",
-			"require": "./dist/cjs/index.cjs"
+			"types": "./dist/.export.d.ts",
+			"import": "./dist/.export.js",
+			"require": "./dist/cjs/.export.cjs"
+		},
+		"./api": {
+			"types": "./dist/api/.export.d.ts",
+			"import": "./dist/api/.export.js",
+			"require": "./dist/cjs/api/.export.cjs"
+		},
+		"./redis": {
+			"types": "./dist/redis/.export.d.ts",
+			"import": "./dist/redis/.export.js",
+			"require": "./dist/cjs/redis/.export.cjs"
+		},
+		"./mongoose": {
+			"types": "./dist/mongoose/.export.d.ts",
+			"import": "./dist/mongoose/.export.js",
+			"require": "./dist/cjs/mongoose/.export.cjs"
 		}
 	},
 	"imports": {
@@ -29,24 +42,27 @@
 		"test": "npm run test:unit && npm run test:integration"
 	},
 	"dependencies": {
-		"@prosopo/api": "3.1.24",
-		"@prosopo/api-route": "2.6.28",
-		"@prosopo/common": "3.1.20",
-		"@prosopo/redis-client": "1.0.5",
-		"@prosopo/types": "3.5.3",
-		"@prosopo/util": "3.1.5",
+		"@prosopo/api": "3.1.33",
+		"@prosopo/api-route": "2.6.30",
+		"@prosopo/common": "3.1.22",
+		"@prosopo/redis-client": "1.0.7",
+		"@prosopo/types": "3.6.0",
+		"@prosopo/util": "3.2.0",
 		"@redis/search": "5.0.0",
+		"@redis/client": "5.0.0",
+		"cidr-calc": "1.0.4",
 		"dotenv": "16.4.5",
 		"ip-address": "10.0.1",
 		"redis": "5.0.0",
 		"zod": "3.23.8"
 	},
 	"devDependencies": {
-		"@prosopo/config": "3.1.20",
-		"@prosopo/util-crypto": "13.5.22",
+		"@prosopo/config": "3.1.22",
+		"@prosopo/util-crypto": "13.5.24",
 		"@types/node": "22.10.2",
-		"vite": "6.3.5",
-		"vitest": "3.0.9",
+		"mongoose": "8.13.0",
+		"vite": "6.4.1",
+		"vitest": "3.2.4",
 		"yargs": "17.7.2"
 	},
 	"author": "PROSOPO LIMITED <info@prosopo.io>",

package/vite.cjs.config.ts

@@ -1,4 +1,3 @@
-import path from "node:path";
 // Copyright 2021-2025 Prosopo (UK) Ltd.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,11 +11,15 @@ import path from "node:path";
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
+import path from "node:path";
 import { ViteCommonJSConfig } from "@prosopo/config";
+import { entries } from "./entries.js";
 
 export default function () {
 	return ViteCommonJSConfig(
 		path.basename("."),
 		path.resolve("./tsconfig.json"),
+		entries,
 	);
 }

package/vite.esm.config.ts

@@ -14,7 +14,12 @@
 
 import path from "node:path";
 import { ViteEsmConfig } from "@prosopo/config";
+import { entries } from "./entries.js";
 
 export default function () {
-	return ViteEsmConfig(path.basename("."), path.resolve("./tsconfig.json"));
+	return ViteEsmConfig(
+		path.basename("."),
+		path.resolve("./tsconfig.json"),
+		entries,
+	);
 }

package/dist/accessPolicy.js

@@ -1,80 +0,0 @@
-import { CaptchaTypeSchema } from "@prosopo/types";
-import { getIPAddress } from "@prosopo/util";
-import { Address4 } from "ip-address";
-import { z } from "zod";
-import { hashUserAgent } from "./util.js";
-var AccessPolicyType = /* @__PURE__ */ ((AccessPolicyType2) => {
-  AccessPolicyType2["Block"] = "block";
-  AccessPolicyType2["Restrict"] = "restrict";
-  return AccessPolicyType2;
-})(AccessPolicyType || {});
-const accessPolicySchema = z.object({
-  type: z.nativeEnum(AccessPolicyType),
-  captchaType: CaptchaTypeSchema.optional(),
-  description: z.coerce.string().optional(),
-  // Redis stores values as strings, so coerce is needed to parse properly
-  solvedImagesCount: z.coerce.number().optional(),
-  // the percentage of image panels that must be solved per image CAPTCHA
-  imageThreshold: z.coerce.number().optional(),
-  // the Proof-of-Work difficulty level
-  powDifficulty: z.coerce.number().optional(),
-  // the number of unsolved image CAPTCHA challenges to serve
-  unsolvedImagesCount: z.coerce.number().optional(),
-  // used to increase the user's score
-  frictionlessScore: z.coerce.number().optional()
-});
-const policyScopeSchema = z.object({
-  clientId: z.coerce.string().optional(),
-  ruleGroupId: z.coerce.string().optional()
-});
-const userScopeSchema = z.object({
-  // coerce is used for safety, as e.g., incoming userId can be digital
-  userId: z.coerce.string().optional(),
-  numericIp: z.coerce.bigint().optional(),
-  numericIpMaskMin: z.coerce.bigint().optional(),
-  numericIpMaskMax: z.coerce.bigint().optional(),
-  ja4Hash: z.coerce.string().optional(),
-  headersHash: z.coerce.string().optional(),
-  userAgentHash: z.coerce.string().optional()
-});
-const userScopeInputSchema = userScopeSchema.extend({
-  // human-friendly ip versions. If present, then converted to numeric and removed from the object
-  // 127.0.0.1
-  ip: z.string().optional(),
-  // 127.0.0.1/24
-  ipMask: z.string().optional(),
-  // human friendly user agent
-  userAgent: z.string().optional()
-}).transform((inputUserScope) => {
-  const { ip, ipMask, userAgent, ...userScope } = inputUserScope;
-  if ("string" === typeof ip) {
-    userScope.numericIp = getIPAddress(ip).bigInt();
-  }
-  if ("string" === typeof ipMask) {
-    const ipObject = new Address4(ipMask);
-    userScope.numericIpMaskMin = ipObject.startAddress().bigInt();
-    userScope.numericIpMaskMax = ipObject.endAddress().bigInt();
-  }
-  if ("string" === typeof userAgent) {
-    userScope.userAgentHash = hashUserAgent(userAgent);
-  }
-  return userScope;
-});
-const accessRuleSchemaExtended = z.object({
-  // flat structure is used to fit the Redis requirements
-  ...accessPolicySchema.shape,
-  ...policyScopeSchema.shape,
-  ...userScopeInputSchema._def.schema.shape
-}).omit({
-  numericIp: true,
-  numericIpMaskMin: true,
-  numericIpMaskMax: true
-});
-export {
-  AccessPolicyType,
-  accessPolicySchema,
-  accessRuleSchemaExtended,
-  policyScopeSchema,
-  userScopeInputSchema,
-  userScopeSchema
-};

package/dist/accessPolicyResolver.js

@@ -1,31 +0,0 @@
-import { z } from "zod";
-import { userScopeInputSchema, policyScopeSchema } from "./accessPolicy.js";
-var ScopeMatch = /* @__PURE__ */ ((ScopeMatch2) => {
-  ScopeMatch2["Exact"] = "exact";
-  ScopeMatch2["Greedy"] = "greedy";
-  return ScopeMatch2;
-})(ScopeMatch || {});
-const policyFilterSchema = z.object({
-  policyScope: policyScopeSchema.optional(),
-  /**
-   * Exact: "clientId" => client rules, "undefined" => global rules. Used by the API
-   * Greedy: "clientId" => client + global rules, "undefined" => any rules. Used by the Express middleware
-   */
-  policyScopeMatch: z.nativeEnum(ScopeMatch).default(
-    "exact"
-    /* Exact */
-  ),
-  userScope: userScopeInputSchema.optional(),
-  /**
-   * Exact: finds rules where all the given fields matches and doesn't check IP against masks. Used by the API
-   * Greedy: finds rules where any of the given fields match and checks IP against masks. Used by the Express middleware
-   */
-  userScopeMatch: z.nativeEnum(ScopeMatch).default(
-    "exact"
-    /* Exact */
-  )
-});
-export {
-  ScopeMatch,
-  policyFilterSchema
-};

package/dist/accessRules.js

@@ -1,11 +0,0 @@
-import { z } from "zod";
-import { userScopeSchema, policyScopeSchema, accessPolicySchema } from "./accessPolicy.js";
-const accessRuleSchema = z.object({
-  // flat structure is used to fit the Redis requirements
-  ...accessPolicySchema.shape,
-  ...policyScopeSchema.shape,
-  ...userScopeSchema.shape
-});
-export {
-  accessRuleSchema
-};

package/dist/api/accessRuleApiRoutes.js

@@ -1,79 +0,0 @@
-import { DeleteAllRulesEndpoint } from "./deleteAllRulesEndpoint.js";
-import { DeleteRulesEndpoint } from "./deleteRulesEndpoint.js";
-import { InsertRulesEndpoint } from "./insertRulesEndpoint.js";
-var accessRuleApiPaths = /* @__PURE__ */ ((accessRuleApiPaths2) => {
-  accessRuleApiPaths2["INSERT_MANY"] = "/v1/prosopo/user-access-policy/rules/insert-many";
-  accessRuleApiPaths2["DELETE_MANY"] = "/v1/prosopo/user-access-policy/rules/delete-many";
-  accessRuleApiPaths2["DELETE_ALL"] = "/v1/prosopo/user-access-policy/rules/delete-all";
-  return accessRuleApiPaths2;
-})(accessRuleApiPaths || {});
-class AccessRuleApiRoutes {
-  constructor(accessRulesStorage) {
-    this.accessRulesStorage = accessRulesStorage;
-  }
-  getRoutes() {
-    return [
-      {
-        path: "/v1/prosopo/user-access-policy/rules/insert-many",
-        endpoint: new InsertRulesEndpoint(this.accessRulesStorage)
-      },
-      {
-        path: "/v1/prosopo/user-access-policy/rules/delete-many",
-        endpoint: new DeleteRulesEndpoint(this.accessRulesStorage)
-      },
-      {
-        path: "/v1/prosopo/user-access-policy/rules/delete-all",
-        endpoint: new DeleteAllRulesEndpoint(this.accessRulesStorage)
-      }
-    ];
-  }
-}
-const getExpressApiRuleRateLimits = () => {
-  const defaultWindowsMs = 6e4;
-  const defaultLimit = 5;
-  return {
-    [
-      "/v1/prosopo/user-access-policy/rules/insert-many"
-      /* INSERT_MANY */
-    ]: {
-      windowMs: getIntEnvironmentVariable(
-        "PROSOPO_USER_ACCESS_POLICY_RULE_INSERT_MANY_WINDOW"
-      ) || defaultWindowsMs,
-      limit: getIntEnvironmentVariable(
-        "PROSOPO_USER_ACCESS_POLICY_RULE_INSERT_MANY_LIMIT"
-      ) || defaultLimit
-    },
-    [
-      "/v1/prosopo/user-access-policy/rules/delete-many"
-      /* DELETE_MANY */
-    ]: {
-      windowMs: getIntEnvironmentVariable(
-        "PROSOPO_USER_ACCESS_POLICY_RULE_DELETE_MANY_WINDOW"
-      ) || defaultWindowsMs,
-      limit: getIntEnvironmentVariable(
-        "PROSOPO_USER_ACCESS_POLICY_RULE_DELETE_MANY_LIMIT"
-      ) || defaultLimit
-    },
-    [
-      "/v1/prosopo/user-access-policy/rules/delete-all"
-      /* DELETE_ALL */
-    ]: {
-      windowMs: getIntEnvironmentVariable(
-        "PROSOPO_USER_ACCESS_POLICY_RULE_DELETE_ALL_WINDOW"
-      ) || defaultWindowsMs,
-      limit: getIntEnvironmentVariable(
-        "PROSOPO_USER_ACCESS_POLICY_RULE_DELETE_ALL_LIMIT"
-      ) || defaultLimit
-    }
-  };
-};
-const getIntEnvironmentVariable = (variableName) => {
-  const variableValue = process.env[variableName];
-  const numericValue = variableValue ? Number.parseInt(variableValue) : Number.NaN;
-  return Number.isInteger(numericValue) ? numericValue : void 0;
-};
-export {
-  AccessRuleApiRoutes,
-  accessRuleApiPaths,
-  getExpressApiRuleRateLimits
-};

package/dist/api/accessRulesApiClient.js

@@ -1,38 +0,0 @@
-import { ApiClient } from "@prosopo/api";
-import { accessRuleApiPaths } from "./accessRuleApiRoutes.js";
-class AccessRulesApiClient extends ApiClient {
-  insertMany(toInsert, timestamp, signature) {
-    return this.post(accessRuleApiPaths.INSERT_MANY, toInsert, {
-      headers: {
-        "Prosopo-Site-Key": this.account,
-        timestamp,
-        signature
-      }
-    });
-  }
-  deleteMany(toDelete, timestamp, signature) {
-    return this.post(accessRuleApiPaths.DELETE_MANY, toDelete, {
-      headers: {
-        "Prosopo-Site-Key": this.account,
-        timestamp,
-        signature
-      }
-    });
-  }
-  deleteAll(timestamp, signature) {
-    return this.post(
-      accessRuleApiPaths.DELETE_ALL,
-      {},
-      {
-        headers: {
-          "Prosopo-Site-Key": this.account,
-          timestamp,
-          signature
-        }
-      }
-    );
-  }
-}
-export {
-  AccessRulesApiClient
-};

package/dist/api/deleteRulesEndpoint.js

@@ -1,34 +0,0 @@
-import { ApiEndpointResponseStatus } from "@prosopo/api-route";
-import { z } from "zod";
-import { policyFilterSchema } from "../accessPolicyResolver.js";
-const deleteRulesEndpointSchema = z.array(policyFilterSchema);
-class DeleteRulesEndpoint {
-  constructor(accessRulesStorage) {
-    this.accessRulesStorage = accessRulesStorage;
-  }
-  async processRequest(args) {
-    const allRuleIds = [];
-    for (const accessRuleFilter of args) {
-      const parsedRules = policyFilterSchema.parse(accessRuleFilter);
-      const foundRuleIds = await this.accessRulesStorage.findRuleIds(parsedRules);
-      allRuleIds.push(...foundRuleIds);
-    }
-    const uniqueRuleIds = [...new Set(allRuleIds)];
-    if (uniqueRuleIds.length > 0) {
-      await this.accessRulesStorage.deleteRules(uniqueRuleIds);
-    }
-    return {
-      status: ApiEndpointResponseStatus.SUCCESS,
-      data: {
-        deleted_count: uniqueRuleIds.length
-      }
-    };
-  }
-  getRequestArgsSchema() {
-    return deleteRulesEndpointSchema;
-  }
-}
-export {
-  DeleteRulesEndpoint,
-  deleteRulesEndpointSchema
-};