import "../../validators-BcQFm1oY.js";
import { ai as OrmSchemaPlugin } from "../../where-clause-compiler-CUzMH_BM.js";
import "../../query-context-ji7By8u0.js";
import "../../orm/index.js";
import * as convex_server0 from "convex/server";

//#region src/plugins/ratelimit/duration.d.ts
type DurationUnit = 'ms' | 's' | 'm' | 'h' | 'd';
type DurationString = `${number} ${DurationUnit}` | `${number}${DurationUnit}`;
type Duration = number | DurationString;
declare function toMs(duration: Duration): number;
//#endregion
//#region src/plugins/ratelimit/types.d.ts
type RatelimitReason = 'timeout' | 'cacheBlock' | 'denyList';
type RatelimitResponse = {
  success: boolean;
  ok: boolean;
  limit: number;
  remaining: number;
  reset: number;
  pending: Promise<unknown>;
  reason?: RatelimitReason;
  deniedValue?: string;
};
type RemainingResponse = {
  remaining: number;
  reset: number;
  limit: number;
};
type DynamicLimitResponse = {
  dynamicLimit: number | null;
};
type RateLimitState = {
  value: number;
  ts: number;
  auxValue?: number;
  auxTs?: number;
};
type RateLimitSnapshot = {
  value: number;
  ts: number;
  shard: number;
  config: ResolvedAlgorithm;
};
type BaseAlgorithmOptions = {
  shards?: number;
  maxReserved?: number;
};
type FixedWindowAlgorithm = {
  kind: 'fixedWindow';
  limit: number;
  window: number;
  capacity: number;
  start?: number;
  maxReserved?: number;
  shards: number;
};
type SlidingWindowAlgorithm = {
  kind: 'slidingWindow';
  limit: number;
  window: number;
  maxReserved?: number;
  shards: number;
};
type TokenBucketAlgorithm = {
  kind: 'tokenBucket';
  refillRate: number;
  interval: number;
  maxTokens: number;
  maxReserved?: number;
  shards: number;
};
type ResolvedAlgorithm = FixedWindowAlgorithm | SlidingWindowAlgorithm | TokenBucketAlgorithm;
type AlgorithmOptions = BaseAlgorithmOptions & {
  capacity?: number;
  start?: number;
};
type LimitRequest = {
  rate?: number;
  count?: number;
  reserve?: boolean;
  ip?: string;
  userAgent?: string;
  country?: string;
  geo?: unknown;
};
type CheckRequest = Omit<LimitRequest, 'reserve'> & {
  reserve?: boolean;
};
type FailureMode = 'closed' | 'open';
type ProtectionLists = {
  identifiers?: readonly string[];
  ips?: readonly string[];
  userAgents?: readonly string[];
  countries?: readonly string[];
};
type RatelimitConfig = {
  db?: ConvexRateLimitDbReader | ConvexRateLimitDbWriter;
  limiter: ResolvedAlgorithm;
  prefix?: string;
  dynamicLimits?: boolean;
  ephemeralCache?: Map<string, number> | false;
  timeout?: number;
  failureMode?: FailureMode;
  enableProtection?: boolean;
  denyListThreshold?: number;
  denyList?: ProtectionLists;
};
type RateLimitRow = {
  _id: string;
  _creationTime?: number;
  name: string;
  key?: string;
  shard: number;
  value: number;
  ts: number;
  auxValue?: number;
  auxTs?: number;
};
type ConvexQueryBuilder = {
  withIndex: (name: any, cb: any) => {
    unique: () => Promise<any>;
    collect: () => Promise<any[]>;
  };
};
type ConvexRateLimitDbReader = {
  query: (tableName: string) => ConvexQueryBuilder;
};
type ConvexRateLimitDbWriter = ConvexRateLimitDbReader & {
  insert: (...args: any[]) => Promise<any>;
  patch: (...args: any[]) => Promise<void>;
  delete: (...args: any[]) => Promise<void>;
};
type HookAPIOptions = {
  identifier?: string | ((ctx: unknown, fromClient?: string) => string | Promise<string>);
  sampleShards?: number;
};
type HookCheckValue = {
  value: number;
  ts: number;
  config: ResolvedAlgorithm;
  shard: number;
  ok: boolean;
  retryAt?: number;
};
//#endregion
//#region src/plugins/ratelimit/core/algorithms.d.ts
declare function fixedWindow(limit: number, window: Duration, options?: AlgorithmOptions): FixedWindowAlgorithm;
declare function slidingWindow(limit: number, window: Duration, options?: AlgorithmOptions): SlidingWindowAlgorithm;
declare function tokenBucket(refillRate: number, interval: Duration, maxTokens: number, options?: AlgorithmOptions): TokenBucketAlgorithm;
declare function applyDynamicLimit(algorithm: ResolvedAlgorithm, dynamicLimit: number | null): ResolvedAlgorithm;
//#endregion
//#region src/plugins/ratelimit/core/calculate-rate-limit.d.ts
type EvaluationResult = {
  state: RateLimitState;
  retryAfter?: number;
  remaining: number;
  reset: number;
  limit: number;
};
declare function calculateRateLimit(state: RateLimitState | null, algorithm: ResolvedAlgorithm, now: number, count: number): EvaluationResult;
//#endregion
//#region src/plugins/ratelimit/ratelimit.d.ts
declare class Ratelimit {
  private readonly config;
  static fixedWindow: typeof fixedWindow;
  static slidingWindow: typeof slidingWindow;
  static tokenBucket: typeof tokenBucket;
  private readonly store;
  private readonly prefix;
  private readonly timeout;
  private readonly dynamicLimits;
  private readonly failureMode;
  private readonly enableProtection;
  private readonly denyListThreshold;
  private readonly denyList?;
  private readonly limiter;
  private readonly blockCache?;
  private readonly blockCacheSource?;
  private readonly checkCache;
  constructor(config: RatelimitConfig);
  limit(identifier: string, request?: LimitRequest): Promise<RatelimitResponse>;
  check(identifier: string, request?: CheckRequest): Promise<RatelimitResponse>;
  blockUntilReady(identifier: string, timeoutMs: number): Promise<RatelimitResponse>;
  resetUsedTokens(identifier: string): Promise<void>;
  getRemaining(identifier: string): Promise<RemainingResponse>;
  getValue(identifier: string, options?: {
    sampleShards?: number;
  }): Promise<RateLimitSnapshot>;
  setDynamicLimit(options: {
    limit: number | false;
  }): Promise<void>;
  getDynamicLimit(): Promise<DynamicLimitResponse>;
  hookAPI(options?: HookAPIOptions): {
    getRateLimit: convex_server0.RegisteredQuery<"public", {
      identifier?: string | undefined;
      sampleShards?: number | undefined;
    }, Promise<RateLimitSnapshot>>;
    getServerTime: convex_server0.RegisteredMutation<"public", {}, Promise<number>>;
  };
  private withDb;
  private evaluate;
  private evaluateCandidates;
  private resolveAlgorithm;
  private rawLimit;
  private runWithTimeout;
  private timeoutResponse;
}
//#endregion
//#region src/plugins/ratelimit/schema.d.ts
declare function ratelimitPlugin(): OrmSchemaPlugin;
//#endregion
//#region src/plugins/ratelimit/store/convex-store.d.ts
declare const RATE_LIMIT_STATE_TABLE = "ratelimit_state";
declare const RATE_LIMIT_DYNAMIC_TABLE = "ratelimit_dynamic_limit";
declare const RATE_LIMIT_HIT_TABLE = "ratelimit_protection_hit";
//#endregion
//#region src/plugins/ratelimit/index.d.ts
declare const SECOND = 1000;
declare const MINUTE: number;
declare const HOUR: number;
declare const DAY: number;
declare const WEEK: number;
//#endregion
export { type CheckRequest, type ConvexQueryBuilder, type ConvexRateLimitDbReader, type ConvexRateLimitDbWriter, DAY, type Duration, type DurationString, type DurationUnit, type DynamicLimitResponse, type FixedWindowAlgorithm, HOUR, type HookAPIOptions, type HookCheckValue, type LimitRequest, MINUTE, RATE_LIMIT_DYNAMIC_TABLE, RATE_LIMIT_HIT_TABLE, RATE_LIMIT_STATE_TABLE, type RateLimitRow, type RateLimitSnapshot, type RateLimitState, Ratelimit, type RatelimitConfig, type RatelimitReason, type RatelimitResponse, type RemainingResponse, type ResolvedAlgorithm, SECOND, type SlidingWindowAlgorithm, type TokenBucketAlgorithm, WEEK, applyDynamicLimit, calculateRateLimit, fixedWindow, ratelimitPlugin, slidingWindow, toMs, tokenBucket };