@vibesdotdev/kit 0.0.0-stage → 1.0.0-rc.4

package/dist/lib/server/helpers/cache.js

@@ -0,0 +1,319 @@
+/**
+ * Caching helper functions
+ */
+import { asVibesKitLocals } from '../locals.js';
+import { defaultCacheKey } from '../middleware/cache-manager.js';
+import { sha256Hex } from './digest.js';
+/**
+ * Caching helper functions for common patterns
+ */
+export const cache = {
+    /**
+     * No caching - disables caching entirely
+     */
+    none() {
+        return {
+            enabled: false,
+            ttl: 0
+        };
+    },
+    /**
+     * Short-term caching: 1 minute
+     */
+    short() {
+        return {
+            enabled: true,
+            ttl: 60
+        };
+    },
+    /**
+     * Medium-term caching: 5 minutes
+     */
+    medium() {
+        return {
+            enabled: true,
+            ttl: 300
+        };
+    },
+    /**
+     * Long-term caching: 1 hour
+     */
+    long() {
+        return {
+            enabled: true,
+            ttl: 3600
+        };
+    },
+    /**
+     * Custom TTL caching
+     */
+    custom(ttl) {
+        return {
+            enabled: true,
+            ttl
+        };
+    },
+    /**
+     * User-based caching (includes user ID in cache key)
+     */
+    userBased() {
+        return {
+            enabled: true,
+            ttl: 300,
+            userBased: true,
+            key: (event) => {
+                const userId = asVibesKitLocals(event.locals).user?.id;
+                const path = event.url.pathname;
+                const search = event.url.search;
+                return `user:${userId}:${path}${search}`;
+            }
+        };
+    },
+    /**
+     * Project-based caching (includes project ID in cache key)
+     */
+    projectBased() {
+        return {
+            enabled: true,
+            ttl: 300,
+            projectBased: true,
+            key: (event) => {
+                const params = event.params;
+                const projectId = asVibesKitLocals(event.locals).activeProjectId ||
+                    params.projectId ||
+                    (event.url.pathname.includes('/projects/') ? params.id : undefined);
+                const path = event.url.pathname;
+                const search = event.url.search;
+                return `project:${projectId}:${path}${search}`;
+            }
+        };
+    }
+};
+/**
+ * Specialized caching patterns
+ */
+export const cachePatterns = {
+    /**
+     * User profile data - medium-term with user-specific key
+     */
+    userProfile: () => ({
+        enabled: true,
+        ttl: 900, // 15 minutes
+        key: (event) => {
+            const params = event.params;
+            const userId = params.userId || asVibesKitLocals(event.locals).user?.id;
+            return `profile:${userId}`;
+        }
+    }),
+    /**
+     * Project data - longer caching since projects change less frequently
+     */
+    projectData: () => ({
+        enabled: true,
+        ttl: 1800, // 30 minutes
+        key: (event) => {
+            const params = event.params;
+            const projectId = params.projectId ||
+                asVibesKitLocals(event.locals).activeProjectId ||
+                (event.url.pathname.includes('/projects/') ? params.id : undefined);
+            return `project:data:${projectId}`;
+        }
+    }),
+    /**
+     * Chat room data - moderate caching
+     */
+    chatRoomData: () => ({
+        enabled: true,
+        ttl: 600, // 10 minutes
+        key: (event) => {
+            const params = event.params;
+            const roomId = params.roomId;
+            return `chat:room:${roomId}`;
+        }
+    }),
+    /**
+     * Chat messages - short caching with pagination
+     */
+    chatMessages: () => ({
+        enabled: true,
+        ttl: 60, // 1 minute
+        key: (event) => {
+            const params = event.params;
+            const roomId = params.roomId;
+            const cursor = event.url.searchParams.get('cursor') || 'latest';
+            const limit = event.url.searchParams.get('limit') || '50';
+            return `chat:messages:${roomId}:${cursor}:${limit}`;
+        }
+    }),
+    /**
+     * AI models list - long caching since models rarely change
+     */
+    aiModels: () => ({
+        enabled: true,
+        ttl: 86400, // 24 hours
+        key: () => 'ai:models:list'
+    }),
+    /**
+     * AI providers - long caching
+     */
+    aiProviders: () => ({
+        enabled: true,
+        ttl: 3600, // 1 hour
+        key: () => 'ai:providers:list'
+    }),
+    /**
+     * Search results - short caching with query fingerprint
+     */
+    searchResults: () => ({
+        enabled: true,
+        ttl: 300, // 5 minutes
+        key: (event) => {
+            const query = event.url.searchParams.get('q') || '';
+            const filters = event.url.searchParams.get('filters') || '';
+            const page = event.url.searchParams.get('page') || '1';
+            // A digest of every field (as an unambiguous list): any Unicode query is
+            // keyable and two different searches cannot share a truncated prefix.
+            return `search:${sha256Hex(JSON.stringify([query, filters, page]))}`;
+        }
+    }),
+    /**
+     * Knowledge domains - moderate caching
+     */
+    knowledgeDomains: () => ({
+        enabled: true,
+        ttl: 1800, // 30 minutes
+        key: (event) => {
+            const page = event.url.searchParams.get('page') || '1';
+            const limit = event.url.searchParams.get('limit') || '20';
+            return `knowledge:domains:${page}:${limit}`;
+        }
+    }),
+    /**
+     * Knowledge items - moderate caching with domain-specific key
+     */
+    knowledgeItems: () => ({
+        enabled: true,
+        ttl: 900, // 15 minutes
+        key: (event) => {
+            const params = event.params;
+            const domainId = params.domainId;
+            const page = event.url.searchParams.get('page') || '1';
+            const limit = event.url.searchParams.get('limit') || '20';
+            return `knowledge:items:${domainId}:${page}:${limit}`;
+        }
+    }),
+    /**
+     * User permissions - short caching for security
+     */
+    userPermissions: () => ({
+        enabled: true,
+        ttl: 300, // 5 minutes
+        key: (event) => {
+            const locals = asVibesKitLocals(event.locals);
+            const params = event.params;
+            const projectId = locals.activeProjectId || params.projectId;
+            return `permissions:${locals.user?.id}:${projectId || 'global'}`;
+        }
+    }),
+    /**
+     * Billing data - short caching since usage changes frequently
+     */
+    billingData: () => ({
+        enabled: true,
+        ttl: 120, // 2 minutes
+        key: (event) => {
+            return `billing:${asVibesKitLocals(event.locals).user?.id}`;
+        }
+    }),
+    /**
+     * Public API endpoints - longer caching
+     */
+    publicApi: () => ({
+        enabled: true,
+        ttl: 1800, // 30 minutes
+        key: (event) => {
+            const path = event.url.pathname;
+            const search = event.url.search;
+            return `public:${path}${search}`;
+        }
+    }),
+    /**
+     * Statistics and analytics - longer caching
+     */
+    statistics: () => ({
+        enabled: true,
+        ttl: 3600, // 1 hour
+        key: (event) => {
+            const type = event.url.searchParams.get('type') || 'general';
+            const period = event.url.searchParams.get('period') || 'day';
+            return `stats:${type}:${period}`;
+        }
+    })
+};
+/**
+ * Create a cache configuration with dynamic key generation
+ */
+export function createCache(ttl, keyGenerator, options = {}) {
+    return {
+        enabled: true,
+        ttl,
+        key: keyGenerator,
+        ...options
+    };
+}
+/**
+ * Cache configuration that varies by headers
+ */
+export function cacheWithVary(ttl, varyHeaders, keyGenerator) {
+    return {
+        enabled: true,
+        ttl,
+        vary: varyHeaders,
+        key: keyGenerator ||
+            ((event) => {
+                const path = event.url.pathname;
+                const search = event.url.search;
+                // Include vary headers in cache key. Only a digest of each value joins
+                // it: the value may be a credential (Authorization, Cookie), and a key
+                // is stored and logged.
+                const varyValues = varyHeaders
+                    .map((header) => {
+                    const value = event.request.headers.get(header);
+                    return value ? sha256Hex(value).slice(0, 32) : '';
+                })
+                    .join(':');
+                return `${path}${search}:${varyValues}`;
+            })
+    };
+}
+/**
+ * Conditional caching based on request properties
+ */
+export function cacheIf(condition, config) {
+    return {
+        ...config,
+        // The condition is honoured whether or not the config has its own key: with
+        // none, a request that passes the condition gets the manager's default key.
+        key: (event) => {
+            if (!condition(event)) {
+                // Return unique key that will never match existing cache
+                return `nocache:${Date.now()}:${Math.random()}`;
+            }
+            return config.key ? config.key(event) : defaultCacheKey(event, config);
+        }
+    };
+}
+/**
+ * Cache TTL based on request type or user status
+ */
+export function dynamicTTL(baseTtl, modifier) {
+    return (event) => ({
+        enabled: true,
+        ttl: baseTtl * modifier(event),
+        key: (e) => {
+            const path = e.url.pathname;
+            const search = e.url.search;
+            return `dynamic:${path}${search}`;
+        }
+    });
+}

package/dist/lib/server/helpers/digest.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Synchronous SHA-256 for cache keys.
+ *
+ * Cache keys are built by synchronous key functions (`CachingConfig.key`), so
+ * Web Crypto's asynchronous digest cannot be used there. A key must never hold
+ * a credential header value or a truncated query: it holds this digest of it.
+ * Not for passwords or secrets storage.
+ */
+/** The SHA-256 digest of `text` (UTF-8), as 64 lowercase hex characters. */
+export declare function sha256Hex(text: string): string;

package/dist/lib/server/helpers/digest.js

@@ -0,0 +1,75 @@
+/**
+ * Synchronous SHA-256 for cache keys.
+ *
+ * Cache keys are built by synchronous key functions (`CachingConfig.key`), so
+ * Web Crypto's asynchronous digest cannot be used there. A key must never hold
+ * a credential header value or a truncated query: it holds this digest of it.
+ * Not for passwords or secrets storage.
+ */
+const ROUND_CONSTANTS = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+function rotateRight(value, bits) {
+    return (value >>> bits) | (value << (32 - bits));
+}
+/** The SHA-256 digest of `text` (UTF-8), as 64 lowercase hex characters. */
+export function sha256Hex(text) {
+    const message = new TextEncoder().encode(text);
+    const paddedLength = Math.ceil((message.length + 9) / 64) * 64;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(message);
+    padded[message.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(paddedLength - 8, Math.floor((message.length * 8) / 0x100000000));
+    view.setUint32(paddedLength - 4, (message.length * 8) >>> 0);
+    const state = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+    ]);
+    const schedule = new Uint32Array(64);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        for (let i = 0; i < 16; i++)
+            schedule[i] = view.getUint32(offset + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotateRight(schedule[i - 15], 7) ^
+                rotateRight(schedule[i - 15], 18) ^
+                (schedule[i - 15] >>> 3);
+            const s1 = rotateRight(schedule[i - 2], 17) ^
+                rotateRight(schedule[i - 2], 19) ^
+                (schedule[i - 2] >>> 10);
+            schedule[i] = (schedule[i - 16] + s0 + schedule[i - 7] + s1) | 0;
+        }
+        let [a, b, c, d, e, f, g, h] = state;
+        for (let i = 0; i < 64; i++) {
+            const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+            const choose = (e & f) ^ (~e & g);
+            const temp1 = (h + sum1 + choose + ROUND_CONSTANTS[i] + schedule[i]) | 0;
+            const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+            const majority = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = (sum0 + majority) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temp1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) | 0;
+        }
+        state[0] += a;
+        state[1] += b;
+        state[2] += c;
+        state[3] += d;
+        state[4] += e;
+        state[5] += f;
+        state[6] += g;
+        state[7] += h;
+    }
+    return Array.from(state, (word) => word.toString(16).padStart(8, '0')).join('');
+}

package/dist/lib/server/helpers/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * VibesKit helper functions export
+ *
+ * Centralized exports for all helper functions to provide
+ * clean, readable API configurations.
+ *
+ * @example
+ * ```typescript
+ * import { vibesGET, quick } from '../../index.ts';
+ *
+ * export const GET = vibesGET(
+ *   { ...quick.auth() },
+ *   async (event, context) => {
+ *     return { user: context.user };
+ *   }
+ * );
+ * ```
+ */
+export { auth, permissions, roles } from './auth.js';
+export { rateLimit, rateLimitPatterns, createRateLimit, combineRateLimits } from './rate-limit.js';
+export { cache, cachePatterns, createCache, cacheWithVary, cacheIf, dynamicTTL } from './cache.js';
+export { normalizePlanSlug, normalizePlanComparisonValue, normalizeTierSlug, canonicalTierPriority, planPriorityOrder, comparePlanPriority, isPlanAtLeast, isPlanOneOf, billing, billingPatterns, requireFeatures, customBilling, freeTier, premiumOnly, dynamicCredits, rateBased, tieredBilling, experimental, beta, BillingConfigError, type DynamicBillingConfig } from './billing.js';
+export { isDemoMode, checkDemoMode, createDemoSessionCookie, clearDemoSessionCookie } from './is-demo-mode.js';
+export { params, query, body, headers, validation, response } from './validation.js';
+export { requireServiceOrigin, type RequireServiceOriginOptions } from './service-origin.js';

package/dist/lib/server/helpers/index.js

@@ -0,0 +1,32 @@
+/**
+ * VibesKit helper functions export
+ *
+ * Centralized exports for all helper functions to provide
+ * clean, readable API configurations.
+ *
+ * @example
+ * ```typescript
+ * import { vibesGET, quick } from '../../index.ts';
+ *
+ * export const GET = vibesGET(
+ *   { ...quick.auth() },
+ *   async (event, context) => {
+ *     return { user: context.user };
+ *   }
+ * );
+ * ```
+ */
+// Authentication and authorization helpers
+export { auth, permissions, roles } from './auth.js';
+// Rate limiting helpers
+export { rateLimit, rateLimitPatterns, createRateLimit, combineRateLimits } from './rate-limit.js';
+// Caching helpers
+export { cache, cachePatterns, createCache, cacheWithVary, cacheIf, dynamicTTL } from './cache.js';
+// Billing and subscription helpers
+export { normalizePlanSlug, normalizePlanComparisonValue, normalizeTierSlug, canonicalTierPriority, planPriorityOrder, comparePlanPriority, isPlanAtLeast, isPlanOneOf, billing, billingPatterns, requireFeatures, customBilling, freeTier, premiumOnly, dynamicCredits, rateBased, tieredBilling, experimental, beta, BillingConfigError } from './billing.js';
+// Demo mode helpers
+export { isDemoMode, checkDemoMode, createDemoSessionCookie, clearDemoSessionCookie } from './is-demo-mode.js';
+// Validation helpers
+export { params, query, body, headers, validation, response } from './validation.js';
+// Service-origin resolution (catalog default, host overlay when passed)
+export { requireServiceOrigin } from './service-origin.js';

package/dist/lib/server/helpers/is-demo-mode.d.ts

@@ -0,0 +1,51 @@
+/**
+ * isDemoMode / checkDemoMode — detect whether a request is in demo/sandbox mode
+ *
+ * Signals checked (any one triggers demo mode):
+ * 1. Query param: `?demo=1` on any URL
+ * 2. Header: `x-vibes-demo: true`
+ * 3. Cookie: `vibes-demo=1` (set by DemoBannerHandle, persists across surfaces)
+ * 4. Declared value: `PUBLIC_VIBES_DEMO_MODE=1` read via `runtime.getEnv` (always-on
+ *    for staging/sandbox subdomain)
+ *
+ * IMPORTANT: If a real authenticated user is present, demo mode is ALWAYS
+ * false. Signing in kills demo mode. The demo cookie is cleared on next
+ * response when a real session is detected.
+ *
+ * Demo mode is read-only: no write operations should be enabled.
+ */
+import { type VibesKitRuntimePort } from '../locals.js';
+/**
+ * Low-level check: query param, header, or env only.
+ * Used by page-server code that doesn't have cookie access.
+ */
+export declare function isDemoMode(runtime: VibesKitRuntimePort, request?: Request | {
+    url?: {
+        searchParams?: URLSearchParams;
+        headers?: Headers;
+    };
+    headers?: Headers;
+}): boolean;
+/**
+ * Full demo-mode check for SvelteKit handle/context.
+ * Checks query param, header, cookie, AND env.
+ *
+ * @returns `true` if demo mode is active AND no real user is signed in.
+ */
+export declare function checkDemoMode(event: {
+    request: Request;
+    url: URL;
+    cookies?: {
+        get(name: string): string | undefined;
+    };
+    locals?: {
+        user?: unknown;
+        runtime?: VibesKitRuntimePort;
+    };
+}): boolean;
+/** Cookie name used for cross-surface demo persistence. */
+export declare const DEMO_COOKIE_NAME = "vibes-demo";
+/** Set-Cookie header value to persist demo mode (1 hour). */
+export declare function createDemoSessionCookie(): string;
+/** Set-Cookie header value to clear demo mode immediately. */
+export declare function clearDemoSessionCookie(): string;

package/dist/lib/server/helpers/is-demo-mode.js

@@ -0,0 +1,78 @@
+/**
+ * isDemoMode / checkDemoMode — detect whether a request is in demo/sandbox mode
+ *
+ * Signals checked (any one triggers demo mode):
+ * 1. Query param: `?demo=1` on any URL
+ * 2. Header: `x-vibes-demo: true`
+ * 3. Cookie: `vibes-demo=1` (set by DemoBannerHandle, persists across surfaces)
+ * 4. Declared value: `PUBLIC_VIBES_DEMO_MODE=1` read via `runtime.getEnv` (always-on
+ *    for staging/sandbox subdomain)
+ *
+ * IMPORTANT: If a real authenticated user is present, demo mode is ALWAYS
+ * false. Signing in kills demo mode. The demo cookie is cleared on next
+ * response when a real session is detected.
+ *
+ * Demo mode is read-only: no write operations should be enabled.
+ */
+import { requireKitRuntime } from '../locals.js';
+const DEMO_QUERY_PARAM = 'demo';
+const DEMO_HEADER = 'x-vibes-demo';
+const DEMO_COOKIE = 'vibes-demo';
+const DEMO_ENV_VAR = 'PUBLIC_VIBES_DEMO_MODE';
+/** Declared host value, read from the request's runtime port on every call (no memo). */
+function isAlwaysOnEnv(runtime) {
+    const raw = runtime.getEnv(DEMO_ENV_VAR);
+    return raw === '1' || raw === 'true';
+}
+function checkRequest(request) {
+    // An unparsable URL carries no demo query param; the header check still applies.
+    if (URL.canParse(request.url) &&
+        new URL(request.url).searchParams.get(DEMO_QUERY_PARAM) === '1') {
+        return true;
+    }
+    if (request.headers.get(DEMO_HEADER) === 'true')
+        return true;
+    return false;
+}
+/**
+ * Low-level check: query param, header, or env only.
+ * Used by page-server code that doesn't have cookie access.
+ */
+export function isDemoMode(runtime, request) {
+    if (!request)
+        return isAlwaysOnEnv(runtime);
+    if (request instanceof Request)
+        return checkRequest(request);
+    if (request.url?.searchParams?.get(DEMO_QUERY_PARAM) === '1')
+        return true;
+    if (request.headers?.get(DEMO_HEADER) === 'true')
+        return true;
+    return isAlwaysOnEnv(runtime);
+}
+/**
+ * Full demo-mode check for SvelteKit handle/context.
+ * Checks query param, header, cookie, AND env.
+ *
+ * @returns `true` if demo mode is active AND no real user is signed in.
+ */
+export function checkDemoMode(event) {
+    if (event.locals?.user)
+        return false;
+    if (checkRequest(event.request))
+        return true;
+    if (event.url.searchParams.get(DEMO_QUERY_PARAM) === '1')
+        return true;
+    if (event.cookies?.get(DEMO_COOKIE) === '1')
+        return true;
+    return isAlwaysOnEnv(requireKitRuntime(event.locals ?? {}));
+}
+/** Cookie name used for cross-surface demo persistence. */
+export const DEMO_COOKIE_NAME = DEMO_COOKIE;
+/** Set-Cookie header value to persist demo mode (1 hour). */
+export function createDemoSessionCookie() {
+    return `${DEMO_COOKIE}=1; Path=/; SameSite=Lax; Max-Age=3600`;
+}
+/** Set-Cookie header value to clear demo mode immediately. */
+export function clearDemoSessionCookie() {
+    return `${DEMO_COOKIE}=; Path=/; SameSite=Lax; Max-Age=0`;
+}

package/dist/lib/server/helpers/rate-limit.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Rate limiting helpers
+ */
+import type { RateLimitHelper, RateLimitConfig } from '../../types';
+import type { RequestEvent } from '@sveltejs/kit';
+/**
+ * Helper functions for rate limiting configuration
+ */
+export declare const rateLimit: RateLimitHelper;
+/**
+ * Specialized rate limiting patterns
+ */
+export declare const rateLimitPatterns: {
+    /**
+     * Authentication endpoints - strict limiting to prevent brute force
+     */
+    auth: () => RateLimitConfig;
+    /**
+     * Password reset - very strict to prevent abuse
+     */
+    passwordReset: () => RateLimitConfig;
+    /**
+     * Email sending - prevent spam
+     */
+    emailSending: () => RateLimitConfig;
+    /**
+     * AI generation - expensive operations
+     */
+    aiGeneration: () => RateLimitConfig;
+    /**
+     * Chat messages - conversational rate limiting
+     */
+    chatMessages: () => RateLimitConfig;
+    /**
+     * Search operations - prevent abuse
+     */
+    search: () => RateLimitConfig;
+    /**
+     * File uploads - resource intensive
+     */
+    fileUpload: () => RateLimitConfig;
+    /**
+     * API key operations - security sensitive
+     */
+    apiKeys: () => RateLimitConfig;
+    /**
+     * Public endpoints - lighter limiting
+     */
+    public: () => RateLimitConfig;
+    /**
+     * Admin operations - moderate limiting
+     */
+    admin: () => RateLimitConfig;
+};
+/**
+ * Create a rate limit configuration with dynamic key generation
+ */
+export declare function createRateLimit(rpm: number, rph: number, keyGenerator: (event: RequestEvent) => string): RateLimitConfig;
+/**
+ * Combine multiple rate limiters (most restrictive wins)
+ */
+export declare function combineRateLimits(...configs: RateLimitConfig[]): RateLimitConfig;