@prosopo/user-access-policy 2.3.2

package/dist/blacklistInspector.d.ts

@@ -0,0 +1,6 @@
+import type { IPAddress } from "@prosopo/types";
+interface BlacklistInspector {
+    isUserBlacklisted(clientId: string, userIpAddress: IPAddress, userId: string): Promise<boolean>;
+}
+export type { BlacklistInspector };
+//# sourceMappingURL=blacklistInspector.d.ts.map

package/dist/blacklistInspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blacklistInspector.d.ts","sourceRoot":"","sources":["../src/blacklistInspector.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,UAAU,kBAAkB;IAC3B,iBAAiB,CAChB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,SAAS,EACxB,MAAM,EAAE,MAAM,GACZ,OAAO,CAAC,OAAO,CAAC,CAAC;CACpB;AAED,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/blacklistInspector.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=blacklistInspector.js.map

package/dist/blacklistInspector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blacklistInspector.js","sourceRoot":"","sources":["../src/blacklistInspector.ts"],"names":[],"mappings":""}

package/dist/imageCaptchaConfigResolver.d.ts

@@ -0,0 +1,7 @@
+import type { IPAddress, ProsopoCaptchaCountConfigSchemaOutput } from "@prosopo/types";
+interface ImageCaptchaConfigResolver {
+    isConfigDefined(clientId: string, userIpAddress: IPAddress, userId: string): Promise<boolean>;
+    resolveConfig(defaults: ProsopoCaptchaCountConfigSchemaOutput, userIpAddress: IPAddress, userId: string, clientId: string): Promise<ProsopoCaptchaCountConfigSchemaOutput>;
+}
+export type { ImageCaptchaConfigResolver };
+//# sourceMappingURL=imageCaptchaConfigResolver.d.ts.map

package/dist/imageCaptchaConfigResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageCaptchaConfigResolver.d.ts","sourceRoot":"","sources":["../src/imageCaptchaConfigResolver.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACX,SAAS,EACT,qCAAqC,EACrC,MAAM,gBAAgB,CAAC;AAExB,UAAU,0BAA0B;IACnC,eAAe,CACd,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,SAAS,EACxB,MAAM,EAAE,MAAM,GACZ,OAAO,CAAC,OAAO,CAAC,CAAC;IAEpB,aAAa,CACZ,QAAQ,EAAE,qCAAqC,EAC/C,aAAa,EAAE,SAAS,EACxB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,qCAAqC,CAAC,CAAC;CAClD;AAED,YAAY,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/imageCaptchaConfigResolver.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=imageCaptchaConfigResolver.js.map

package/dist/imageCaptchaConfigResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageCaptchaConfigResolver.js","sourceRoot":"","sources":["../src/imageCaptchaConfigResolver.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { ApiRoutesProvider } from "@prosopo/api-route";
+import type { Logger } from "@prosopo/common";
+import type { Model } from "mongoose";
+import type { BlacklistInspector } from "./blacklistInspector.js";
+import { getExpressApiRuleRateLimits } from "./rules/api/getExpressApiRuleRateLimits.js";
+import { ImageCaptchaConfigRulesResolver } from "./rules/imageCaptchaConfigRulesResolver.js";
+import { getRuleMongooseSchema } from "./rules/mongoose/schemas/getRuleMongooseSchema.js";
+import type { Rule } from "./rules/rule/rule.js";
+import type { RulesStorage } from "./rules/storage/rulesStorage.js";
+declare const createBlacklistInspector: (rulesStorage: RulesStorage, logger: Logger) => BlacklistInspector;
+declare const createImageCaptchaConfigResolver: (rulesStorage: RulesStorage, logger: Logger) => ImageCaptchaConfigRulesResolver;
+declare const createApiRuleRoutesProvider: (rulesStorage: RulesStorage) => ApiRoutesProvider;
+declare const createMongooseRulesStorage: (logger: Logger, readingModel: Model<Rule> | null, writingModel?: Model<Rule> | null) => RulesStorage;
+export { type Rule, type RulesStorage, type BlacklistInspector, createMongooseRulesStorage, createImageCaptchaConfigResolver, createBlacklistInspector, createApiRuleRoutesProvider, getRuleMongooseSchema, getExpressApiRuleRateLimits, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AAEzF,OAAO,EAAE,+BAA+B,EAAE,MAAM,4CAA4C,CAAC;AAE7F,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE,QAAA,MAAM,wBAAwB,iBACf,YAAY,UAClB,MAAM,KACZ,kBAEF,CAAC;AAEF,QAAA,MAAM,gCAAgC,iBACvB,YAAY,UAClB,MAAM,KACZ,+BAEF,CAAC;AAEF,QAAA,MAAM,2BAA2B,iBAClB,YAAY,KACxB,iBAEF,CAAC;AAEF,QAAA,MAAM,0BAA0B,WACvB,MAAM,gBACA,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,iBAClB,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,KAC9B,YAEF,CAAC;AAEF,OAAO,EACN,KAAK,IAAI,EACT,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,0BAA0B,EAC1B,gCAAgC,EAChC,wBAAwB,EACxB,2BAA2B,EAC3B,qBAAqB,EACrB,2BAA2B,GAC3B,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+import { ApiRuleRoutesProvider } from "./rules/api/apiRuleRoutesProvider.js";
+import { getExpressApiRuleRateLimits } from "./rules/api/getExpressApiRuleRateLimits.js";
+import { BlacklistRulesInspector } from "./rules/blacklistRulesInspector.js";
+import { ImageCaptchaConfigRulesResolver } from "./rules/imageCaptchaConfigRulesResolver.js";
+import { RulesMongooseStorage } from "./rules/mongoose/rulesMongooseStorage.js";
+import { getRuleMongooseSchema } from "./rules/mongoose/schemas/getRuleMongooseSchema.js";
+const createBlacklistInspector = (rulesStorage, logger) => {
+    return new BlacklistRulesInspector(rulesStorage, logger);
+};
+const createImageCaptchaConfigResolver = (rulesStorage, logger) => {
+    return new ImageCaptchaConfigRulesResolver(rulesStorage, logger);
+};
+const createApiRuleRoutesProvider = (rulesStorage) => {
+    return new ApiRuleRoutesProvider(rulesStorage);
+};
+const createMongooseRulesStorage = (logger, readingModel, writingModel = null) => {
+    return new RulesMongooseStorage(logger, readingModel, writingModel);
+};
+export { createMongooseRulesStorage, createImageCaptchaConfigResolver, createBlacklistInspector, createApiRuleRoutesProvider, getRuleMongooseSchema, getExpressApiRuleRateLimits, };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AACzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,+BAA+B,EAAE,MAAM,4CAA4C,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAChF,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAI1F,MAAM,wBAAwB,GAAG,CAChC,YAA0B,EAC1B,MAAc,EACO,EAAE;IACvB,OAAO,IAAI,uBAAuB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;AAC1D,CAAC,CAAC;AAEF,MAAM,gCAAgC,GAAG,CACxC,YAA0B,EAC1B,MAAc,EACoB,EAAE;IACpC,OAAO,IAAI,+BAA+B,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;AAClE,CAAC,CAAC;AAEF,MAAM,2BAA2B,GAAG,CACnC,YAA0B,EACN,EAAE;IACtB,OAAO,IAAI,qBAAqB,CAAC,YAAY,CAAC,CAAC;AAChD,CAAC,CAAC;AAEF,MAAM,0BAA0B,GAAG,CAClC,MAAc,EACd,YAAgC,EAChC,eAAmC,IAAI,EACxB,EAAE;IACjB,OAAO,IAAI,oBAAoB,CAAC,MAAM,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;AACrE,CAAC,CAAC;AAEF,OAAO,EAIN,0BAA0B,EAC1B,gCAAgC,EAChC,wBAAwB,EACxB,2BAA2B,EAC3B,qBAAqB,EACrB,2BAA2B,GAC3B,CAAC"}

package/dist/rules/api/apiRulePaths.d.ts

@@ -0,0 +1,6 @@
+declare const apiRulePaths: {
+    INSERT_MANY: string;
+    DELETE_MANY: string;
+};
+export { apiRulePaths };
+//# sourceMappingURL=apiRulePaths.d.ts.map

package/dist/rules/api/apiRulePaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiRulePaths.d.ts","sourceRoot":"","sources":["../../../src/rules/api/apiRulePaths.ts"],"names":[],"mappings":"AAcA,QAAA,MAAM,YAAY;;;CAGjB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/rules/api/apiRulePaths.js

@@ -0,0 +1,6 @@
+const apiRulePaths = {
+    INSERT_MANY: "/v1/prosopo/user-access-policy/rules/insert-many",
+    DELETE_MANY: "/v1/prosopo/user-access-policy/rules/delete-many",
+};
+export { apiRulePaths };
+//# sourceMappingURL=apiRulePaths.js.map

package/dist/rules/api/apiRulePaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiRulePaths.js","sourceRoot":"","sources":["../../../src/rules/api/apiRulePaths.ts"],"names":[],"mappings":"AAcA,MAAM,YAAY,GAAG;IACpB,WAAW,EAAE,kDAAkD;IAC/D,WAAW,EAAE,kDAAkD;CAC/D,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/rules/api/apiRuleRoutesProvider.d.ts

@@ -0,0 +1,9 @@
+import type { ApiRoute, ApiRoutesProvider } from "@prosopo/api-route";
+import type { RulesStorage } from "../storage/rulesStorage.js";
+declare class ApiRuleRoutesProvider implements ApiRoutesProvider {
+    private readonly rulesStorage;
+    constructor(rulesStorage: RulesStorage);
+    getRoutes(): ApiRoute[];
+}
+export { ApiRuleRoutesProvider };
+//# sourceMappingURL=apiRuleRoutesProvider.d.ts.map

package/dist/rules/api/apiRuleRoutesProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiRuleRoutesProvider.d.ts","sourceRoot":"","sources":["../../../src/rules/api/apiRuleRoutesProvider.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAK/D,cAAM,qBAAsB,YAAW,iBAAiB;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,EAAE,YAAY;IAEvD,SAAS,IAAI,QAAQ,EAAE;CAY9B;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/rules/api/apiRuleRoutesProvider.js

@@ -0,0 +1,22 @@
+import { apiRulePaths } from "./apiRulePaths.js";
+import { ApiDeleteManyRulesEndpoint } from "./deleteMany/apiDeleteManyRulesEndpoint.js";
+import { ApiInsertManyRulesEndpoint } from "./insertMany/apiInsertManyRulesEndpoint.js";
+class ApiRuleRoutesProvider {
+    constructor(rulesStorage) {
+        this.rulesStorage = rulesStorage;
+    }
+    getRoutes() {
+        return [
+            {
+                path: apiRulePaths.INSERT_MANY,
+                endpoint: new ApiInsertManyRulesEndpoint(this.rulesStorage),
+            },
+            {
+                path: apiRulePaths.DELETE_MANY,
+                endpoint: new ApiDeleteManyRulesEndpoint(this.rulesStorage),
+            },
+        ];
+    }
+}
+export { ApiRuleRoutesProvider };
+//# sourceMappingURL=apiRuleRoutesProvider.js.map

package/dist/rules/api/apiRuleRoutesProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiRuleRoutesProvider.js","sourceRoot":"","sources":["../../../src/rules/api/apiRuleRoutesProvider.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AACxF,OAAO,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AAExF,MAAM,qBAAqB;IAC1B,YAAoC,YAA0B;QAA1B,iBAAY,GAAZ,YAAY,CAAc;IAAG,CAAC;IAE3D,SAAS;QACf,OAAO;YACN;gBACC,IAAI,EAAE,YAAY,CAAC,WAAW;gBAC9B,QAAQ,EAAE,IAAI,0BAA0B,CAAC,IAAI,CAAC,YAAY,CAAC;aAC3D;YACD;gBACC,IAAI,EAAE,YAAY,CAAC,WAAW;gBAC9B,QAAQ,EAAE,IAAI,0BAA0B,CAAC,IAAI,CAAC,YAAY,CAAC;aAC3D;SACD,CAAC;IACH,CAAC;CACD;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/rules/api/deleteMany/apiDeleteManyRulesArgsSchema.d.ts

@@ -0,0 +1,159 @@
+declare const apiDeleteManyRulesArgsSchema: import("zod").ZodArray<import("zod").ZodObject<{
+    clientId: import("zod").ZodOptional<import("zod").ZodString>;
+    userIp: import("zod").ZodOptional<import("zod").ZodObject<{
+        v4: import("zod").ZodOptional<import("zod").ZodObject<{
+            asNumeric: import("zod").ZodBigInt;
+            asString: import("zod").ZodString;
+            mask: import("zod").ZodOptional<import("zod").ZodObject<{
+                rangeMinAsNumeric: import("zod").ZodBigInt;
+                rangeMaxAsNumeric: import("zod").ZodBigInt;
+                asNumeric: import("zod").ZodNumber;
+            }, "strip", import("zod").ZodTypeAny, {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            }, {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            }>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        }, {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        }>>;
+        v6: import("zod").ZodOptional<import("zod").ZodObject<{
+            asNumericString: import("zod").ZodString;
+            asString: import("zod").ZodString;
+            mask: import("zod").ZodOptional<import("zod").ZodObject<{
+                rangeMinAsNumericString: import("zod").ZodString;
+                rangeMaxAsNumericString: import("zod").ZodString;
+                asNumeric: import("zod").ZodNumber;
+            }, "strip", import("zod").ZodTypeAny, {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            }, {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            }>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        }, {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        }>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        v4?: {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        } | undefined;
+        v6?: {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        } | undefined;
+    }, {
+        v4?: {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        } | undefined;
+        v6?: {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        } | undefined;
+    }>>;
+    userId: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    clientId?: string | undefined;
+    userIp?: {
+        v4?: {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        } | undefined;
+        v6?: {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    userId?: string | undefined;
+}, {
+    clientId?: string | undefined;
+    userIp?: {
+        v4?: {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        } | undefined;
+        v6?: {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    userId?: string | undefined;
+}>, "many">;
+type ApiDeleteManyRulesArgsSchema = typeof apiDeleteManyRulesArgsSchema;
+export { apiDeleteManyRulesArgsSchema, type ApiDeleteManyRulesArgsSchema };
+//# sourceMappingURL=apiDeleteManyRulesArgsSchema.d.ts.map

package/dist/rules/api/deleteMany/apiDeleteManyRulesArgsSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiDeleteManyRulesArgsSchema.d.ts","sourceRoot":"","sources":["../../../../src/rules/api/deleteMany/apiDeleteManyRulesArgsSchema.ts"],"names":[],"mappings":"AAiBA,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAMjC,CAAC;AAEF,KAAK,4BAA4B,GAAG,OAAO,4BAA4B,CAAC;AAExE,OAAO,EAAE,4BAA4B,EAAE,KAAK,4BAA4B,EAAE,CAAC"}

package/dist/rules/api/deleteMany/apiDeleteManyRulesArgsSchema.js

@@ -0,0 +1,9 @@
+import { array, object, string } from "zod";
+import { ruleIpSchema } from "../../rule/ip/ruleIpSchema.js";
+const apiDeleteManyRulesArgsSchema = array(object({
+    clientId: string().optional(),
+    userIp: ruleIpSchema.optional(),
+    userId: string().optional(),
+}));
+export { apiDeleteManyRulesArgsSchema };
+//# sourceMappingURL=apiDeleteManyRulesArgsSchema.js.map

package/dist/rules/api/deleteMany/apiDeleteManyRulesArgsSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiDeleteManyRulesArgsSchema.js","sourceRoot":"","sources":["../../../../src/rules/api/deleteMany/apiDeleteManyRulesArgsSchema.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,MAAM,4BAA4B,GAAG,KAAK,CACzC,MAAM,CAAC;IACN,QAAQ,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;IAC/B,MAAM,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC3B,CAAC,CACF,CAAC;AAIF,OAAO,EAAE,4BAA4B,EAAqC,CAAC"}

package/dist/rules/api/deleteMany/apiDeleteManyRulesEndpoint.d.ts

@@ -0,0 +1,12 @@
+import { type ApiEndpoint, type ApiEndpointResponse } from "@prosopo/api-route";
+import type { z } from "zod";
+import type { RulesStorage } from "../../storage/rulesStorage.js";
+import { type ApiDeleteManyRulesArgsSchema } from "./apiDeleteManyRulesArgsSchema.js";
+declare class ApiDeleteManyRulesEndpoint implements ApiEndpoint<ApiDeleteManyRulesArgsSchema> {
+    private readonly rulesStorage;
+    constructor(rulesStorage: RulesStorage);
+    processRequest(args: z.infer<ApiDeleteManyRulesArgsSchema>): Promise<ApiEndpointResponse>;
+    getRequestArgsSchema(): ApiDeleteManyRulesArgsSchema;
+}
+export { ApiDeleteManyRulesEndpoint };
+//# sourceMappingURL=apiDeleteManyRulesEndpoint.d.ts.map

package/dist/rules/api/deleteMany/apiDeleteManyRulesEndpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiDeleteManyRulesEndpoint.d.ts","sourceRoot":"","sources":["../../../../src/rules/api/deleteMany/apiDeleteManyRulesEndpoint.ts"],"names":[],"mappings":"AAcA,OAAO,EACN,KAAK,WAAW,EAChB,KAAK,mBAAmB,EAExB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EACN,KAAK,4BAA4B,EAEjC,MAAM,mCAAmC,CAAC;AAE3C,cAAM,0BACL,YAAW,WAAW,CAAC,4BAA4B,CAAC;IAEjC,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,EAAE,YAAY;IAExD,cAAc,CACnB,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,4BAA4B,CAAC,GACzC,OAAO,CAAC,mBAAmB,CAAC;IAQxB,oBAAoB,IAAI,4BAA4B;CAG3D;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/rules/api/deleteMany/apiDeleteManyRulesEndpoint.js

@@ -0,0 +1,18 @@
+import { ApiEndpointResponseStatus, } from "@prosopo/api-route";
+import { apiDeleteManyRulesArgsSchema, } from "./apiDeleteManyRulesArgsSchema.js";
+class ApiDeleteManyRulesEndpoint {
+    constructor(rulesStorage) {
+        this.rulesStorage = rulesStorage;
+    }
+    async processRequest(args) {
+        await this.rulesStorage.deleteMany(args);
+        return {
+            status: ApiEndpointResponseStatus.SUCCESS,
+        };
+    }
+    getRequestArgsSchema() {
+        return apiDeleteManyRulesArgsSchema;
+    }
+}
+export { ApiDeleteManyRulesEndpoint };
+//# sourceMappingURL=apiDeleteManyRulesEndpoint.js.map

package/dist/rules/api/deleteMany/apiDeleteManyRulesEndpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiDeleteManyRulesEndpoint.js","sourceRoot":"","sources":["../../../../src/rules/api/deleteMany/apiDeleteManyRulesEndpoint.ts"],"names":[],"mappings":"AAcA,OAAO,EAGN,yBAAyB,GACzB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAEN,4BAA4B,GAC5B,MAAM,mCAAmC,CAAC;AAE3C,MAAM,0BAA0B;IAG/B,YAAoC,YAA0B;QAA1B,iBAAY,GAAZ,YAAY,CAAc;IAAG,CAAC;IAElE,KAAK,CAAC,cAAc,CACnB,IAA2C;QAE3C,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAEzC,OAAO;YACN,MAAM,EAAE,yBAAyB,CAAC,OAAO;SACzC,CAAC;IACH,CAAC;IAEM,oBAAoB;QAC1B,OAAO,4BAA4B,CAAC;IACrC,CAAC;CACD;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/rules/api/getExpressApiRuleRateLimits.d.ts

@@ -0,0 +1,8 @@
+declare const getExpressApiRuleRateLimits: () => {
+    [x: string]: {
+        windowMs: string | number;
+        limit: string | number;
+    };
+};
+export { getExpressApiRuleRateLimits };
+//# sourceMappingURL=getExpressApiRuleRateLimits.d.ts.map

package/dist/rules/api/getExpressApiRuleRateLimits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getExpressApiRuleRateLimits.d.ts","sourceRoot":"","sources":["../../../src/rules/api/getExpressApiRuleRateLimits.ts"],"names":[],"mappings":"AAgBA,QAAA,MAAM,2BAA2B;;;;;CAsBhC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/rules/api/getExpressApiRuleRateLimits.js

@@ -0,0 +1,21 @@
+import { apiRulePaths } from "./apiRulePaths.js";
+const getExpressApiRuleRateLimits = () => {
+    const defaultWindowsMs = 60000;
+    const defaultLimit = 5;
+    return {
+        [apiRulePaths.INSERT_MANY]: {
+            windowMs: process.env.PROSOPO_USER_ACCESS_POLICY_RULE_INSERT_MANY_WINDOW ||
+                defaultWindowsMs,
+            limit: process.env.PROSOPO_USER_ACCESS_POLICY_RULE_INSERT_MANY_LIMIT ||
+                defaultLimit,
+        },
+        [apiRulePaths.DELETE_MANY]: {
+            windowMs: process.env.PROSOPO_USER_ACCESS_POLICY_RULE_DELETE_MANY_WINDOW ||
+                defaultWindowsMs,
+            limit: process.env.PROSOPO_USER_ACCESS_POLICY_RULE_DELETE_MANY_LIMIT ||
+                defaultLimit,
+        },
+    };
+};
+export { getExpressApiRuleRateLimits };
+//# sourceMappingURL=getExpressApiRuleRateLimits.js.map

package/dist/rules/api/getExpressApiRuleRateLimits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getExpressApiRuleRateLimits.js","sourceRoot":"","sources":["../../../src/rules/api/getExpressApiRuleRateLimits.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,MAAM,2BAA2B,GAAG,GAAG,EAAE;IACxC,MAAM,gBAAgB,GAAG,KAAK,CAAC;IAC/B,MAAM,YAAY,GAAG,CAAC,CAAC;IAEvB,OAAO;QACN,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE;YAC3B,QAAQ,EACP,OAAO,CAAC,GAAG,CAAC,kDAAkD;gBAC9D,gBAAgB;YACjB,KAAK,EACJ,OAAO,CAAC,GAAG,CAAC,iDAAiD;gBAC7D,YAAY;SACb;QACD,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE;YAC3B,QAAQ,EACP,OAAO,CAAC,GAAG,CAAC,kDAAkD;gBAC9D,gBAAgB;YACjB,KAAK,EACJ,OAAO,CAAC,GAAG,CAAC,iDAAiD;gBAC7D,YAAY;SACb;KACD,CAAC;AACH,CAAC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/rules/api/insertMany/apiInsertManyRulesArgsSchema.d.ts

@@ -0,0 +1,199 @@
+declare const apiInsertManyRulesArgsSchema: import("zod").ZodObject<{
+    isUserBlocked: import("zod").ZodBoolean;
+    clientId: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    userIps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        v4: import("zod").ZodOptional<import("zod").ZodObject<{
+            asNumeric: import("zod").ZodBigInt;
+            asString: import("zod").ZodString;
+            mask: import("zod").ZodOptional<import("zod").ZodObject<{
+                rangeMinAsNumeric: import("zod").ZodBigInt;
+                rangeMaxAsNumeric: import("zod").ZodBigInt;
+                asNumeric: import("zod").ZodNumber;
+            }, "strip", import("zod").ZodTypeAny, {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            }, {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            }>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        }, {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        }>>;
+        v6: import("zod").ZodOptional<import("zod").ZodObject<{
+            asNumericString: import("zod").ZodString;
+            asString: import("zod").ZodString;
+            mask: import("zod").ZodOptional<import("zod").ZodObject<{
+                rangeMinAsNumericString: import("zod").ZodString;
+                rangeMaxAsNumericString: import("zod").ZodString;
+                asNumeric: import("zod").ZodNumber;
+            }, "strip", import("zod").ZodTypeAny, {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            }, {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            }>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        }, {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        }>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        v4?: {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        } | undefined;
+        v6?: {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        } | undefined;
+    }, {
+        v4?: {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        } | undefined;
+        v6?: {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        } | undefined;
+    }>, "many">>;
+    userIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    config: import("zod").ZodOptional<import("zod").ZodObject<{
+        imageCaptcha: import("zod").ZodOptional<import("zod").ZodObject<{
+            solvedCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+            unsolvedCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            solvedCount?: number | undefined;
+            unsolvedCount?: number | undefined;
+        }, {
+            solvedCount?: number | undefined;
+            unsolvedCount?: number | undefined;
+        }>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        imageCaptcha?: {
+            solvedCount?: number | undefined;
+            unsolvedCount?: number | undefined;
+        } | undefined;
+    }, {
+        imageCaptcha?: {
+            solvedCount?: number | undefined;
+            unsolvedCount?: number | undefined;
+        } | undefined;
+    }>>;
+}, "strip", import("zod").ZodTypeAny, {
+    isUserBlocked: boolean;
+    clientId?: string | undefined;
+    description?: string | undefined;
+    userIps?: {
+        v4?: {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        } | undefined;
+        v6?: {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        } | undefined;
+    }[] | undefined;
+    userIds?: string[] | undefined;
+    config?: {
+        imageCaptcha?: {
+            solvedCount?: number | undefined;
+            unsolvedCount?: number | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    isUserBlocked: boolean;
+    clientId?: string | undefined;
+    description?: string | undefined;
+    userIps?: {
+        v4?: {
+            asNumeric: bigint;
+            asString: string;
+            mask?: {
+                rangeMinAsNumeric: bigint;
+                rangeMaxAsNumeric: bigint;
+                asNumeric: number;
+            } | undefined;
+        } | undefined;
+        v6?: {
+            asString: string;
+            asNumericString: string;
+            mask?: {
+                asNumeric: number;
+                rangeMinAsNumericString: string;
+                rangeMaxAsNumericString: string;
+            } | undefined;
+        } | undefined;
+    }[] | undefined;
+    userIds?: string[] | undefined;
+    config?: {
+        imageCaptcha?: {
+            solvedCount?: number | undefined;
+            unsolvedCount?: number | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+type ApiInsertManyRulesArgsSchema = typeof apiInsertManyRulesArgsSchema;
+export { apiInsertManyRulesArgsSchema, type ApiInsertManyRulesArgsSchema };
+//# sourceMappingURL=apiInsertManyRulesArgsSchema.d.ts.map

package/dist/rules/api/insertMany/apiInsertManyRulesArgsSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiInsertManyRulesArgsSchema.d.ts","sourceRoot":"","sources":["../../../../src/rules/api/insertMany/apiInsertManyRulesArgsSchema.ts"],"names":[],"mappings":"AAkBA,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOhC,CAAC;AAEH,KAAK,4BAA4B,GAAG,OAAO,4BAA4B,CAAC;AAExE,OAAO,EAAE,4BAA4B,EAAE,KAAK,4BAA4B,EAAE,CAAC"}

package/dist/rules/api/insertMany/apiInsertManyRulesArgsSchema.js

@@ -0,0 +1,13 @@
+import { boolean, object, string } from "zod";
+import { ruleConfigSchema } from "../../rule/config/ruleConfigSchema.js";
+import { ruleIpSchema } from "../../rule/ip/ruleIpSchema.js";
+const apiInsertManyRulesArgsSchema = object({
+    isUserBlocked: boolean(),
+    clientId: string().optional(),
+    description: string().optional(),
+    userIps: ruleIpSchema.array().optional(),
+    userIds: string().array().optional(),
+    config: ruleConfigSchema.optional(),
+});
+export { apiInsertManyRulesArgsSchema };
+//# sourceMappingURL=apiInsertManyRulesArgsSchema.js.map

package/dist/rules/api/insertMany/apiInsertManyRulesArgsSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiInsertManyRulesArgsSchema.js","sourceRoot":"","sources":["../../../../src/rules/api/insertMany/apiInsertManyRulesArgsSchema.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,MAAM,4BAA4B,GAAG,MAAM,CAAC;IAC3C,aAAa,EAAE,OAAO,EAAE;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,WAAW,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE;IACxC,OAAO,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE;IACpC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,EAAE;CACnC,CAAC,CAAC;AAIH,OAAO,EAAE,4BAA4B,EAAqC,CAAC"}