@prosopo/types-database 3.0.9 → 3.0.10

package/dist/types/provider.js

@@ -1,254 +1,279 @@
 import { TranslationKeysSchema } from "@prosopo/locale";
-import { CaptchaType, Tier } from "@prosopo/types";
-import { CaptchaSolutionSchema, CaptchaStatus, ScheduledTaskNames, ScheduledTaskStatus, TimestampSchema, } from "@prosopo/types";
-import mongoose from "mongoose";
-import { Schema } from "mongoose";
-import { any, array, bigint, boolean, nativeEnum, object, string, union, instanceof as zInstanceof, } from "zod";
+import { Tier, CaptchaStatus, TimestampSchema, CaptchaSolutionSchema, ScheduledTaskStatus, ScheduledTaskNames, CaptchaType } from "@prosopo/types";
+import mongoose, { Schema } from "mongoose";
+import { object, string, nativeEnum, union, instanceof as _instanceof, boolean, bigint, array, any } from "zod";
 import { UserSettingsSchema } from "./client.js";
 const ONE_HOUR = 60 * 60;
 const ONE_DAY = ONE_HOUR * 24;
 const ONE_WEEK = ONE_DAY * 7;
 const ONE_MONTH = ONE_WEEK * 4;
 const TEN_MINUTES = 10 * 60;
-export const ClientRecordSchema = new Schema({
-    account: String,
-    settings: UserSettingsSchema,
-    tier: { type: String, enum: Tier, required: true },
+const ClientRecordSchema = new Schema({
+  account: String,
+  settings: UserSettingsSchema,
+  tier: { type: String, enum: Tier, required: true }
 });
 ClientRecordSchema.index({ account: 1 });
 const CaptchaResultSchema = object({
-    status: nativeEnum(CaptchaStatus),
-    reason: TranslationKeysSchema.optional(),
-    error: string().optional(),
-});
-export const UserCommitmentSchema = object({
-    userAccount: string(),
-    dappAccount: string(),
-    datasetId: string(),
-    providerAccount: string(),
-    id: string(),
-    result: CaptchaResultSchema,
-    userSignature: string(),
-    ipAddress: bigint(),
-    headers: object({}).catchall(string()),
-    ja4: string(),
-    userSubmitted: boolean(),
-    serverChecked: boolean(),
-    storedAtTimestamp: TimestampSchema.optional(),
-    requestedAtTimestamp: TimestampSchema,
-    lastUpdatedTimestamp: TimestampSchema.optional(),
-    frictionlessTokenId: union([
-        string(),
-        zInstanceof(mongoose.Types.ObjectId),
-    ]).optional(),
-});
-export const CaptchaRecordSchema = new Schema({
-    captchaId: { type: String, required: true },
-    captchaContentId: { type: String, required: true },
-    assetURI: { type: String, required: false },
-    datasetId: { type: String, required: true },
-    datasetContentId: { type: String, required: true },
-    solved: { type: Boolean, required: true },
-    target: { type: String, required: true },
-    salt: { type: String, required: true },
-    items: {
-        type: [
-            new Schema({
-                hash: { type: String, required: true },
-                data: { type: String, required: true },
-                type: { type: String, required: true },
-            }, { _id: false }),
-        ],
-        required: true,
-    },
+  status: nativeEnum(CaptchaStatus),
+  reason: TranslationKeysSchema.optional(),
+  error: string().optional()
+});
+const UserCommitmentSchema = object({
+  userAccount: string(),
+  dappAccount: string(),
+  datasetId: string(),
+  providerAccount: string(),
+  id: string(),
+  result: CaptchaResultSchema,
+  userSignature: string(),
+  ipAddress: bigint(),
+  headers: object({}).catchall(string()),
+  ja4: string(),
+  userSubmitted: boolean(),
+  serverChecked: boolean(),
+  storedAtTimestamp: TimestampSchema.optional(),
+  requestedAtTimestamp: TimestampSchema,
+  lastUpdatedTimestamp: TimestampSchema.optional(),
+  frictionlessTokenId: union([
+    string(),
+    _instanceof(mongoose.Types.ObjectId)
+  ]).optional()
+});
+const CaptchaRecordSchema = new Schema({
+  captchaId: { type: String, required: true },
+  captchaContentId: { type: String, required: true },
+  assetURI: { type: String, required: false },
+  datasetId: { type: String, required: true },
+  datasetContentId: { type: String, required: true },
+  solved: { type: Boolean, required: true },
+  target: { type: String, required: true },
+  salt: { type: String, required: true },
+  items: {
+    type: [
+      new Schema(
+        {
+          hash: { type: String, required: true },
+          data: { type: String, required: true },
+          type: { type: String, required: true }
+        },
+        { _id: false }
+      )
+    ],
+    required: true
+  }
 });
 CaptchaRecordSchema.index({ captchaId: 1 });
 CaptchaRecordSchema.index({ datasetId: 1 });
 CaptchaRecordSchema.index({ datasetId: 1, solved: 1 });
-export const PoWCaptchaRecordSchema = new Schema({
-    challenge: { type: String, required: true },
-    dappAccount: { type: String, required: true },
-    userAccount: { type: String, required: true },
-    requestedAtTimestamp: { type: Number, required: true },
-    lastUpdatedTimestamp: { type: Number, required: false },
-    result: {
-        status: { type: String, enum: CaptchaStatus, required: true },
-        reason: {
-            type: String,
-            enum: TranslationKeysSchema.options,
-            required: false,
-        },
-        error: { type: String, required: false },
-    },
-    difficulty: { type: Number, required: true },
-    ipAddress: { type: BigInt, required: true },
-    headers: { type: Object, required: true },
-    ja4: { type: String, required: true },
-    userSignature: { type: String, required: false },
-    userSubmitted: { type: Boolean, required: true },
-    serverChecked: { type: Boolean, required: true },
-    storedAtTimestamp: { type: Date, required: false, expires: ONE_MONTH },
-    geolocation: { type: String, required: false },
-    vpn: { type: Boolean, required: false },
-    frictionlessTokenId: {
-        type: mongoose.Schema.Types.ObjectId,
-        required: false,
+const PoWCaptchaRecordSchema = new Schema({
+  challenge: { type: String, required: true },
+  dappAccount: { type: String, required: true },
+  userAccount: { type: String, required: true },
+  requestedAtTimestamp: { type: Number, required: true },
+  lastUpdatedTimestamp: { type: Number, required: false },
+  result: {
+    status: { type: String, enum: CaptchaStatus, required: true },
+    reason: {
+      type: String,
+      enum: TranslationKeysSchema.options,
+      required: false
     },
+    error: { type: String, required: false }
+  },
+  difficulty: { type: Number, required: true },
+  ipAddress: { type: BigInt, required: true },
+  headers: { type: Object, required: true },
+  ja4: { type: String, required: true },
+  userSignature: { type: String, required: false },
+  userSubmitted: { type: Boolean, required: true },
+  serverChecked: { type: Boolean, required: true },
+  storedAtTimestamp: { type: Date, required: false, expires: ONE_MONTH },
+  geolocation: { type: String, required: false },
+  vpn: { type: Boolean, required: false },
+  frictionlessTokenId: {
+    type: mongoose.Schema.Types.ObjectId,
+    required: false
+  }
 });
 PoWCaptchaRecordSchema.index({ challenge: 1 });
 PoWCaptchaRecordSchema.index({ storedAtTimestamp: 1 });
 PoWCaptchaRecordSchema.index({ storedAtTimestamp: 1, lastUpdatedTimestamp: 1 });
 PoWCaptchaRecordSchema.index({ dappAccount: 1, requestedAtTimestamp: 1 });
-export const UserCommitmentRecordSchema = new Schema({
-    userAccount: { type: String, required: true },
-    dappAccount: { type: String, required: true },
-    providerAccount: { type: String, required: true },
-    datasetId: { type: String, required: true },
-    id: { type: String, required: true },
-    result: {
-        status: { type: String, enum: CaptchaStatus, required: true },
-        reason: {
-            type: String,
-            enum: TranslationKeysSchema.options,
-            required: false,
-        },
-        error: { type: String, required: false },
-    },
-    ipAddress: { type: BigInt, required: true },
-    headers: { type: Object, required: true },
-    ja4: { type: String, required: true },
-    userSignature: { type: String, required: true },
-    userSubmitted: { type: Boolean, required: true },
-    serverChecked: { type: Boolean, required: true },
-    storedAtTimestamp: { type: Number, required: false },
-    requestedAtTimestamp: { type: Number, required: true },
-    lastUpdatedTimestamp: { type: Number, required: false },
-    geolocation: { type: String, required: false },
-    vpn: { type: Boolean, required: false },
-    frictionlessTokenId: {
-        type: mongoose.Schema.Types.ObjectId,
-        required: false,
+const UserCommitmentRecordSchema = new Schema({
+  userAccount: { type: String, required: true },
+  dappAccount: { type: String, required: true },
+  providerAccount: { type: String, required: true },
+  datasetId: { type: String, required: true },
+  id: { type: String, required: true },
+  result: {
+    status: { type: String, enum: CaptchaStatus, required: true },
+    reason: {
+      type: String,
+      enum: TranslationKeysSchema.options,
+      required: false
     },
+    error: { type: String, required: false }
+  },
+  ipAddress: { type: BigInt, required: true },
+  headers: { type: Object, required: true },
+  ja4: { type: String, required: true },
+  userSignature: { type: String, required: true },
+  userSubmitted: { type: Boolean, required: true },
+  serverChecked: { type: Boolean, required: true },
+  storedAtTimestamp: { type: Number, required: false },
+  requestedAtTimestamp: { type: Number, required: true },
+  lastUpdatedTimestamp: { type: Number, required: false },
+  geolocation: { type: String, required: false },
+  vpn: { type: Boolean, required: false },
+  frictionlessTokenId: {
+    type: mongoose.Schema.Types.ObjectId,
+    required: false
+  }
 });
 UserCommitmentRecordSchema.index({ id: -1 });
 UserCommitmentRecordSchema.index({ storedAtTimestamp: 1 });
 UserCommitmentRecordSchema.index({
-    storedAtTimestamp: 1,
-    lastUpdatedTimestamp: 1,
+  storedAtTimestamp: 1,
+  lastUpdatedTimestamp: 1
 });
 UserCommitmentRecordSchema.index({ userAccount: 1, dappAccount: 1 });
-export const DatasetRecordSchema = new Schema({
-    contentTree: { type: [[String]], required: true },
-    datasetContentId: { type: String, required: true },
-    datasetId: { type: String, required: true },
-    format: { type: String, required: true },
-    solutionTree: { type: [[String]], required: true },
+const DatasetRecordSchema = new Schema({
+  contentTree: { type: [[String]], required: true },
+  datasetContentId: { type: String, required: true },
+  datasetId: { type: String, required: true },
+  format: { type: String, required: true },
+  solutionTree: { type: [[String]], required: true }
 });
 DatasetRecordSchema.index({ datasetId: 1 });
-export const SolutionRecordSchema = new Schema({
-    captchaId: { type: String, required: true },
-    captchaContentId: { type: String, required: true },
-    datasetId: { type: String, required: true },
-    datasetContentId: { type: String, required: true },
-    salt: { type: String, required: true },
-    solution: { type: [String], required: true },
+const SolutionRecordSchema = new Schema({
+  captchaId: { type: String, required: true },
+  captchaContentId: { type: String, required: true },
+  datasetId: { type: String, required: true },
+  datasetContentId: { type: String, required: true },
+  salt: { type: String, required: true },
+  solution: { type: [String], required: true }
 });
 SolutionRecordSchema.index({ captchaId: 1 });
-export const UserSolutionSchema = CaptchaSolutionSchema.extend({
-    processed: boolean(),
-    checked: boolean(),
-    commitmentId: string(),
+const UserSolutionSchema = CaptchaSolutionSchema.extend({
+  processed: boolean(),
+  checked: boolean(),
+  commitmentId: string()
 });
-export const UserSolutionRecordSchema = new Schema({
+const UserSolutionRecordSchema = new Schema(
+  {
     captchaId: { type: String, required: true },
     captchaContentId: { type: String, required: true },
     salt: { type: String, required: true },
     solution: [{ type: String, required: true }],
     processed: { type: Boolean, required: true },
     checked: { type: Boolean, required: true },
-    commitmentId: { type: String, required: true },
-}, { _id: false });
+    commitmentId: { type: String, required: true }
+  },
+  { _id: false }
+);
 UserSolutionRecordSchema.index({ captchaId: 1 });
 UserSolutionRecordSchema.index({ commitmentId: -1 });
-export const UserCommitmentWithSolutionsSchema = UserCommitmentSchema.extend({
-    captchas: array(UserSolutionSchema),
+const UserCommitmentWithSolutionsSchema = UserCommitmentSchema.extend({
+  captchas: array(UserSolutionSchema)
 });
-export const PendingRecordSchema = new Schema({
-    accountId: { type: String, required: true },
-    pending: { type: Boolean, required: true },
-    salt: { type: String, required: true },
-    requestHash: { type: String, required: true },
-    deadlineTimestamp: { type: Number, required: true },
-    requestedAtTimestamp: { type: Date, required: true, expires: ONE_WEEK },
-    ipAddress: { type: BigInt, required: true },
-    frictionlessTokenId: {
-        type: mongoose.Schema.Types.ObjectId,
-        required: false,
-    },
-    threshold: { type: Number, required: true, default: 0.8 },
+const PendingRecordSchema = new Schema({
+  accountId: { type: String, required: true },
+  pending: { type: Boolean, required: true },
+  salt: { type: String, required: true },
+  requestHash: { type: String, required: true },
+  deadlineTimestamp: { type: Number, required: true },
+  // unix timestamp
+  requestedAtTimestamp: { type: Date, required: true, expires: ONE_WEEK },
+  ipAddress: { type: BigInt, required: true },
+  frictionlessTokenId: {
+    type: mongoose.Schema.Types.ObjectId,
+    required: false
+  },
+  threshold: { type: Number, required: true, default: 0.8 }
 });
 PendingRecordSchema.index({ requestHash: -1 });
-export const ScheduledTaskSchema = object({
-    processName: nativeEnum(ScheduledTaskNames),
-    datetime: TimestampSchema,
-    updated: TimestampSchema.optional(),
-    status: nativeEnum(ScheduledTaskStatus),
-    result: object({
-        data: any().optional(),
-        error: any().optional(),
-    }).optional(),
-});
-export const ScheduledTaskRecordSchema = new Schema({
-    processName: { type: String, enum: ScheduledTaskNames, required: true },
-    datetime: { type: Date, required: true, expires: ONE_WEEK },
-    updated: { type: Number, required: false },
-    status: { type: String, enum: ScheduledTaskStatus, required: true },
-    result: {
-        type: new Schema({
-            error: { type: String, required: false },
-            data: { type: Object, required: false },
-        }, { _id: false }),
-        required: false,
-    },
+const ScheduledTaskSchema = object({
+  processName: nativeEnum(ScheduledTaskNames),
+  datetime: TimestampSchema,
+  updated: TimestampSchema.optional(),
+  status: nativeEnum(ScheduledTaskStatus),
+  result: object({
+    data: any().optional(),
+    error: any().optional()
+  }).optional()
+});
+const ScheduledTaskRecordSchema = new Schema({
+  processName: { type: String, enum: ScheduledTaskNames, required: true },
+  datetime: { type: Date, required: true, expires: ONE_WEEK },
+  updated: { type: Number, required: false },
+  status: { type: String, enum: ScheduledTaskStatus, required: true },
+  result: {
+    type: new Schema(
+      {
+        error: { type: String, required: false },
+        data: { type: Object, required: false }
+      },
+      { _id: false }
+    ),
+    required: false
+  }
 });
 ScheduledTaskRecordSchema.index({ processName: 1 });
 ScheduledTaskRecordSchema.index({ processName: 1, status: 1 });
 ScheduledTaskRecordSchema.index({ _id: 1, status: 1 });
-export const FrictionlessTokenRecordSchema = new Schema({
-    token: { type: String, required: true, unique: true },
-    score: { type: Number, required: true },
-    threshold: { type: Number, required: true },
-    scoreComponents: {
-        baseScore: { type: Number, required: true },
-        lScore: { type: Number, required: false },
-        timeout: { type: Number, required: false },
-        accessPolicy: { type: Number, required: false },
-    },
-    createdAt: { type: Date, default: Date.now, expires: ONE_DAY },
-    storedAtTimestamp: { type: Date, required: false },
-    lastUpdatedTimestamp: { type: Date, required: false },
+const FrictionlessTokenRecordSchema = new Schema({
+  token: { type: String, required: true, unique: true },
+  score: { type: Number, required: true },
+  threshold: { type: Number, required: true },
+  scoreComponents: {
+    baseScore: { type: Number, required: true },
+    lScore: { type: Number, required: false },
+    timeout: { type: Number, required: false },
+    accessPolicy: { type: Number, required: false }
+  },
+  createdAt: { type: Date, default: Date.now, expires: ONE_DAY },
+  storedAtTimestamp: { type: Date, required: false },
+  lastUpdatedTimestamp: { type: Date, required: false }
 });
 FrictionlessTokenRecordSchema.index({ token: 1 }, { unique: true });
 FrictionlessTokenRecordSchema.index({ storedAtTimestamp: 1 });
-export const SessionRecordSchema = new Schema({
-    sessionId: { type: String, required: true, unique: true },
-    createdAt: { type: Date, required: true, expires: ONE_DAY },
-    tokenId: {
-        type: mongoose.Schema.Types.ObjectId,
-    },
-    captchaType: { type: String, enum: CaptchaType, required: true },
-    storedAtTimestamp: { type: Date, required: false },
-    lastUpdatedTimestamp: { type: Date, required: false },
-    deleted: { type: Boolean, required: false },
+const SessionRecordSchema = new Schema({
+  sessionId: { type: String, required: true, unique: true },
+  createdAt: { type: Date, required: true, expires: ONE_DAY },
+  tokenId: {
+    type: mongoose.Schema.Types.ObjectId
+  },
+  captchaType: { type: String, enum: CaptchaType, required: true },
+  storedAtTimestamp: { type: Date, required: false },
+  lastUpdatedTimestamp: { type: Date, required: false },
+  deleted: { type: Boolean, required: false }
 });
 SessionRecordSchema.index({ sessionId: 1 }, { unique: true });
 SessionRecordSchema.index({ storedAtTimestamp: 1 });
 SessionRecordSchema.index({ deleted: 1 });
-export const DetectorRecordSchema = new Schema({
-    createdAt: { type: Date, required: true },
-    detectorKey: { type: String, required: true },
-    expiresAt: { type: Date, required: false, expires: 0 },
+const DetectorRecordSchema = new Schema({
+  createdAt: { type: Date, required: true },
+  detectorKey: { type: String, required: true },
+  expiresAt: { type: Date, required: false, expires: 0 }
 });
 DetectorRecordSchema.index({ createdAt: 1 }, { unique: true });
 DetectorRecordSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
-//# sourceMappingURL=provider.js.map
+export {
+  CaptchaRecordSchema,
+  ClientRecordSchema,
+  DatasetRecordSchema,
+  DetectorRecordSchema,
+  FrictionlessTokenRecordSchema,
+  PendingRecordSchema,
+  PoWCaptchaRecordSchema,
+  ScheduledTaskRecordSchema,
+  ScheduledTaskSchema,
+  SessionRecordSchema,
+  SolutionRecordSchema,
+  UserCommitmentRecordSchema,
+  UserCommitmentSchema,
+  UserCommitmentWithSolutionsSchema,
+  UserSolutionRecordSchema,
+  UserSolutionSchema
+};

package/package.json

@@ -1,24 +1,28 @@
 {
 	"name": "@prosopo/types-database",
-	"version": "3.0.9",
+	"version": "3.0.10",
 	"description": "Types for prosopo database",
-	"main": "dist/index.js",
 	"type": "module",
-	"engines": {
-		"node": "20",
-		"npm": "10.8.2"
-	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
 	"exports": {
 		".": {
+			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js",
 			"require": "./dist/cjs/index.cjs"
 		}
 	},
+	"engines": {
+		"node": "20",
+		"npm": "10.8.2"
+	},
 	"scripts": {
-		"test": "echo \"No test specified\"",
-		"clean": "tsc --build --clean",
-		"build": "tsc --build --verbose",
-		"build:cjs": "npx vite --config vite.cjs.config.ts build"
+		"clean": "del-cli --verbose dist tsconfig.tsbuildinfo",
+		"build": "NODE_ENV=${NODE_ENV:-production}; vite build --config vite.esm.config.ts --mode $NODE_ENV",
+		"build:tsc": "tsc --build --verbose",
+		"build:cjs": "NODE_ENV=${NODE_ENV:-production}; vite build --config vite.cjs.config.ts --mode $NODE_ENV",
+		"typecheck": "tsc --build --declaration --emitDeclarationOnly",
+		"test": "echo no tests"
 	},
 	"repository": {
 		"type": "git",
@@ -31,21 +35,21 @@
 	},
 	"homepage": "https://github.com/prosopo/captcha#readme",
 	"dependencies": {
-		"@prosopo/common": "3.0.2",
-		"@prosopo/types": "3.0.3",
-		"@prosopo/user-access-policy": "3.3.0",
+		"@prosopo/common": "3.1.0",
+		"@prosopo/types": "3.0.4",
+		"@prosopo/user-access-policy": "3.3.1",
 		"@typegoose/auto-increment": "4.13.0",
 		"axios": "1.10.0",
 		"esbuild": "0.25.6",
 		"express": "4.21.2",
 		"mongodb": "6.9.0",
-		"mongoose": "8.13.0",
+		"mongoose": "8.6.2",
+		"zod": "3.23.8",
+		"@prosopo/config": "3.1.1",
 		"openpgp": "5.11.3",
-		"webpack-dev-server": "5.2.2",
-		"zod": "3.23.8"
+		"webpack-dev-server": "5.2.2"
 	},
 	"devDependencies": {
-		"@prosopo/config": "3.1.0",
 		"@vitest/coverage-v8": "3.0.9",
 		"concurrently": "9.0.1",
 		"del-cli": "6.0.0",

package/vite.cjs.config.ts

@@ -16,7 +16,7 @@ import { ViteCommonJSConfig } from "@prosopo/config";
 
 export default function () {
 	return ViteCommonJSConfig(
-		"types-database",
-		path.resolve("./tsconfig.cjs.json"),
+		path.basename("."),
+		path.resolve("./tsconfig.json"),
 	);
 }

package/vite.esm.config.ts

@@ -0,0 +1,20 @@
+// Copyright 2021-2025 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import path from "node:path";
+import { ViteEsmConfig } from "@prosopo/config";
+
+export default function () {
+	return ViteEsmConfig(path.basename("."), path.resolve("./tsconfig.json"));
+}

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./types/index.js";
-export type { PendingCaptchaRequest } from "./provider/pendingCaptchaRequest.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,kBAAkB,CAAC;AACjC,YAAY,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC"}

package/dist/index.js.map

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

package/dist/provider/pendingCaptchaRequest.d.ts

@@ -1,14 +0,0 @@
-import { ApiParams } from "@prosopo/types";
-import type { FrictionlessTokenId } from "../types/index.js";
-export interface PendingCaptchaRequest {
-    accountId: string;
-    pending: boolean;
-    salt: string;
-    [ApiParams.requestHash]: string;
-    deadlineTimestamp: number;
-    requestedAtTimestamp: number;
-    ipAddress: bigint;
-    frictionlessTokenId?: FrictionlessTokenId;
-    threshold: number;
-}
-//# sourceMappingURL=pendingCaptchaRequest.d.ts.map

package/dist/provider/pendingCaptchaRequest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pendingCaptchaRequest.d.ts","sourceRoot":"","sources":["../../src/provider/pendingCaptchaRequest.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,SAAS,EAAuB,MAAM,gBAAgB,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,MAAM,WAAW,qBAAqB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAChC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,SAAS,EAAE,MAAM,CAAC;CAClB"}

package/dist/provider/pendingCaptchaRequest.js

@@ -1,2 +0,0 @@
-import { ApiParams } from "@prosopo/types";
-//# sourceMappingURL=pendingCaptchaRequest.js.map

package/dist/provider/pendingCaptchaRequest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pendingCaptchaRequest.js","sourceRoot":"","sources":["../../src/provider/pendingCaptchaRequest.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,SAAS,EAAuB,MAAM,gBAAgB,CAAC"}

package/dist/types/captcha.d.ts

@@ -1,22 +0,0 @@
-import type { PoWCaptcha } from "@prosopo/types";
-import { type RootFilterQuery, Schema } from "mongoose";
-import type { IDatabase } from "./mongo.js";
-import { type PoWCaptchaRecord, type ScoreComponents, type SessionRecord, type UserCommitment, type UserCommitmentRecord } from "./provider.js";
-export type StoredSession = Pick<SessionRecord, "_id" | "sessionId" | "createdAt" | "captchaType" | "deleted" | "tokenId"> & {
-    score: number;
-    scoreComponents: ScoreComponents;
-    threshold: number;
-};
-export declare const StoredSessionRecordSchema: Schema;
-export declare const StoredUserCommitmentRecordSchema: Schema;
-export declare const StoredPoWCaptchaRecordSchema: Schema;
-export interface ICaptchaDatabase extends IDatabase {
-    saveCaptchas(sessionEvents: StoredSession[], imageCaptchaEvents: UserCommitmentRecord[], powCaptchaEvents: PoWCaptchaRecord[]): Promise<void>;
-    getCaptchas(filter: RootFilterQuery<CaptchaProperties>, limit: number): Promise<{
-        userCommitmentRecords: UserCommitmentRecord[];
-        powCaptchaRecords: PoWCaptchaRecord[];
-    }>;
-}
-export interface CaptchaProperties extends Partial<UserCommitment & PoWCaptcha> {
-}
-//# sourceMappingURL=captcha.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"captcha.d.ts","sourceRoot":"","sources":["../../src/types/captcha.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAEN,KAAK,gBAAgB,EAErB,KAAK,eAAe,EACpB,KAAK,aAAa,EAElB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EAEzB,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,aAAa,GAAG,IAAI,CAC/B,aAAa,EACb,KAAK,GAAG,WAAW,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,GAAG,SAAS,CACzE,GAAG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,eAAe,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,MAStC,CAAC;AAEH,eAAO,MAAM,gCAAgC,EAAE,MAE7C,CAAC;AAGH,eAAO,MAAM,4BAA4B,EAAE,MAEzC,CAAC;AAOH,MAAM,WAAW,gBAAiB,SAAQ,SAAS;IAClD,YAAY,CACX,aAAa,EAAE,aAAa,EAAE,EAC9B,kBAAkB,EAAE,oBAAoB,EAAE,EAC1C,gBAAgB,EAAE,gBAAgB,EAAE,GAClC,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,WAAW,CACV,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,EAC1C,KAAK,EAAE,MAAM,GACX,OAAO,CAAC;QACV,qBAAqB,EAAE,oBAAoB,EAAE,CAAC;QAC9C,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;KACtC,CAAC,CAAC;CACH;AAED,MAAM,WAAW,iBAChB,SAAQ,OAAO,CAAC,cAAc,GAAG,UAAU,CAAC;CAAG"}

package/dist/types/captcha.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"captcha.js","sourceRoot":"","sources":["../../src/types/captcha.ts"],"names":[],"mappings":"AAeA,OAAO,EAAwB,MAAM,EAAE,MAAM,UAAU,CAAC;AAExD,OAAO,EACN,6BAA6B,EAE7B,sBAAsB,EAGtB,mBAAmB,EAGnB,0BAA0B,GAC1B,MAAM,eAAe,CAAC;AAWvB,MAAM,CAAC,MAAM,yBAAyB,GAAW,IAAI,MAAM,CAAC;IAC3D,SAAS,EAAE,mBAAmB,CAAC,GAAG,CAAC,SAAS;IAC5C,SAAS,EAAE,mBAAmB,CAAC,GAAG,CAAC,SAAS;IAC5C,WAAW,EAAE,mBAAmB,CAAC,GAAG,CAAC,WAAW;IAChD,OAAO,EAAE,mBAAmB,CAAC,GAAG,CAAC,OAAO;IACxC,OAAO,EAAE,mBAAmB,CAAC,GAAG,CAAC,OAAO;IACxC,KAAK,EAAE,6BAA6B,CAAC,GAAG,CAAC,KAAK;IAC9C,eAAe,EAAE,6BAA6B,CAAC,GAAG,CAAC,eAAe;IAClE,SAAS,EAAE,6BAA6B,CAAC,GAAG,CAAC,SAAS;CACtD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,gCAAgC,GAAW,IAAI,MAAM,CAAC;IAClE,GAAG,0BAA0B,CAAC,GAAG;CACjC,CAAC,CAAC;AACH,gCAAgC,CAAC,KAAK,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,CAAC,CAAC;AAEnE,MAAM,CAAC,MAAM,4BAA4B,GAAW,IAAI,MAAM,CAAC;IAC9D,GAAG,sBAAsB,CAAC,GAAG;CAC7B,CAAC,CAAC;AACH,4BAA4B,CAAC,KAAK,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,CAAC,CAAC;AAG/D,yBAAyB,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;AAClD,yBAAyB,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC"}