@planu/cli 4.14.1 → 5.1.1

package/dist/engine/spec-changelog/index.js

@@ -1,4 +0,0 @@
-// engine/spec-changelog/index.ts — Barrel export for spec-changelog module
-export * from './core.js';
-export * from './diff.js';
-//# sourceMappingURL=index.js.map

package/dist/engine/trial-engine.d.ts

@@ -1,5 +0,0 @@
-export declare function getInstallationId(): string;
-export declare function getTrialStatus(_projectId?: string): null;
-export declare function isTrialActive(_projectId?: string): boolean;
-export declare function requestTrial(_projectId?: string): Promise<void>;
-//# sourceMappingURL=trial-engine.d.ts.map

package/dist/engine/trial-engine.js

@@ -1,14 +0,0 @@
-// engine/trial-engine.ts — Trial stub (trial tools removed in SPEC-533)
-export function getInstallationId() {
-    return 'n/a';
-}
-export function getTrialStatus(_projectId) {
-    return null;
-}
-export function isTrialActive(_projectId) {
-    return false;
-}
-export async function requestTrial(_projectId) {
-    // No-op: trial tools removed
-}
-//# sourceMappingURL=trial-engine.js.map

package/dist/engine/usage-tracker/rate-check.d.ts

@@ -1,7 +0,0 @@
-import type { RateLimitResult } from '../../types/index.js';
-/**
- * Evaluates both daily limit and cooldown in a single call.
- * Returns the first failing check, or an allowed result if both pass.
- */
-export declare function evaluateRateLimit(callCount: number, maxCalls: number, lastCallAt: string | null, now: Date): RateLimitResult;
-//# sourceMappingURL=rate-check.d.ts.map

package/dist/engine/usage-tracker/rate-check.js

@@ -1,18 +0,0 @@
-// engine/usage-tracker/rate-check.ts — Composed rate-limit evaluation (pure, no I/O).
-import { checkDailyLimit, checkCooldown } from './rate-limiter.js';
-/**
- * Evaluates both daily limit and cooldown in a single call.
- * Returns the first failing check, or an allowed result if both pass.
- */
-export function evaluateRateLimit(callCount, maxCalls, lastCallAt, now) {
-    const daily = checkDailyLimit(callCount, maxCalls);
-    if (!daily.allowed) {
-        return daily;
-    }
-    const cooldown = checkCooldown(lastCallAt, now);
-    if (!cooldown.allowed) {
-        return cooldown;
-    }
-    return daily;
-}
-//# sourceMappingURL=rate-check.js.map

package/dist/engine/usage-tracker/rate-limiter.d.ts

@@ -1,14 +0,0 @@
-import type { RateLimitResult } from '../../types/index.js';
-/** Minimum milliseconds required between consecutive tool calls. */
-export declare const COOLDOWN_MS = 2000;
-/**
- * Checks whether the caller has exceeded the daily call limit.
- * Returns an allowed result when maxCalls is -1 (unlimited).
- */
-export declare function checkDailyLimit(callCount: number, maxCalls: number): RateLimitResult;
-/**
- * Checks whether enough time has passed since the last tool call.
- * Passes when lastCallAt is null (no previous call recorded).
- */
-export declare function checkCooldown(lastCallAt: string | null, now: Date): RateLimitResult;
-//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/engine/usage-tracker/rate-limiter.js

@@ -1,73 +0,0 @@
-// engine/usage-tracker/rate-limiter.ts — Rate limiting logic (pure functions, no I/O).
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-/** Minimum milliseconds required between consecutive tool calls. */
-export const COOLDOWN_MS = 2000;
-// ---------------------------------------------------------------------------
-// Daily limit check
-// ---------------------------------------------------------------------------
-/**
- * Checks whether the caller has exceeded the daily call limit.
- * Returns an allowed result when maxCalls is -1 (unlimited).
- */
-export function checkDailyLimit(callCount, maxCalls) {
-    if (maxCalls === -1) {
-        return {
-            allowed: true,
-            reason: null,
-            message: 'Unlimited calls available.',
-            remainingCalls: -1,
-        };
-    }
-    const remaining = maxCalls - callCount;
-    if (remaining <= 0) {
-        return {
-            allowed: false,
-            reason: 'daily_limit',
-            message: `Daily call limit of ${String(maxCalls)} reached. Limit resets at midnight UTC.`,
-            remainingCalls: 0,
-        };
-    }
-    return {
-        allowed: true,
-        reason: null,
-        message: `${String(remaining)} of ${String(maxCalls)} daily calls remaining.`,
-        remainingCalls: remaining,
-    };
-}
-// ---------------------------------------------------------------------------
-// Cooldown check
-// ---------------------------------------------------------------------------
-/**
- * Checks whether enough time has passed since the last tool call.
- * Passes when lastCallAt is null (no previous call recorded).
- */
-export function checkCooldown(lastCallAt, now) {
-    if (lastCallAt === null) {
-        return {
-            allowed: true,
-            reason: null,
-            message: 'No previous call recorded.',
-            remainingCalls: -1,
-        };
-    }
-    const lastCallMs = new Date(lastCallAt).getTime();
-    const elapsedMs = now.getTime() - lastCallMs;
-    if (elapsedMs < COOLDOWN_MS) {
-        const waitMs = COOLDOWN_MS - elapsedMs;
-        return {
-            allowed: false,
-            reason: 'cooldown',
-            message: `Rate limit: please wait ${String(waitMs)}ms before the next call.`,
-            remainingCalls: -1,
-        };
-    }
-    return {
-        allowed: true,
-        reason: null,
-        message: 'Cooldown period elapsed.',
-        remainingCalls: -1,
-    };
-}
-//# sourceMappingURL=rate-limiter.js.map

package/dist/engine/usage-tracker/trial.d.ts

@@ -1,27 +0,0 @@
-/** Number of days in the full trial period. */
-export declare const TRIAL_DAYS = 30;
-/**
- * Returns the number of whole days elapsed since the given ISO 8601 timestamp.
- */
-export declare function calculateDaysSinceFirstRun(firstRunAt: string): number;
-/**
- * Returns true if the installation is still within the 30-day trial period.
- */
-export declare function isTrialActive(firstRunAt: string): boolean;
-/**
- * Returns the number of days remaining in the trial period.
- * Returns 0 if the trial has already expired.
- */
-export declare function trialDaysRemaining(firstRunAt: string): number;
-/**
- * Returns tool/spec/daily-call limits based on the current trial status.
- *
- * - Day 1–30  (trial active):  { tools: 20, specs: 5, dailyCalls: 50 }
- * - Day 31+   (trial expired): { tools: 10, specs: 3, dailyCalls: 30 }
- */
-export declare function getTrialLimits(firstRunAt: string): {
-    tools: number;
-    specs: number;
-    dailyCalls: number;
-};
-//# sourceMappingURL=trial.d.ts.map

package/dist/engine/usage-tracker/trial.js

@@ -1,49 +0,0 @@
-// engine/usage-tracker/trial.ts — Trial period logic (pure functions, no I/O).
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-/** Number of days in the full trial period. */
-export const TRIAL_DAYS = 30;
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-// ---------------------------------------------------------------------------
-// Trial calculations
-// ---------------------------------------------------------------------------
-/**
- * Returns the number of whole days elapsed since the given ISO 8601 timestamp.
- */
-export function calculateDaysSinceFirstRun(firstRunAt) {
-    const firstRunMs = new Date(firstRunAt).getTime();
-    const nowMs = Date.now();
-    const elapsedMs = nowMs - firstRunMs;
-    return Math.floor(elapsedMs / MS_PER_DAY);
-}
-/**
- * Returns true if the installation is still within the 30-day trial period.
- */
-export function isTrialActive(firstRunAt) {
-    return calculateDaysSinceFirstRun(firstRunAt) < TRIAL_DAYS;
-}
-/**
- * Returns the number of days remaining in the trial period.
- * Returns 0 if the trial has already expired.
- */
-export function trialDaysRemaining(firstRunAt) {
-    const elapsed = calculateDaysSinceFirstRun(firstRunAt);
-    return Math.max(0, TRIAL_DAYS - elapsed);
-}
-// ---------------------------------------------------------------------------
-// Limit resolution
-// ---------------------------------------------------------------------------
-/**
- * Returns tool/spec/daily-call limits based on the current trial status.
- *
- * - Day 1–30  (trial active):  { tools: 20, specs: 5, dailyCalls: 50 }
- * - Day 31+   (trial expired): { tools: 10, specs: 3, dailyCalls: 30 }
- */
-export function getTrialLimits(firstRunAt) {
-    if (isTrialActive(firstRunAt)) {
-        return { tools: 20, specs: 5, dailyCalls: 50 };
-    }
-    return { tools: 10, specs: 3, dailyCalls: 30 };
-}
-//# sourceMappingURL=trial.js.map

package/dist/engine/webhook/event-handlers.d.ts

@@ -1,25 +0,0 @@
-import type { LemonSqueezyWebhookPayload, WebhookProcessResult } from '../../types/index.js';
-/**
- * Handles subscription_cancelled: the customer cancelled their subscription.
- * The tier should be reverted to free when the subscription period ends.
- */
-export declare function handleSubscriptionCancelled(payload: LemonSqueezyWebhookPayload): WebhookProcessResult;
-/**
- * Handles subscription_updated: plan tier may have changed (upgrade/downgrade).
- */
-export declare function handleSubscriptionUpdated(payload: LemonSqueezyWebhookPayload): WebhookProcessResult;
-/**
- * Handles license_key_created: a new license key was issued (after purchase).
- * This is informational — the user will activate the key via activate_license tool.
- */
-export declare function handleLicenseKeyCreated(payload: LemonSqueezyWebhookPayload): WebhookProcessResult;
-/**
- * Returns a generic "acknowledged" result for unhandled but recognised events.
- */
-export declare function handleUnknownEvent(eventType: string): WebhookProcessResult;
-/**
- * Dispatches a parsed webhook payload to the appropriate event handler.
- * Unhandled but valid events are acknowledged with a 200 response.
- */
-export declare function dispatchWebhookEvent(payload: LemonSqueezyWebhookPayload): WebhookProcessResult;
-//# sourceMappingURL=event-handlers.d.ts.map

package/dist/engine/webhook/event-handlers.js

@@ -1,89 +0,0 @@
-// engine/webhook/event-handlers.ts — Handles individual Lemon Squeezy webhook events.
-// Each handler receives parsed payload and applies the corresponding business logic.
-// ---------------------------------------------------------------------------
-// Individual event handlers
-// ---------------------------------------------------------------------------
-/**
- * Handles subscription_cancelled: the customer cancelled their subscription.
- * The tier should be reverted to free when the subscription period ends.
- */
-export function handleSubscriptionCancelled(payload) {
-    const attrs = payload.data.attributes;
-    const endsAt = attrs.ends_at ?? 'unknown date';
-    const productName = attrs.product_name ?? 'Planu subscription';
-    return {
-        success: true,
-        eventType: 'subscription_cancelled',
-        statusCode: 200,
-        message: [
-            `Subscription cancellation recorded: ${productName}`,
-            `Access continues until: ${endsAt}`,
-            'Tier will revert to free upon expiry.',
-        ].join(' | '),
-    };
-}
-/**
- * Handles subscription_updated: plan tier may have changed (upgrade/downgrade).
- */
-export function handleSubscriptionUpdated(payload) {
-    const attrs = payload.data.attributes;
-    const variantName = attrs.variant_name ?? 'unknown variant';
-    const status = attrs.status ?? 'unknown';
-    return {
-        success: true,
-        eventType: 'subscription_updated',
-        statusCode: 200,
-        message: [`Subscription updated: variant=${variantName}`, `status=${status}`].join(' | '),
-    };
-}
-/**
- * Handles license_key_created: a new license key was issued (after purchase).
- * This is informational — the user will activate the key via activate_license tool.
- */
-export function handleLicenseKeyCreated(payload) {
-    const attrs = payload.data.attributes;
-    const productName = attrs.product_name ?? 'Planu';
-    const userEmail = attrs.user_email ?? 'unknown';
-    return {
-        success: true,
-        eventType: 'license_key_created',
-        statusCode: 200,
-        message: [
-            `License key created for: ${productName}`,
-            `customer=${userEmail}`,
-            'Key can be activated using activate_license tool.',
-        ].join(' | '),
-    };
-}
-/**
- * Returns a generic "acknowledged" result for unhandled but recognised events.
- */
-export function handleUnknownEvent(eventType) {
-    return {
-        success: true,
-        eventType,
-        statusCode: 200,
-        message: `Event acknowledged (no handler): ${eventType}`,
-    };
-}
-// ---------------------------------------------------------------------------
-// Dispatcher
-// ---------------------------------------------------------------------------
-const HANDLERS = {
-    subscription_cancelled: handleSubscriptionCancelled,
-    subscription_updated: handleSubscriptionUpdated,
-    license_key_created: handleLicenseKeyCreated,
-};
-/**
- * Dispatches a parsed webhook payload to the appropriate event handler.
- * Unhandled but valid events are acknowledged with a 200 response.
- */
-export function dispatchWebhookEvent(payload) {
-    const eventType = payload.meta.event_name;
-    const handler = HANDLERS[eventType];
-    if (handler) {
-        return handler(payload);
-    }
-    return handleUnknownEvent(eventType);
-}
-//# sourceMappingURL=event-handlers.js.map

package/dist/engine/webhook/index.d.ts

@@ -1,4 +0,0 @@
-export { startWebhookServer, stopWebhookServer, getWebhookState, setWebhookSecret, } from './server.js';
-export { validateSignature, extractSignatureHeader } from './signature.js';
-export { dispatchWebhookEvent, handleSubscriptionCancelled, handleSubscriptionUpdated, handleLicenseKeyCreated, handleUnknownEvent, } from './event-handlers.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/engine/webhook/index.js

@@ -1,5 +0,0 @@
-// engine/webhook/index.ts — Barrel re-export for the webhook engine module.
-export { startWebhookServer, stopWebhookServer, getWebhookState, setWebhookSecret, } from './server.js';
-export { validateSignature, extractSignatureHeader } from './signature.js';
-export { dispatchWebhookEvent, handleSubscriptionCancelled, handleSubscriptionUpdated, handleLicenseKeyCreated, handleUnknownEvent, } from './event-handlers.js';
-//# sourceMappingURL=index.js.map

package/dist/engine/webhook/server.d.ts

@@ -1,12 +0,0 @@
-import type { WebhookServerState } from '../../types/index.js';
-/** Returns the current webhook server state (immutable snapshot). */
-export declare function getWebhookState(): WebhookServerState;
-/** Replaces the webhook secret used for HMAC-SHA256 validation. */
-export declare function setWebhookSecret(secret: string): void;
-/** Starts the HTTP webhook server on the given port. Idempotent. */
-export declare function startWebhookServer(port?: number): Promise<WebhookServerState>;
-/** Stops the running webhook server gracefully. Idempotent. */
-export declare function stopWebhookServer(): Promise<WebhookServerState>;
-/** Reset replay protection state (for testing only). */
-export declare function _resetReplayState(): void;
-//# sourceMappingURL=server.d.ts.map

package/dist/engine/webhook/server.js

@@ -1,249 +0,0 @@
-// engine/webhook/server.ts — Lightweight HTTP webhook receiver using node:http.
-// No framework dependencies — only built-in Node.js modules.
-import { createServer } from 'node:http';
-import { randomUUID, createHash } from 'node:crypto';
-import { validateSignature, extractSignatureHeader } from './signature.js';
-import { dispatchWebhookEvent } from './event-handlers.js';
-// Constants
-const DEFAULT_PORT = 2358;
-const MAX_RECENT_EVENTS = 20;
-const MAX_BODY_SIZE = 1024 * 1024; // 1 MB
-const NONCE_CACHE_SIZE = 1000;
-const MAX_TIMESTAMP_AGE_MS = 5 * 60 * 1000; // 5 minutes
-const RATE_LIMIT_WINDOW_MS = 60 * 1000;
-const RATE_LIMIT_MAX = 10;
-// Module state
-let activeServer = null;
-let serverState = makeIdleState();
-let webhookSecret = '';
-const recentNonces = new Set();
-const nonceQueue = [];
-const rateLimitMap = new Map();
-// Public API
-/** Returns the current webhook server state (immutable snapshot). */
-export function getWebhookState() {
-    return serverState;
-}
-/** Replaces the webhook secret used for HMAC-SHA256 validation. */
-export function setWebhookSecret(secret) {
-    webhookSecret = secret;
-}
-/** Starts the HTTP webhook server on the given port. Idempotent. */
-export async function startWebhookServer(port = DEFAULT_PORT) {
-    if (activeServer !== null) {
-        return serverState;
-    }
-    return new Promise((resolve, reject) => {
-        const server = createServer(handleRequest);
-        server.on('error', (err) => {
-            reject(err);
-        });
-        server.listen(port, () => {
-            activeServer = server;
-            serverState = {
-                running: true,
-                port,
-                startedAt: new Date().toISOString(),
-                eventsProcessed: 0,
-                recentEvents: [],
-            };
-            if (!webhookSecret) {
-                console.warn('[Planu] Warning: Webhook server started without a secret. All incoming requests will be accepted without signature verification. Set a secret via configure_webhook.');
-            }
-            resolve(serverState);
-        });
-    });
-}
-/** Stops the running webhook server gracefully. Idempotent. */
-export async function stopWebhookServer() {
-    if (activeServer === null) {
-        serverState = makeIdleState();
-        return serverState;
-    }
-    const server = activeServer;
-    return new Promise((resolve, reject) => {
-        server.close((err) => {
-            /* v8 ignore start */
-            if (err) {
-                reject(err);
-                return;
-            }
-            /* v8 ignore stop */
-            activeServer = null;
-            serverState = makeIdleState();
-            resolve(serverState);
-        });
-    });
-}
-// HTTP request handler
-function handleRequest(req, res) {
-    if (req.method !== 'POST') {
-        res.writeHead(405, { 'Content-Type': 'text/plain' });
-        res.end('Method Not Allowed');
-        return;
-    }
-    collectBody(req)
-        .then((rawBody) => {
-        processWebhookRequest(rawBody, req.headers, res);
-    })
-        .catch(() => {
-        res.writeHead(400, { 'Content-Type': 'text/plain' });
-        res.end('Bad Request');
-    });
-}
-function collectBody(req) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        let totalSize = 0;
-        req.on('data', (chunk) => {
-            totalSize += chunk.length;
-            if (totalSize > MAX_BODY_SIZE) {
-                reject(new Error('Payload too large'));
-                return;
-            }
-            chunks.push(chunk);
-        });
-        req.on('end', () => {
-            resolve(Buffer.concat(chunks));
-        });
-        req.on('error', reject);
-    });
-}
-// Replay & rate-limit protection (SPEC-094 AC-7)
-function isReplayAttack(headers, bodyStr) {
-    const tsHeader = headers['x-webhook-timestamp'] ?? headers['X-Webhook-Timestamp'];
-    const timestamp = typeof tsHeader === 'string' ? tsHeader : undefined;
-    if (timestamp) {
-        const age = Date.now() - new Date(timestamp).getTime();
-        if (age > MAX_TIMESTAMP_AGE_MS || age < -MAX_TIMESTAMP_AGE_MS) {
-            return 'Webhook timestamp too old or in the future';
-        }
-    }
-    const nonce = extractNonce(headers, bodyStr);
-    if (nonce && recentNonces.has(nonce)) {
-        return 'Duplicate webhook (replay detected)';
-    }
-    if (nonce) {
-        trackNonce(nonce);
-    }
-    return null;
-}
-function extractNonce(headers, bodyStr) {
-    const idHeader = headers['x-webhook-id'] ?? headers['X-Webhook-Id'];
-    if (typeof idHeader === 'string') {
-        return idHeader;
-    }
-    return createHash('sha256').update(bodyStr).digest('hex').slice(0, 32);
-}
-function trackNonce(nonce) {
-    recentNonces.add(nonce);
-    nonceQueue.push(nonce);
-    while (nonceQueue.length > NONCE_CACHE_SIZE) {
-        const old = nonceQueue.shift();
-        if (old) {
-            recentNonces.delete(old);
-        }
-    }
-}
-function isRateLimited(source) {
-    const now = Date.now();
-    const entry = rateLimitMap.get(source);
-    if (!entry || now - entry.windowStart > RATE_LIMIT_WINDOW_MS) {
-        rateLimitMap.set(source, { count: 1, windowStart: now });
-        return false;
-    }
-    entry.count++;
-    return entry.count > RATE_LIMIT_MAX;
-}
-/** Reset replay protection state (for testing only). */
-export function _resetReplayState() {
-    recentNonces.clear();
-    nonceQueue.length = 0;
-    rateLimitMap.clear();
-}
-function processWebhookRequest(rawBody, headers, res) {
-    // Rate limiting
-    const source = String(headers['x-forwarded-for'] ?? headers['x-real-ip'] ?? 'unknown');
-    if (isRateLimited(source)) {
-        res.writeHead(429, { 'Content-Type': 'text/plain' });
-        res.end('Too Many Requests');
-        return;
-    }
-    // Replay protection
-    const replayReason = isReplayAttack(headers, rawBody.toString('utf8'));
-    if (replayReason) {
-        recordEvent('replay_rejected', false, replayReason, '');
-        res.writeHead(409, { 'Content-Type': 'text/plain' });
-        res.end(replayReason);
-        return;
-    }
-    // Signature validation (only if a secret is configured)
-    if (webhookSecret) {
-        const sig = extractSignatureHeader(headers);
-        if (!validateSignature(rawBody, sig, webhookSecret)) {
-            recordEvent('signature_invalid', false, 'Signature validation failed', '');
-            res.writeHead(401, { 'Content-Type': 'text/plain' });
-            res.end('Unauthorized');
-            return;
-        }
-    }
-    // Parse JSON body
-    let payload;
-    try {
-        payload = JSON.parse(rawBody.toString('utf8'));
-    }
-    catch {
-        res.writeHead(400, { 'Content-Type': 'text/plain' });
-        res.end('Invalid JSON');
-        return;
-    }
-    if (!payload.meta?.event_name) {
-        res.writeHead(400, { 'Content-Type': 'text/plain' });
-        res.end('Invalid payload: missing meta.event_name');
-        return;
-    }
-    // Dispatch event
-    const eventType = payload.meta.event_name;
-    try {
-        const result = dispatchWebhookEvent(payload);
-        recordEvent(eventType, result.success, result.message, result.eventType);
-        res.writeHead(result.statusCode, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: true, message: result.message }));
-        /* v8 ignore start */
-    }
-    catch (err) {
-        const errMsg = err instanceof Error ? err.message : 'Unknown error';
-        recordEvent(eventType, false, errMsg, eventType);
-        res.writeHead(500, { 'Content-Type': 'text/plain' });
-        res.end('Internal Server Error');
-    }
-    /* v8 ignore stop */
-}
-// Event recording
-function recordEvent(_eventType, processed, summary, resolvedType) {
-    const record = {
-        id: randomUUID(),
-        eventType: resolvedType,
-        receivedAt: new Date().toISOString(),
-        processed,
-        summary,
-        ...(processed ? {} : { error: summary }),
-    };
-    const recentEvents = [record, ...serverState.recentEvents].slice(0, MAX_RECENT_EVENTS);
-    serverState = {
-        ...serverState,
-        eventsProcessed: serverState.eventsProcessed + 1,
-        recentEvents,
-    };
-}
-// Helpers
-function makeIdleState() {
-    return {
-        running: false,
-        port: DEFAULT_PORT,
-        startedAt: null,
-        eventsProcessed: 0,
-        recentEvents: [],
-    };
-}
-//# sourceMappingURL=server.js.map

package/dist/engine/webhook/signature.d.ts

@@ -1,16 +0,0 @@
-/**
- * Validates an HMAC-SHA256 signature from a Lemon Squeezy webhook request.
- * Uses timing-safe comparison to prevent timing attacks.
- *
- * @param rawBody - The raw request body bytes (NOT parsed JSON)
- * @param signatureHeader - The value of the X-Signature header
- * @param secret - The webhook secret configured in Lemon Squeezy dashboard
- * @returns true if signature is valid, false otherwise
- */
-export declare function validateSignature(rawBody: Buffer, signatureHeader: string, secret: string): boolean;
-/**
- * Extracts the signature header value from a map of HTTP headers.
- * Header names are case-insensitive in HTTP/1.1.
- */
-export declare function extractSignatureHeader(headers: Record<string, string | string[] | undefined>): string;
-//# sourceMappingURL=signature.d.ts.map