@prosopo/types 3.0.6 → 3.5.3

package/dist/cjs/index.cjs

@@ -29,11 +29,22 @@ exports.Tier = user.Tier;
 exports.TierMonthlyLimits = user.TierMonthlyLimits;
 exports.TierSchema = user.TierSchema;
 exports.ClientSettingsSchema = settings.ClientSettingsSchema;
+exports.IPValidationAction = settings.IPValidationAction;
+exports.IPValidationActionSchema = settings.IPValidationActionSchema;
+exports.IPValidationRulesSchema = settings.IPValidationRulesSchema;
+exports.abuseScoreThresholdDefault = settings.abuseScoreThresholdDefault;
+exports.abuseScoreThresholdExceedActionDefault = settings.abuseScoreThresholdExceedActionDefault;
 exports.captchaTypeDefault = settings.captchaTypeDefault;
+exports.cityChangeActionDefault = settings.cityChangeActionDefault;
+exports.countryChangeActionDefault = settings.countryChangeActionDefault;
+exports.distanceExceedActionDefault = settings.distanceExceedActionDefault;
+exports.distanceThresholdKmDefault = settings.distanceThresholdKmDefault;
 exports.domainsDefault = settings.domainsDefault;
 exports.frictionlessThresholdDefault = settings.frictionlessThresholdDefault;
 exports.imageThresholdDefault = settings.imageThresholdDefault;
+exports.ispChangeActionDefault = settings.ispChangeActionDefault;
 exports.powDifficultyDefault = settings.powDifficultyDefault;
+exports.requireAllConditionsDefault = settings.requireAllConditionsDefault;
 exports.CaptchaType = captchaType.CaptchaType;
 exports.CaptchaTypeSchema = captchaType.CaptchaTypeSchema;
 exports.CaptchaTypeSpec = captchaTypeSpec.CaptchaTypeSpec;
@@ -42,6 +53,7 @@ exports.CaptchaTimeoutSchema = config.CaptchaTimeoutSchema;
 exports.DatabaseConfigSchema = config.DatabaseConfigSchema;
 exports.DatabaseTypes = config.DatabaseTypes;
 exports.EnvironmentTypesSchema = config.EnvironmentTypesSchema;
+exports.IpApiServiceSpec = config.IpApiServiceSpec;
 exports.Mode = config.Mode;
 exports.ModeEnum = config.ModeEnum;
 exports.PolkadotSecretJSONSpec = config.PolkadotSecretJSONSpec;
@@ -65,6 +77,7 @@ exports.DEFAULT_POW_CAPTCHA_VERIFIED_TIMEOUT = timeouts.DEFAULT_POW_CAPTCHA_VERI
 exports.FrictionlessPenalties = frictionless.FrictionlessPenalties;
 exports.PENALTY_ACCESS_RULE_DEFAULT = frictionless.PENALTY_ACCESS_RULE_DEFAULT;
 exports.PENALTY_OLD_TIMESTAMP_DEFAULT = frictionless.PENALTY_OLD_TIMESTAMP_DEFAULT;
+exports.PENALTY_UNVERIFIED_HOST_DEFAULT = frictionless.PENALTY_UNVERIFIED_HOST_DEFAULT;
 exports.CaptchaItemSchema = captcha.CaptchaItemSchema;
 exports.CaptchaItemTypes = captcha.CaptchaItemTypes;
 exports.CaptchaSchema = captcha.CaptchaSchema;
@@ -112,11 +125,13 @@ exports.ProsopoCaptchaCountConfigSchema = api.ProsopoCaptchaCountConfigSchema;
 exports.ProviderDefaultRateLimits = api.ProviderDefaultRateLimits;
 exports.PublicApiPaths = api.PublicApiPaths;
 exports.RegisterSitekeyBody = api.RegisterSitekeyBody;
+exports.RemoveDetectorKeyBodySpec = api.RemoveDetectorKeyBodySpec;
 exports.ServerPowCaptchaVerifyRequestBody = api.ServerPowCaptchaVerifyRequestBody;
 exports.SubmitPowCaptchaSolutionBody = api.SubmitPowCaptchaSolutionBody;
 exports.UpdateDetectorKeyBody = api.UpdateDetectorKeyBody;
 exports.VerifyPowCaptchaSolutionBody = api.VerifyPowCaptchaSolutionBody;
 exports.VerifySolutionBody = api.VerifySolutionBody;
+exports.providerDetailsSchema = api.providerDetailsSchema;
 exports.ScheduledTaskNames = scheduler.ScheduledTaskNames;
 exports.ScheduledTaskStatus = scheduler.ScheduledTaskStatus;
 exports.ProcaptchaResponse = manager.ProcaptchaResponse;

package/dist/cjs/provider/api.cjs

@@ -30,6 +30,15 @@ var PublicApiPaths = /* @__PURE__ */ ((PublicApiPaths2) => {
   PublicApiPaths2["GetProviderDetails"] = "/v1/prosopo/provider/public/details";
   return PublicApiPaths2;
 })(PublicApiPaths || {});
+const providerDetailsSchema = z.object({
+  version: z.string(),
+  message: z.string(),
+  redis: z.object({
+    actor: z.string(),
+    isReady: z.boolean(),
+    awaitingTimeSeconds: z.number()
+  }).array()
+});
 var AdminApiPaths = /* @__PURE__ */ ((AdminApiPaths2) => {
   AdminApiPaths2["SiteKeyRegister"] = "/v1/prosopo/provider/admin/sitekey/register";
   AdminApiPaths2["UpdateDetectorKey"] = "/v1/prosopo/provider/admin/detector/update";
@@ -178,6 +187,10 @@ const RegisterSitekeyBody = z.object({
 const UpdateDetectorKeyBody = z.object({
   [params.ApiParams.detectorKey]: z.string()
 });
+const RemoveDetectorKeyBodySpec = z.object({
+  [params.ApiParams.detectorKey]: z.string(),
+  [params.ApiParams.expirationInSeconds]: z.number().positive().optional()
+});
 const ProsopoCaptchaCountConfigSchema = z.object({
   solved: z.object({
     count: z.number().positive()
@@ -219,8 +232,10 @@ exports.ProsopoCaptchaCountConfigSchema = ProsopoCaptchaCountConfigSchema;
 exports.ProviderDefaultRateLimits = ProviderDefaultRateLimits;
 exports.PublicApiPaths = PublicApiPaths;
 exports.RegisterSitekeyBody = RegisterSitekeyBody;
+exports.RemoveDetectorKeyBodySpec = RemoveDetectorKeyBodySpec;
 exports.ServerPowCaptchaVerifyRequestBody = ServerPowCaptchaVerifyRequestBody;
 exports.SubmitPowCaptchaSolutionBody = SubmitPowCaptchaSolutionBody;
 exports.UpdateDetectorKeyBody = UpdateDetectorKeyBody;
 exports.VerifyPowCaptchaSolutionBody = VerifyPowCaptchaSolutionBody;
 exports.VerifySolutionBody = VerifySolutionBody;
+exports.providerDetailsSchema = providerDetailsSchema;

package/dist/cjs/provider/detection.cjs

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

package/dist/cjs/provider/index.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./accounts.cjs");
 const api = require("./api.cjs");
 const scheduler = require("./scheduler.cjs");
+require("./detection.cjs");
 exports.AdminApiPaths = api.AdminApiPaths;
 exports.ApiPathRateLimits = api.ApiPathRateLimits;
 exports.ApiPrefix = api.ApiPrefix;
@@ -20,10 +21,12 @@ exports.ProsopoCaptchaCountConfigSchema = api.ProsopoCaptchaCountConfigSchema;
 exports.ProviderDefaultRateLimits = api.ProviderDefaultRateLimits;
 exports.PublicApiPaths = api.PublicApiPaths;
 exports.RegisterSitekeyBody = api.RegisterSitekeyBody;
+exports.RemoveDetectorKeyBodySpec = api.RemoveDetectorKeyBodySpec;
 exports.ServerPowCaptchaVerifyRequestBody = api.ServerPowCaptchaVerifyRequestBody;
 exports.SubmitPowCaptchaSolutionBody = api.SubmitPowCaptchaSolutionBody;
 exports.UpdateDetectorKeyBody = api.UpdateDetectorKeyBody;
 exports.VerifyPowCaptchaSolutionBody = api.VerifyPowCaptchaSolutionBody;
 exports.VerifySolutionBody = api.VerifySolutionBody;
+exports.providerDetailsSchema = api.providerDetailsSchema;
 exports.ScheduledTaskNames = scheduler.ScheduledTaskNames;
 exports.ScheduledTaskStatus = scheduler.ScheduledTaskStatus;

package/dist/client/index.js

@@ -1,5 +1,5 @@
 import { Tier, TierMonthlyLimits, TierSchema } from "./user.js";
-import { ClientSettingsSchema, captchaTypeDefault, domainsDefault, frictionlessThresholdDefault, imageThresholdDefault, powDifficultyDefault } from "./settings.js";
+import { ClientSettingsSchema, IPValidationAction, IPValidationActionSchema, IPValidationRulesSchema, abuseScoreThresholdDefault, abuseScoreThresholdExceedActionDefault, captchaTypeDefault, cityChangeActionDefault, countryChangeActionDefault, distanceExceedActionDefault, distanceThresholdKmDefault, domainsDefault, frictionlessThresholdDefault, imageThresholdDefault, ispChangeActionDefault, powDifficultyDefault, requireAllConditionsDefault } from "./settings.js";
 import { CaptchaType, CaptchaTypeSchema } from "./captchaType/captchaType.js";
 import { CaptchaTypeSpec } from "./captchaType/captchaTypeSpec.js";
 export {
@@ -7,12 +7,23 @@ export {
   CaptchaTypeSchema,
   CaptchaTypeSpec,
   ClientSettingsSchema,
+  IPValidationAction,
+  IPValidationActionSchema,
+  IPValidationRulesSchema,
   Tier,
   TierMonthlyLimits,
   TierSchema,
+  abuseScoreThresholdDefault,
+  abuseScoreThresholdExceedActionDefault,
   captchaTypeDefault,
+  cityChangeActionDefault,
+  countryChangeActionDefault,
+  distanceExceedActionDefault,
+  distanceThresholdKmDefault,
   domainsDefault,
   frictionlessThresholdDefault,
   imageThresholdDefault,
-  powDifficultyDefault
+  ispChangeActionDefault,
+  powDifficultyDefault,
+  requireAllConditionsDefault
 };

package/dist/client/settings.d.ts

@@ -1,28 +1,376 @@
-import { type output } from "zod";
+import { type output, z } from "zod";
 import { CaptchaType } from "./captchaType/captchaType.js";
 export declare const captchaTypeDefault = CaptchaType.frictionless;
 export declare const domainsDefault: string[];
 export declare const frictionlessThresholdDefault = 0.5;
 export declare const powDifficultyDefault = 4;
 export declare const imageThresholdDefault = 0.8;
-export declare const ClientSettingsSchema: import("zod").ZodObject<{
-    captchaType: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNativeEnum<typeof CaptchaType>>>;
-    domains: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>>;
-    frictionlessThreshold: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
-    powDifficulty: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
-    imageThreshold: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
-}, "strip", import("zod").ZodTypeAny, {
+export declare enum IPValidationAction {
+    Allow = "allow",
+    Reject = "reject",
+    Flag = "flag"
+}
+export type IPValidateCondition = {
+    met: boolean;
+    action: IPValidationAction;
+    message: string;
+};
+export declare const IPValidationActionSchema: z.ZodNativeEnum<typeof IPValidationAction>;
+export declare const countryChangeActionDefault = IPValidationAction.Allow;
+export declare const cityChangeActionDefault = IPValidationAction.Allow;
+export declare const ispChangeActionDefault = IPValidationAction.Allow;
+export declare const distanceThresholdKmDefault = 1000;
+export declare const abuseScoreThresholdDefault = 0.005;
+export declare const distanceExceedActionDefault = IPValidationAction.Reject;
+export declare const abuseScoreThresholdExceedActionDefault = IPValidationAction.Reject;
+export declare const requireAllConditionsDefault = false;
+declare const IPValidationSchema: z.ZodObject<{
+    actions: z.ZodObject<{
+        countryChangeAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+        cityChangeAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+        ispChangeAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+        distanceExceedAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+        abuseScoreExceedAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+    }, "strip", z.ZodTypeAny, {
+        countryChangeAction?: IPValidationAction | undefined;
+        cityChangeAction?: IPValidationAction | undefined;
+        ispChangeAction?: IPValidationAction | undefined;
+        distanceExceedAction?: IPValidationAction | undefined;
+        abuseScoreExceedAction?: IPValidationAction | undefined;
+    }, {
+        countryChangeAction?: IPValidationAction | undefined;
+        cityChangeAction?: IPValidationAction | undefined;
+        ispChangeAction?: IPValidationAction | undefined;
+        distanceExceedAction?: IPValidationAction | undefined;
+        abuseScoreExceedAction?: IPValidationAction | undefined;
+    }>;
+    distanceThresholdKm: z.ZodOptional<z.ZodNumber>;
+    abuseScoreThreshold: z.ZodOptional<z.ZodNumber>;
+    requireAllConditions: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    actions: {
+        countryChangeAction?: IPValidationAction | undefined;
+        cityChangeAction?: IPValidationAction | undefined;
+        ispChangeAction?: IPValidationAction | undefined;
+        distanceExceedAction?: IPValidationAction | undefined;
+        abuseScoreExceedAction?: IPValidationAction | undefined;
+    };
+    distanceThresholdKm?: number | undefined;
+    abuseScoreThreshold?: number | undefined;
+    requireAllConditions?: boolean | undefined;
+}, {
+    actions: {
+        countryChangeAction?: IPValidationAction | undefined;
+        cityChangeAction?: IPValidationAction | undefined;
+        ispChangeAction?: IPValidationAction | undefined;
+        distanceExceedAction?: IPValidationAction | undefined;
+        abuseScoreExceedAction?: IPValidationAction | undefined;
+    };
+    distanceThresholdKm?: number | undefined;
+    abuseScoreThreshold?: number | undefined;
+    requireAllConditions?: boolean | undefined;
+}>;
+export declare const IPValidationRulesSchema: z.ZodObject<{
+    actions: z.ZodObject<{
+        countryChangeAction: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+        cityChangeAction: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+        ispChangeAction: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+        distanceExceedAction: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+        abuseScoreExceedAction: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+    }, "strip", z.ZodTypeAny, {
+        countryChangeAction: IPValidationAction;
+        cityChangeAction: IPValidationAction;
+        ispChangeAction: IPValidationAction;
+        distanceExceedAction: IPValidationAction;
+        abuseScoreExceedAction: IPValidationAction;
+    }, {
+        countryChangeAction?: IPValidationAction | undefined;
+        cityChangeAction?: IPValidationAction | undefined;
+        ispChangeAction?: IPValidationAction | undefined;
+        distanceExceedAction?: IPValidationAction | undefined;
+        abuseScoreExceedAction?: IPValidationAction | undefined;
+    }>;
+    distanceThresholdKm: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    abuseScoreThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    requireAllConditions: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    countryOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        actions: z.ZodObject<{
+            countryChangeAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+            cityChangeAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+            ispChangeAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+            distanceExceedAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+            abuseScoreExceedAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+        }, "strip", z.ZodTypeAny, {
+            countryChangeAction?: IPValidationAction | undefined;
+            cityChangeAction?: IPValidationAction | undefined;
+            ispChangeAction?: IPValidationAction | undefined;
+            distanceExceedAction?: IPValidationAction | undefined;
+            abuseScoreExceedAction?: IPValidationAction | undefined;
+        }, {
+            countryChangeAction?: IPValidationAction | undefined;
+            cityChangeAction?: IPValidationAction | undefined;
+            ispChangeAction?: IPValidationAction | undefined;
+            distanceExceedAction?: IPValidationAction | undefined;
+            abuseScoreExceedAction?: IPValidationAction | undefined;
+        }>;
+        distanceThresholdKm: z.ZodOptional<z.ZodNumber>;
+        abuseScoreThreshold: z.ZodOptional<z.ZodNumber>;
+        requireAllConditions: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        actions: {
+            countryChangeAction?: IPValidationAction | undefined;
+            cityChangeAction?: IPValidationAction | undefined;
+            ispChangeAction?: IPValidationAction | undefined;
+            distanceExceedAction?: IPValidationAction | undefined;
+            abuseScoreExceedAction?: IPValidationAction | undefined;
+        };
+        distanceThresholdKm?: number | undefined;
+        abuseScoreThreshold?: number | undefined;
+        requireAllConditions?: boolean | undefined;
+    }, {
+        actions: {
+            countryChangeAction?: IPValidationAction | undefined;
+            cityChangeAction?: IPValidationAction | undefined;
+            ispChangeAction?: IPValidationAction | undefined;
+            distanceExceedAction?: IPValidationAction | undefined;
+            abuseScoreExceedAction?: IPValidationAction | undefined;
+        };
+        distanceThresholdKm?: number | undefined;
+        abuseScoreThreshold?: number | undefined;
+        requireAllConditions?: boolean | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    actions: {
+        countryChangeAction: IPValidationAction;
+        cityChangeAction: IPValidationAction;
+        ispChangeAction: IPValidationAction;
+        distanceExceedAction: IPValidationAction;
+        abuseScoreExceedAction: IPValidationAction;
+    };
+    distanceThresholdKm: number;
+    abuseScoreThreshold: number;
+    requireAllConditions: boolean;
+    countryOverrides?: Record<string, {
+        actions: {
+            countryChangeAction?: IPValidationAction | undefined;
+            cityChangeAction?: IPValidationAction | undefined;
+            ispChangeAction?: IPValidationAction | undefined;
+            distanceExceedAction?: IPValidationAction | undefined;
+            abuseScoreExceedAction?: IPValidationAction | undefined;
+        };
+        distanceThresholdKm?: number | undefined;
+        abuseScoreThreshold?: number | undefined;
+        requireAllConditions?: boolean | undefined;
+    }> | undefined;
+}, {
+    actions: {
+        countryChangeAction?: IPValidationAction | undefined;
+        cityChangeAction?: IPValidationAction | undefined;
+        ispChangeAction?: IPValidationAction | undefined;
+        distanceExceedAction?: IPValidationAction | undefined;
+        abuseScoreExceedAction?: IPValidationAction | undefined;
+    };
+    distanceThresholdKm?: number | undefined;
+    abuseScoreThreshold?: number | undefined;
+    requireAllConditions?: boolean | undefined;
+    countryOverrides?: Record<string, {
+        actions: {
+            countryChangeAction?: IPValidationAction | undefined;
+            cityChangeAction?: IPValidationAction | undefined;
+            ispChangeAction?: IPValidationAction | undefined;
+            distanceExceedAction?: IPValidationAction | undefined;
+            abuseScoreExceedAction?: IPValidationAction | undefined;
+        };
+        distanceThresholdKm?: number | undefined;
+        abuseScoreThreshold?: number | undefined;
+        requireAllConditions?: boolean | undefined;
+    }> | undefined;
+}>;
+export declare const ClientSettingsSchema: z.ZodObject<{
+    captchaType: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof CaptchaType>>>;
+    domains: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    frictionlessThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    powDifficulty: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    imageThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    ipValidationRules: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodObject<{
+            countryChangeAction: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+            cityChangeAction: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+            ispChangeAction: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+            distanceExceedAction: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+            abuseScoreExceedAction: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+        }, "strip", z.ZodTypeAny, {
+            countryChangeAction: IPValidationAction;
+            cityChangeAction: IPValidationAction;
+            ispChangeAction: IPValidationAction;
+            distanceExceedAction: IPValidationAction;
+            abuseScoreExceedAction: IPValidationAction;
+        }, {
+            countryChangeAction?: IPValidationAction | undefined;
+            cityChangeAction?: IPValidationAction | undefined;
+            ispChangeAction?: IPValidationAction | undefined;
+            distanceExceedAction?: IPValidationAction | undefined;
+            abuseScoreExceedAction?: IPValidationAction | undefined;
+        }>;
+        distanceThresholdKm: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        abuseScoreThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        requireAllConditions: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        countryOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            actions: z.ZodObject<{
+                countryChangeAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+                cityChangeAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+                ispChangeAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+                distanceExceedAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+                abuseScoreExceedAction: z.ZodOptional<z.ZodOptional<z.ZodNativeEnum<typeof IPValidationAction>>>;
+            }, "strip", z.ZodTypeAny, {
+                countryChangeAction?: IPValidationAction | undefined;
+                cityChangeAction?: IPValidationAction | undefined;
+                ispChangeAction?: IPValidationAction | undefined;
+                distanceExceedAction?: IPValidationAction | undefined;
+                abuseScoreExceedAction?: IPValidationAction | undefined;
+            }, {
+                countryChangeAction?: IPValidationAction | undefined;
+                cityChangeAction?: IPValidationAction | undefined;
+                ispChangeAction?: IPValidationAction | undefined;
+                distanceExceedAction?: IPValidationAction | undefined;
+                abuseScoreExceedAction?: IPValidationAction | undefined;
+            }>;
+            distanceThresholdKm: z.ZodOptional<z.ZodNumber>;
+            abuseScoreThreshold: z.ZodOptional<z.ZodNumber>;
+            requireAllConditions: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            actions: {
+                countryChangeAction?: IPValidationAction | undefined;
+                cityChangeAction?: IPValidationAction | undefined;
+                ispChangeAction?: IPValidationAction | undefined;
+                distanceExceedAction?: IPValidationAction | undefined;
+                abuseScoreExceedAction?: IPValidationAction | undefined;
+            };
+            distanceThresholdKm?: number | undefined;
+            abuseScoreThreshold?: number | undefined;
+            requireAllConditions?: boolean | undefined;
+        }, {
+            actions: {
+                countryChangeAction?: IPValidationAction | undefined;
+                cityChangeAction?: IPValidationAction | undefined;
+                ispChangeAction?: IPValidationAction | undefined;
+                distanceExceedAction?: IPValidationAction | undefined;
+                abuseScoreExceedAction?: IPValidationAction | undefined;
+            };
+            distanceThresholdKm?: number | undefined;
+            abuseScoreThreshold?: number | undefined;
+            requireAllConditions?: boolean | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        actions: {
+            countryChangeAction: IPValidationAction;
+            cityChangeAction: IPValidationAction;
+            ispChangeAction: IPValidationAction;
+            distanceExceedAction: IPValidationAction;
+            abuseScoreExceedAction: IPValidationAction;
+        };
+        distanceThresholdKm: number;
+        abuseScoreThreshold: number;
+        requireAllConditions: boolean;
+        countryOverrides?: Record<string, {
+            actions: {
+                countryChangeAction?: IPValidationAction | undefined;
+                cityChangeAction?: IPValidationAction | undefined;
+                ispChangeAction?: IPValidationAction | undefined;
+                distanceExceedAction?: IPValidationAction | undefined;
+                abuseScoreExceedAction?: IPValidationAction | undefined;
+            };
+            distanceThresholdKm?: number | undefined;
+            abuseScoreThreshold?: number | undefined;
+            requireAllConditions?: boolean | undefined;
+        }> | undefined;
+    }, {
+        actions: {
+            countryChangeAction?: IPValidationAction | undefined;
+            cityChangeAction?: IPValidationAction | undefined;
+            ispChangeAction?: IPValidationAction | undefined;
+            distanceExceedAction?: IPValidationAction | undefined;
+            abuseScoreExceedAction?: IPValidationAction | undefined;
+        };
+        distanceThresholdKm?: number | undefined;
+        abuseScoreThreshold?: number | undefined;
+        requireAllConditions?: boolean | undefined;
+        countryOverrides?: Record<string, {
+            actions: {
+                countryChangeAction?: IPValidationAction | undefined;
+                cityChangeAction?: IPValidationAction | undefined;
+                ispChangeAction?: IPValidationAction | undefined;
+                distanceExceedAction?: IPValidationAction | undefined;
+                abuseScoreExceedAction?: IPValidationAction | undefined;
+            };
+            distanceThresholdKm?: number | undefined;
+            abuseScoreThreshold?: number | undefined;
+            requireAllConditions?: boolean | undefined;
+        }> | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
     captchaType: CaptchaType;
     domains: string[];
     frictionlessThreshold: number;
     powDifficulty: number;
     imageThreshold: number;
+    ipValidationRules?: {
+        actions: {
+            countryChangeAction: IPValidationAction;
+            cityChangeAction: IPValidationAction;
+            ispChangeAction: IPValidationAction;
+            distanceExceedAction: IPValidationAction;
+            abuseScoreExceedAction: IPValidationAction;
+        };
+        distanceThresholdKm: number;
+        abuseScoreThreshold: number;
+        requireAllConditions: boolean;
+        countryOverrides?: Record<string, {
+            actions: {
+                countryChangeAction?: IPValidationAction | undefined;
+                cityChangeAction?: IPValidationAction | undefined;
+                ispChangeAction?: IPValidationAction | undefined;
+                distanceExceedAction?: IPValidationAction | undefined;
+                abuseScoreExceedAction?: IPValidationAction | undefined;
+            };
+            distanceThresholdKm?: number | undefined;
+            abuseScoreThreshold?: number | undefined;
+            requireAllConditions?: boolean | undefined;
+        }> | undefined;
+    } | undefined;
 }, {
     captchaType?: CaptchaType | undefined;
     domains?: string[] | undefined;
     frictionlessThreshold?: number | undefined;
     powDifficulty?: number | undefined;
     imageThreshold?: number | undefined;
+    ipValidationRules?: {
+        actions: {
+            countryChangeAction?: IPValidationAction | undefined;
+            cityChangeAction?: IPValidationAction | undefined;
+            ispChangeAction?: IPValidationAction | undefined;
+            distanceExceedAction?: IPValidationAction | undefined;
+            abuseScoreExceedAction?: IPValidationAction | undefined;
+        };
+        distanceThresholdKm?: number | undefined;
+        abuseScoreThreshold?: number | undefined;
+        requireAllConditions?: boolean | undefined;
+        countryOverrides?: Record<string, {
+            actions: {
+                countryChangeAction?: IPValidationAction | undefined;
+                cityChangeAction?: IPValidationAction | undefined;
+                ispChangeAction?: IPValidationAction | undefined;
+                distanceExceedAction?: IPValidationAction | undefined;
+                abuseScoreExceedAction?: IPValidationAction | undefined;
+            };
+            distanceThresholdKm?: number | undefined;
+            abuseScoreThreshold?: number | undefined;
+            requireAllConditions?: boolean | undefined;
+        }> | undefined;
+    } | undefined;
 }>;
 export type IUserSettings = output<typeof ClientSettingsSchema>;
+export type IIPValidationRules = output<typeof IPValidationRulesSchema>;
+export type IIPValidation = output<typeof IPValidationSchema>;
+export {};
 //# sourceMappingURL=settings.d.ts.map

package/dist/client/settings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/client/settings.ts"],"names":[],"mappings":"AAaA,OAAO,EAAyB,KAAK,MAAM,EAAU,MAAM,KAAK,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAG3D,eAAO,MAAM,kBAAkB,2BAA2B,CAAC;AAC3D,eAAO,MAAM,cAAc,EAAE,MAAM,EAAO,CAAC;AAC3C,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAChD,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EAU/B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/client/settings.ts"],"names":[],"mappings":"AAaA,OAAO,EAAkC,KAAK,MAAM,EAAU,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAG3D,eAAO,MAAM,kBAAkB,2BAA2B,CAAC;AAC3D,eAAO,MAAM,cAAc,EAAE,MAAM,EAAO,CAAC;AAC3C,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAChD,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAGzC,oBAAY,kBAAkB;IAC7B,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,IAAI,SAAS;CACb;AAED,MAAM,MAAM,mBAAmB,GAAG;IACjC,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,wBAAwB,4CAAmC,CAAC;AAGzE,eAAO,MAAM,0BAA0B,2BAA2B,CAAC;AACnE,eAAO,MAAM,uBAAuB,2BAA2B,CAAC;AAChE,eAAO,MAAM,sBAAsB,2BAA2B,CAAC;AAC/D,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAC/C,eAAO,MAAM,0BAA0B,QAAQ,CAAC;AAChD,eAAO,MAAM,2BAA2B,4BAA4B,CAAC;AACrE,eAAO,MAAM,sCAAsC,4BAA4B,CAAC;AAChF,eAAO,MAAM,2BAA2B,QAAQ,CAAC;AAEjD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYtB,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgClC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW/B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAChE,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/client/settings.js

@@ -1,4 +1,4 @@
-import { object, number, array, string } from "zod";
+import { z, object, boolean, number, string, array } from "zod";
 import { CaptchaType } from "./captchaType/captchaType.js";
 import { CaptchaTypeSpec } from "./captchaType/captchaTypeSpec.js";
 const captchaTypeDefault = CaptchaType.frictionless;
@@ -6,18 +6,82 @@ const domainsDefault = [];
 const frictionlessThresholdDefault = 0.5;
 const powDifficultyDefault = 4;
 const imageThresholdDefault = 0.8;
+var IPValidationAction = /* @__PURE__ */ ((IPValidationAction2) => {
+  IPValidationAction2["Allow"] = "allow";
+  IPValidationAction2["Reject"] = "reject";
+  IPValidationAction2["Flag"] = "flag";
+  return IPValidationAction2;
+})(IPValidationAction || {});
+const IPValidationActionSchema = z.nativeEnum(IPValidationAction);
+const countryChangeActionDefault = "allow";
+const cityChangeActionDefault = "allow";
+const ispChangeActionDefault = "allow";
+const distanceThresholdKmDefault = 1e3;
+const abuseScoreThresholdDefault = 5e-3;
+const distanceExceedActionDefault = "reject";
+const abuseScoreThresholdExceedActionDefault = "reject";
+const requireAllConditionsDefault = false;
+const IPValidationSchema = object({
+  actions: object({
+    countryChangeAction: IPValidationActionSchema.optional(),
+    cityChangeAction: IPValidationActionSchema.optional(),
+    ispChangeAction: IPValidationActionSchema.optional(),
+    distanceExceedAction: IPValidationActionSchema.optional(),
+    abuseScoreExceedAction: IPValidationActionSchema.optional()
+  }).partial(),
+  // all optional, so you can just override what you need
+  distanceThresholdKm: number().positive().optional(),
+  abuseScoreThreshold: number().positive().optional(),
+  requireAllConditions: boolean().optional()
+});
+const IPValidationRulesSchema = object({
+  actions: object({
+    countryChangeAction: IPValidationActionSchema.optional().default(
+      countryChangeActionDefault
+    ),
+    cityChangeAction: IPValidationActionSchema.optional().default(
+      cityChangeActionDefault
+    ),
+    ispChangeAction: IPValidationActionSchema.optional().default(
+      ispChangeActionDefault
+    ),
+    distanceExceedAction: IPValidationActionSchema.optional().default(
+      distanceExceedActionDefault
+    ),
+    abuseScoreExceedAction: IPValidationActionSchema.optional().default(
+      abuseScoreThresholdExceedActionDefault
+    )
+  }),
+  distanceThresholdKm: number().positive().optional().default(distanceThresholdKmDefault),
+  abuseScoreThreshold: number().positive().optional().default(abuseScoreThresholdDefault),
+  requireAllConditions: z.boolean().optional().default(requireAllConditionsDefault),
+  // overrides are now lightweight, not recursive
+  countryOverrides: z.record(string(), IPValidationSchema).optional()
+});
 const ClientSettingsSchema = object({
   captchaType: CaptchaTypeSpec.optional().default(captchaTypeDefault),
   domains: array(string()).optional().default([...domainsDefault]),
   frictionlessThreshold: number().optional().default(frictionlessThresholdDefault),
   powDifficulty: number().optional().default(powDifficultyDefault),
-  imageThreshold: number().optional().default(imageThresholdDefault)
+  imageThreshold: number().optional().default(imageThresholdDefault),
+  ipValidationRules: IPValidationRulesSchema.optional()
 });
 export {
   ClientSettingsSchema,
+  IPValidationAction,
+  IPValidationActionSchema,
+  IPValidationRulesSchema,
+  abuseScoreThresholdDefault,
+  abuseScoreThresholdExceedActionDefault,
   captchaTypeDefault,
+  cityChangeActionDefault,
+  countryChangeActionDefault,
+  distanceExceedActionDefault,
+  distanceThresholdKmDefault,
   domainsDefault,
   frictionlessThresholdDefault,
   imageThresholdDefault,
-  powDifficultyDefault
+  ispChangeActionDefault,
+  powDifficultyDefault,
+  requireAllConditionsDefault
 };