@prosopo/user-access-policy 3.15.7 → 3.15.9

package/dist/types/ruleInput/ruleInput.d.ts

@@ -0,0 +1,204 @@
+import { type ZodType, z } from "zod";
+import type { AccessPolicy, AccessRule, PolicyScope, PolicyScopeExclusions } from "#policy/rule.js";
+import { type AccessRuleEntry, type AccessRulesFilter, FilterScopeMatch } from "#policy/rulesStorage.js";
+import { type UserScopeInput } from "./userScopeInput.js";
+type RuleGroupInput = {
+    groupId?: string;
+    ruleGroupId?: string;
+};
+export type AccessRuleInput = AccessPolicy & PolicyScope & PolicyScopeExclusions & UserScopeInput & RuleGroupInput;
+export declare const accessRuleInput: ZodType<AccessRule, z.ZodTypeDef, unknown>;
+export declare const ruleEntryInput: ZodType<AccessRuleEntry, z.ZodTypeDef, unknown>;
+export type AccessRulesFilterInput = AccessRulesFilter & {
+    userScope?: UserScopeInput;
+    policyScopes?: PolicyScope[];
+};
+export declare const accessRulesFilterInput: z.ZodObject<{
+    policyScope: z.ZodOptional<z.ZodObject<{
+        clientId: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
+    }, "strip", z.ZodTypeAny, {
+        clientId?: string | undefined;
+    }, {
+        clientId?: unknown;
+    }>>;
+    policyScopes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        clientId: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
+    }, "strip", z.ZodTypeAny, {
+        clientId?: string | undefined;
+    }, {
+        clientId?: unknown;
+    }>, "many">>;
+    policyScopeMatch: z.ZodDefault<z.ZodNativeEnum<typeof FilterScopeMatch>>;
+    userScope: z.ZodOptional<z.ZodEffects<z.ZodIntersection<z.ZodIntersection<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodEffects<z.ZodObject<{
+        ip: z.ZodOptional<z.ZodString>;
+        ipMask: z.ZodOptional<z.ZodString>;
+        numericIp: z.ZodOptional<z.ZodBigInt>;
+        numericIpMaskMin: z.ZodOptional<z.ZodBigInt>;
+        numericIpMaskMax: z.ZodOptional<z.ZodBigInt>;
+    }, "strip", z.ZodTypeAny, {
+        ip?: string | undefined;
+        ipMask?: string | undefined;
+        numericIp?: bigint | undefined;
+        numericIpMaskMin?: bigint | undefined;
+        numericIpMaskMax?: bigint | undefined;
+    }, {
+        ip?: string | undefined;
+        ipMask?: string | undefined;
+        numericIp?: bigint | undefined;
+        numericIpMaskMin?: bigint | undefined;
+        numericIpMaskMax?: bigint | undefined;
+    }>, import("#policy/rule.js").UserIp, {
+        ip?: string | undefined;
+        ipMask?: string | undefined;
+        numericIp?: bigint | undefined;
+        numericIpMaskMin?: bigint | undefined;
+        numericIpMaskMax?: bigint | undefined;
+    }>>, z.ZodEffects<z.ZodObject<{
+        userAgent: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        ja4Hash: z.ZodOptional<z.ZodString>;
+        headersHash: z.ZodOptional<z.ZodString>;
+        userAgentHash: z.ZodOptional<z.ZodString>;
+        headHash: z.ZodOptional<z.ZodString>;
+        coords: z.ZodOptional<z.ZodString>;
+        countryCode: z.ZodOptional<z.ZodString>;
+        asn: z.ZodOptional<z.ZodNumber>;
+        os: z.ZodOptional<z.ZodString>;
+        browser: z.ZodOptional<z.ZodString>;
+        headerMatch: z.ZodOptional<z.ZodString>;
+        headerName: z.ZodOptional<z.ZodString>;
+        headerValue: z.ZodOptional<z.ZodString>;
+        headerOperator: z.ZodOptional<z.ZodString>;
+        webBotAuthAgent: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    }, "strip", z.ZodTypeAny, {
+        userAgentHash?: string | undefined;
+        userId?: string | undefined;
+        ja4Hash?: string | undefined;
+        headersHash?: string | undefined;
+        headHash?: string | undefined;
+        coords?: string | undefined;
+        countryCode?: string | undefined;
+        asn?: number | undefined;
+        os?: string | undefined;
+        browser?: string | undefined;
+        headerMatch?: string | undefined;
+        headerName?: string | undefined;
+        headerValue?: string | undefined;
+        headerOperator?: string | undefined;
+        webBotAuthAgent?: string | undefined;
+        userAgent?: string | undefined;
+    }, {
+        userAgentHash?: string | undefined;
+        userId?: string | undefined;
+        ja4Hash?: string | undefined;
+        headersHash?: string | undefined;
+        headHash?: string | undefined;
+        coords?: string | undefined;
+        countryCode?: string | undefined;
+        asn?: number | undefined;
+        os?: string | undefined;
+        browser?: string | undefined;
+        headerMatch?: string | undefined;
+        headerName?: string | undefined;
+        headerValue?: string | undefined;
+        headerOperator?: string | undefined;
+        webBotAuthAgent?: string | undefined;
+        userAgent?: string | undefined;
+    }>, import("#policy/rule.js").UserAttributes, {
+        userAgentHash?: string | undefined;
+        userId?: string | undefined;
+        ja4Hash?: string | undefined;
+        headersHash?: string | undefined;
+        headHash?: string | undefined;
+        coords?: string | undefined;
+        countryCode?: string | undefined;
+        asn?: number | undefined;
+        os?: string | undefined;
+        browser?: string | undefined;
+        headerMatch?: string | undefined;
+        headerName?: string | undefined;
+        headerValue?: string | undefined;
+        headerOperator?: string | undefined;
+        webBotAuthAgent?: string | undefined;
+        userAgent?: string | undefined;
+    }>>, UserScopeInput, {} & {
+        ip?: string | undefined;
+        ipMask?: string | undefined;
+        numericIp?: bigint | undefined;
+        numericIpMaskMin?: bigint | undefined;
+        numericIpMaskMax?: bigint | undefined;
+    } & {
+        userAgentHash?: string | undefined;
+        userId?: string | undefined;
+        ja4Hash?: string | undefined;
+        headersHash?: string | undefined;
+        headHash?: string | undefined;
+        coords?: string | undefined;
+        countryCode?: string | undefined;
+        asn?: number | undefined;
+        os?: string | undefined;
+        browser?: string | undefined;
+        headerMatch?: string | undefined;
+        headerName?: string | undefined;
+        headerValue?: string | undefined;
+        headerOperator?: string | undefined;
+        webBotAuthAgent?: string | undefined;
+        userAgent?: string | undefined;
+    }>>;
+    userScopeMatch: z.ZodDefault<z.ZodNativeEnum<typeof FilterScopeMatch>>;
+    groupId: z.ZodOptional<z.ZodString>;
+    blockOnly: z.ZodOptional<z.ZodBoolean>;
+    includeDeferred: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    policyScopeMatch: FilterScopeMatch;
+    userScopeMatch: FilterScopeMatch;
+    userScope?: UserScopeInput | undefined;
+    groupId?: string | undefined;
+    policyScope?: {
+        clientId?: string | undefined;
+    } | undefined;
+    blockOnly?: boolean | undefined;
+    includeDeferred?: boolean | undefined;
+    policyScopes?: {
+        clientId?: string | undefined;
+    }[] | undefined;
+}, {
+    userScope?: ({} & {
+        ip?: string | undefined;
+        ipMask?: string | undefined;
+        numericIp?: bigint | undefined;
+        numericIpMaskMin?: bigint | undefined;
+        numericIpMaskMax?: bigint | undefined;
+    } & {
+        userAgentHash?: string | undefined;
+        userId?: string | undefined;
+        ja4Hash?: string | undefined;
+        headersHash?: string | undefined;
+        headHash?: string | undefined;
+        coords?: string | undefined;
+        countryCode?: string | undefined;
+        asn?: number | undefined;
+        os?: string | undefined;
+        browser?: string | undefined;
+        headerMatch?: string | undefined;
+        headerName?: string | undefined;
+        headerValue?: string | undefined;
+        headerOperator?: string | undefined;
+        webBotAuthAgent?: string | undefined;
+        userAgent?: string | undefined;
+    }) | undefined;
+    groupId?: string | undefined;
+    policyScope?: {
+        clientId?: unknown;
+    } | undefined;
+    policyScopeMatch?: FilterScopeMatch | undefined;
+    userScopeMatch?: FilterScopeMatch | undefined;
+    blockOnly?: boolean | undefined;
+    includeDeferred?: boolean | undefined;
+    policyScopes?: {
+        clientId?: unknown;
+    }[] | undefined;
+}>;
+export declare const getAccessRuleFiltersFromInput: (filterInput: AccessRulesFilterInput) => AccessRulesFilter[];
+export {};
+//# sourceMappingURL=ruleInput.d.ts.map

package/dist/types/ruleInput/ruleInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruleInput.d.ts","sourceRoot":"","sources":["../../../src/ruleInput/ruleInput.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,WAAW,EACX,qBAAqB,EACrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACN,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,gBAAgB,EAChB,MAAM,yBAAyB,CAAC;AAMjC,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,qBAAqB,CAAC;AAE1E,KAAK,cAAc,GAAG;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,YAAY,GACzC,WAAW,GACX,qBAAqB,GACrB,cAAc,GACd,cAAc,CAAC;AA6BhB,eAAO,MAAM,eAAe,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,EAAE,OAAO,CAQL,CAAC;AAEnE,eAAO,MAAM,cAAc,EAAE,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC,UAAU,EAAE,OAAO,CAIrC,CAAC;AAEvC,MAAM,MAAM,sBAAsB,GAAG,iBAAiB,GAAG;IACxD,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;CAC7B,CAAC;AAQF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaS,CAAC;AAE7C,eAAO,MAAM,6BAA6B,gBAC5B,sBAAsB,KACjC,iBAAiB,EAiBnB,CAAC"}

package/dist/types/ruleInput/userScopeInput.d.ts

@@ -0,0 +1,181 @@
+import { z } from "zod";
+import type { UserAttributes, UserIp } from "#policy/rule.js";
+import type { UserAttributesRecord, UserIpRecord } from "#policy/ruleRecord.js";
+export type UserAttributesInput = UserAttributes & UserAttributesRecord;
+export type UserIpInput = UserIp & UserIpRecord;
+export type UserScopeInput = UserAttributesInput & UserIpInput;
+export declare const userScopeSchema: z.ZodObject<{
+    userId: z.ZodOptional<z.ZodString>;
+    ja4Hash: z.ZodOptional<z.ZodString>;
+    headersHash: z.ZodOptional<z.ZodString>;
+    userAgentHash: z.ZodOptional<z.ZodString>;
+    headHash: z.ZodOptional<z.ZodString>;
+    coords: z.ZodOptional<z.ZodString>;
+    countryCode: z.ZodOptional<z.ZodString>;
+    asn: z.ZodOptional<z.ZodNumber>;
+    os: z.ZodOptional<z.ZodString>;
+    browser: z.ZodOptional<z.ZodString>;
+    headerMatch: z.ZodOptional<z.ZodString>;
+    headerName: z.ZodOptional<z.ZodString>;
+    headerValue: z.ZodOptional<z.ZodString>;
+    headerOperator: z.ZodOptional<z.ZodString>;
+    webBotAuthAgent: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    numericIp: z.ZodOptional<z.ZodBigInt>;
+    numericIpMaskMin: z.ZodOptional<z.ZodBigInt>;
+    numericIpMaskMax: z.ZodOptional<z.ZodBigInt>;
+}, "strip", z.ZodTypeAny, {
+    userAgentHash?: string | undefined;
+    userId?: string | undefined;
+    ja4Hash?: string | undefined;
+    headersHash?: string | undefined;
+    headHash?: string | undefined;
+    coords?: string | undefined;
+    countryCode?: string | undefined;
+    asn?: number | undefined;
+    os?: string | undefined;
+    browser?: string | undefined;
+    headerMatch?: string | undefined;
+    headerName?: string | undefined;
+    headerValue?: string | undefined;
+    headerOperator?: string | undefined;
+    webBotAuthAgent?: string | undefined;
+    numericIp?: bigint | undefined;
+    numericIpMaskMin?: bigint | undefined;
+    numericIpMaskMax?: bigint | undefined;
+}, {
+    userAgentHash?: string | undefined;
+    userId?: string | undefined;
+    ja4Hash?: string | undefined;
+    headersHash?: string | undefined;
+    headHash?: string | undefined;
+    coords?: string | undefined;
+    countryCode?: string | undefined;
+    asn?: number | undefined;
+    os?: string | undefined;
+    browser?: string | undefined;
+    headerMatch?: string | undefined;
+    headerName?: string | undefined;
+    headerValue?: string | undefined;
+    headerOperator?: string | undefined;
+    webBotAuthAgent?: string | undefined;
+    numericIp?: bigint | undefined;
+    numericIpMaskMin?: bigint | undefined;
+    numericIpMaskMax?: bigint | undefined;
+}>;
+export declare const userScopeInput: z.ZodEffects<z.ZodIntersection<z.ZodIntersection<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodEffects<z.ZodObject<{
+    ip: z.ZodOptional<z.ZodString>;
+    ipMask: z.ZodOptional<z.ZodString>;
+    numericIp: z.ZodOptional<z.ZodBigInt>;
+    numericIpMaskMin: z.ZodOptional<z.ZodBigInt>;
+    numericIpMaskMax: z.ZodOptional<z.ZodBigInt>;
+}, "strip", z.ZodTypeAny, {
+    ip?: string | undefined;
+    ipMask?: string | undefined;
+    numericIp?: bigint | undefined;
+    numericIpMaskMin?: bigint | undefined;
+    numericIpMaskMax?: bigint | undefined;
+}, {
+    ip?: string | undefined;
+    ipMask?: string | undefined;
+    numericIp?: bigint | undefined;
+    numericIpMaskMin?: bigint | undefined;
+    numericIpMaskMax?: bigint | undefined;
+}>, UserIp, {
+    ip?: string | undefined;
+    ipMask?: string | undefined;
+    numericIp?: bigint | undefined;
+    numericIpMaskMin?: bigint | undefined;
+    numericIpMaskMax?: bigint | undefined;
+}>>, z.ZodEffects<z.ZodObject<{
+    userAgent: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    ja4Hash: z.ZodOptional<z.ZodString>;
+    headersHash: z.ZodOptional<z.ZodString>;
+    userAgentHash: z.ZodOptional<z.ZodString>;
+    headHash: z.ZodOptional<z.ZodString>;
+    coords: z.ZodOptional<z.ZodString>;
+    countryCode: z.ZodOptional<z.ZodString>;
+    asn: z.ZodOptional<z.ZodNumber>;
+    os: z.ZodOptional<z.ZodString>;
+    browser: z.ZodOptional<z.ZodString>;
+    headerMatch: z.ZodOptional<z.ZodString>;
+    headerName: z.ZodOptional<z.ZodString>;
+    headerValue: z.ZodOptional<z.ZodString>;
+    headerOperator: z.ZodOptional<z.ZodString>;
+    webBotAuthAgent: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+}, "strip", z.ZodTypeAny, {
+    userAgentHash?: string | undefined;
+    userId?: string | undefined;
+    ja4Hash?: string | undefined;
+    headersHash?: string | undefined;
+    headHash?: string | undefined;
+    coords?: string | undefined;
+    countryCode?: string | undefined;
+    asn?: number | undefined;
+    os?: string | undefined;
+    browser?: string | undefined;
+    headerMatch?: string | undefined;
+    headerName?: string | undefined;
+    headerValue?: string | undefined;
+    headerOperator?: string | undefined;
+    webBotAuthAgent?: string | undefined;
+    userAgent?: string | undefined;
+}, {
+    userAgentHash?: string | undefined;
+    userId?: string | undefined;
+    ja4Hash?: string | undefined;
+    headersHash?: string | undefined;
+    headHash?: string | undefined;
+    coords?: string | undefined;
+    countryCode?: string | undefined;
+    asn?: number | undefined;
+    os?: string | undefined;
+    browser?: string | undefined;
+    headerMatch?: string | undefined;
+    headerName?: string | undefined;
+    headerValue?: string | undefined;
+    headerOperator?: string | undefined;
+    webBotAuthAgent?: string | undefined;
+    userAgent?: string | undefined;
+}>, UserAttributes, {
+    userAgentHash?: string | undefined;
+    userId?: string | undefined;
+    ja4Hash?: string | undefined;
+    headersHash?: string | undefined;
+    headHash?: string | undefined;
+    coords?: string | undefined;
+    countryCode?: string | undefined;
+    asn?: number | undefined;
+    os?: string | undefined;
+    browser?: string | undefined;
+    headerMatch?: string | undefined;
+    headerName?: string | undefined;
+    headerValue?: string | undefined;
+    headerOperator?: string | undefined;
+    webBotAuthAgent?: string | undefined;
+    userAgent?: string | undefined;
+}>>, UserScopeInput, {} & {
+    ip?: string | undefined;
+    ipMask?: string | undefined;
+    numericIp?: bigint | undefined;
+    numericIpMaskMin?: bigint | undefined;
+    numericIpMaskMax?: bigint | undefined;
+} & {
+    userAgentHash?: string | undefined;
+    userId?: string | undefined;
+    ja4Hash?: string | undefined;
+    headersHash?: string | undefined;
+    headHash?: string | undefined;
+    coords?: string | undefined;
+    countryCode?: string | undefined;
+    asn?: number | undefined;
+    os?: string | undefined;
+    browser?: string | undefined;
+    headerMatch?: string | undefined;
+    headerName?: string | undefined;
+    headerValue?: string | undefined;
+    headerOperator?: string | undefined;
+    webBotAuthAgent?: string | undefined;
+    userAgent?: string | undefined;
+}>;
+//# sourceMappingURL=userScopeInput.d.ts.map

package/dist/types/ruleInput/userScopeInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userScopeInput.d.ts","sourceRoot":"","sources":["../../../src/ruleInput/userScopeInput.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAgB,CAAC,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAa,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAEhF,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,oBAAoB,CAAC;AAkExE,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,YAAY,CAAC;AAsChD,MAAM,MAAM,cAAc,GAAG,mBAAmB,GAAG,WAAW,CAAC;AAE/D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGgC,CAAC;AAE7D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQzB,CAAC"}

package/dist/types/ruleRecord.d.ts

@@ -0,0 +1,18 @@
+import type { AccessPolicy, PolicyScope, PolicyScopeExclusions, UserAttributes } from "#policy/rule.js";
+export type UserAttributesRecord = Omit<UserAttributes, "userAgentHash"> & {
+    userAgent?: string;
+};
+export declare const userAttributesRecordFields: ["userId", "ja4Hash", "headersHash", "userAgent", "headHash", "coords", "countryCode", "asn", "os", "browser", "headerMatch", "headerName", "headerValue", "headerOperator", "webBotAuthAgent"];
+export type UserIpRecord = {
+    ip?: string;
+    ipMask?: string;
+};
+export declare const userIpRecordFields: ["ip", "ipMask"];
+export type UserScopeRecord = UserAttributesRecord & UserIpRecord;
+export declare const userScopeRecordFields: ["userId", "ja4Hash", "headersHash", "userAgent", "headHash", "coords", "countryCode", "asn", "os", "browser", "headerMatch", "headerName", "headerValue", "headerOperator", "webBotAuthAgent", "ip", "ipMask"];
+export type UserScopeRecordField = (typeof userScopeRecordFields)[number];
+export type AccessRuleRecord = AccessPolicy & PolicyScope & PolicyScopeExclusions & UserScopeRecord & {
+    ruleGroupId?: string;
+};
+export declare const getUserScopeRecordFromAccessRuleRecord: (ruleRecord: AccessRuleRecord) => UserScopeRecord;
+//# sourceMappingURL=ruleRecord.d.ts.map

package/dist/types/ruleRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruleRecord.d.ts","sourceRoot":"","sources":["../../src/ruleRecord.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACX,YAAY,EACZ,WAAW,EACX,qBAAqB,EACrB,cAAc,EACd,MAAM,iBAAiB,CAAC;AAEzB,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,cAAc,EAAE,eAAe,CAAC,GAAG;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,0BAA0B,iMAgBY,CAAC;AAEpD,MAAM,MAAM,YAAY,GAAG;IAE1B,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,kBAAkB,kBAGY,CAAC;AAE5C,MAAM,MAAM,eAAe,GAAG,oBAAoB,GAAG,YAAY,CAAC;AAElE,eAAO,MAAM,qBAAqB,iNAGY,CAAC;AAE/C,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1E,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAC1C,WAAW,GACX,qBAAqB,GACrB,eAAe,GAAG;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEH,eAAO,MAAM,sCAAsC,eACtC,gBAAgB,KAC1B,eAKD,CAAC"}

package/dist/types/rulesStorage.d.ts

@@ -0,0 +1,32 @@
+import type { AccessRule, PolicyScope, UserScope } from "#policy/rule.js";
+export declare enum FilterScopeMatch {
+    Exact = "exact",
+    Greedy = "greedy"
+}
+export type AccessRulesFilter = {
+    policyScope?: PolicyScope;
+    policyScopeMatch?: FilterScopeMatch;
+    userScope?: UserScope;
+    userScopeMatch?: FilterScopeMatch;
+    groupId?: string;
+    blockOnly?: boolean;
+    includeDeferred?: boolean;
+};
+export type AccessRuleEntry = {
+    rule: AccessRule;
+    expiresUnixTimestamp?: number;
+};
+export type AccessRulesReader = {
+    fetchRules(ruleIds: string[]): Promise<AccessRuleEntry[]>;
+    getMissingRuleIds(ruleIds: string[]): Promise<string[]>;
+    findRules(filter: AccessRulesFilter, matchingFieldsOnly?: boolean, skipEmptyUserScopes?: boolean): Promise<AccessRule[]>;
+    findRuleIds(filter: AccessRulesFilter, matchingFieldsOnly?: boolean): Promise<string[]>;
+    fetchAllRuleIds(batchHandler: (ruleIds: string[]) => Promise<void>): Promise<void>;
+};
+export type AccessRulesWriter = {
+    insertRules(ruleEntries: AccessRuleEntry[]): Promise<string[]>;
+    deleteRules(ruleIds: string[]): Promise<void>;
+    deleteAllRules(): Promise<number>;
+};
+export type AccessRulesStorage = AccessRulesReader & AccessRulesWriter;
+//# sourceMappingURL=rulesStorage.d.ts.map

package/dist/types/rulesStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulesStorage.d.ts","sourceRoot":"","sources":["../../src/rulesStorage.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE1E,oBAAY,gBAAgB;IAC3B,KAAK,UAAU;IACf,MAAM,WAAW;CACjB;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC/B,WAAW,CAAC,EAAE,WAAW,CAAC;IAK1B,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,SAAS,CAAC,EAAE,SAAS,CAAC;IAKtB,cAAc,CAAC,EAAE,gBAAgB,CAAC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IASjB,SAAS,CAAC,EAAE,OAAO,CAAC;IASpB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC/B,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IAE1D,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAExD,SAAS,CACR,MAAM,EAAE,iBAAiB,EACzB,kBAAkB,CAAC,EAAE,OAAO,EAC5B,mBAAmB,CAAC,EAAE,OAAO,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAEzB,WAAW,CACV,MAAM,EAAE,iBAAiB,EACzB,kBAAkB,CAAC,EAAE,OAAO,GAC1B,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAErB,eAAe,CACd,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAChD,OAAO,CAAC,IAAI,CAAC,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC/B,WAAW,CAAC,WAAW,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAE/D,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9C,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,iBAAiB,GAAG,iBAAiB,CAAC"}

package/dist/types/tests/blockingRuleShapes.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=blockingRuleShapes.unit.test.d.ts.map

package/dist/types/tests/blockingRuleShapes.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockingRuleShapes.unit.test.d.ts","sourceRoot":"","sources":["../../../src/tests/blockingRuleShapes.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/classifyBrowser.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=classifyBrowser.unit.test.d.ts.map

package/dist/types/tests/classifyBrowser.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifyBrowser.unit.test.d.ts","sourceRoot":"","sources":["../../../src/tests/classifyBrowser.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/classifyOs.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=classifyOs.unit.test.d.ts.map

package/dist/types/tests/classifyOs.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifyOs.unit.test.d.ts","sourceRoot":"","sources":["../../../src/tests/classifyOs.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/headerMatch.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=headerMatch.unit.test.d.ts.map

package/dist/types/tests/headerMatch.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headerMatch.unit.test.d.ts","sourceRoot":"","sources":["../../../src/tests/headerMatch.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/insertRulesEndpoint.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=insertRulesEndpoint.unit.test.d.ts.map

package/dist/types/tests/insertRulesEndpoint.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertRulesEndpoint.unit.test.d.ts","sourceRoot":"","sources":["../../../src/tests/insertRulesEndpoint.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/matchedRule.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=matchedRule.unit.test.d.ts.map

package/dist/types/tests/matchedRule.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchedRule.unit.test.d.ts","sourceRoot":"","sources":["../../../src/tests/matchedRule.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/policyInput.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=policyInput.unit.test.d.ts.map

package/dist/types/tests/policyInput.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policyInput.unit.test.d.ts","sourceRoot":"","sources":["../../../src/tests/policyInput.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/redis/deferredPoolClause.benchmark.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deferredPoolClause.benchmark.d.ts.map

package/dist/types/tests/redis/deferredPoolClause.benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferredPoolClause.benchmark.d.ts","sourceRoot":"","sources":["../../../../src/tests/redis/deferredPoolClause.benchmark.ts"],"names":[],"mappings":""}

package/dist/types/tests/redis/reader/redisAggregate.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=redisAggregate.unit.test.d.ts.map

package/dist/types/tests/redis/reader/redisAggregate.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisAggregate.unit.test.d.ts","sourceRoot":"","sources":["../../../../../src/tests/redis/reader/redisAggregate.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/redis/reader/redisRulesQuery.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=redisRulesQuery.unit.test.d.ts.map

package/dist/types/tests/redis/reader/redisRulesQuery.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisRulesQuery.unit.test.d.ts","sourceRoot":"","sources":["../../../../../src/tests/redis/reader/redisRulesQuery.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/redis/reader/redisRulesSplitQuery.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=redisRulesSplitQuery.unit.test.d.ts.map

package/dist/types/tests/redis/reader/redisRulesSplitQuery.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisRulesSplitQuery.unit.test.d.ts","sourceRoot":"","sources":["../../../../../src/tests/redis/reader/redisRulesSplitQuery.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/redis/redisRulesReaderLoad.benchmark.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=redisRulesReaderLoad.benchmark.integration.test.d.ts.map

package/dist/types/tests/redis/redisRulesReaderLoad.benchmark.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisRulesReaderLoad.benchmark.integration.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/redis/redisRulesReaderLoad.benchmark.integration.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/redis/redisRulesReaderRank.benchmark.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=redisRulesReaderRank.benchmark.integration.test.d.ts.map

package/dist/types/tests/redis/redisRulesReaderRank.benchmark.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisRulesReaderRank.benchmark.integration.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/redis/redisRulesReaderRank.benchmark.integration.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/redis/redisRulesStorage.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=redisRulesStorage.integration.test.d.ts.map

package/dist/types/tests/redis/redisRulesStorage.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisRulesStorage.integration.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/redis/redisRulesStorage.integration.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/testLogger.d.ts

@@ -0,0 +1,4 @@
+import type { Logger } from "@prosopo/logger";
+declare const loggerMockedInstance: Logger;
+export { loggerMockedInstance };
+//# sourceMappingURL=testLogger.d.ts.map

package/dist/types/tests/testLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testLogger.d.ts","sourceRoot":"","sources":["../../../src/tests/testLogger.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAG9C,QAAA,MAAM,oBAAoB,EAAE,MAkB3B,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/types/tests/transformRule.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transformRule.unit.test.d.ts.map

package/dist/types/tests/transformRule.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformRule.unit.test.d.ts","sourceRoot":"","sources":["../../../src/tests/transformRule.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/transformRule.d.ts

@@ -0,0 +1,7 @@
+import type { AccessRule } from "./rule.js";
+import type { AccessRuleRecord } from "./ruleRecord.js";
+export declare const makeAccessRuleHash: (rule: AccessRule) => string;
+export declare const transformAccessRuleRecordIntoRule: (ruleRecord: AccessRuleRecord) => AccessRule;
+export declare const transformAccessRuleIntoRecord: (rule: AccessRule) => AccessRuleRecord;
+export declare const getCidrFromNumericIpRange: (startIp: bigint, endIp: bigint) => string | undefined;
+//# sourceMappingURL=transformRule.d.ts.map

package/dist/types/transformRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformRule.d.ts","sourceRoot":"","sources":["../../src/transformRule.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAQ5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAcxD,eAAO,MAAM,kBAAkB,SAAU,UAAU,KAAG,MAarD,CAAC;AAEF,eAAO,MAAM,iCAAiC,eACjC,gBAAgB,KAC1B,UAE+B,CAAC;AAEnC,eAAO,MAAM,6BAA6B,SACnC,UAAU,KACd,gBAAwD,CAAC;AAmE5D,eAAO,MAAM,yBAAyB,YAC5B,MAAM,SACR,MAAM,KACX,MAAM,GAAG,SASX,CAAC"}

package/entries.ts

@@ -14,7 +14,7 @@
 
 import fg from "fast-glob";
 
-// package.json maps "#policy/*" to "./dist/*", so every emitted module is
+// package.json maps "#policy/*" to "./dist/esm/*", so every emitted module is
 // importable by consumers (the unit tests do exactly that). vite-plugin-no-bundle
 // emits one file per source module either way, but rolldown prunes named exports
 // that no *in-graph* module imports — rollup kept them. Left as just the four