/**
 * StorageServer.ts
 *
 * A server-side class that "has a" local WalletStorage (like a StorageKnex instance),
 * and exposes it via a JSON-RPC POST endpoint using Express.
 */
import { MakeWalletLogger, TelemetryConfig } from '@bsv/sdk';
import { Request } from 'express';
import { AuthMiddlewareOptions } from '@bsv/auth-express-middleware';
import type { PaymentReplayStore } from '@bsv/payment-express-middleware';
import { Options as RateLimitOptions } from 'express-rate-limit';
import { Wallet } from '../../Wallet';
import { StorageProvider } from '../StorageProvider';
import { EntityTimeStamp } from '../../sdk/types';
import { TrustProxySetting } from './RateLimitPolicy';
import { type HttpServerPolicyDefaults, type SecurityHeadersOptions } from './edgePolicy';
export interface WalletStorageServerOptions {
    /** Listener bind host. Omit to retain Node's historical all-interface behavior. */
    host?: string;
    port: number;
    wallet: Wallet;
    monetize: boolean;
    calculateRequestPrice?: (req: Request) => number | Promise<number>;
    adminIdentityKeys?: string[];
    makeLogger?: MakeWalletLogger;
    /**
     * Shared BRC-103 session storage for multi-process or multi-replica servers.
     * Defaults to the auth middleware's in-process SessionManager.
     */
    sessionManager?: AuthMiddlewareOptions['sessionManager'];
    /**
     * Authenticated request rate limiting. Defaults to 1,000 requests per
     * identity key per minute. Override the store for shared enforcement across
     * multiple server processes or replicas.
     */
    rateLimit?: Partial<RateLimitOptions>;
    /**
     * Pre-authentication IP rate limiting. Defaults to 300 requests per minute.
     * Use a shared store when multiple server processes or replicas must enforce
     * one aggregate limit.
     */
    preAuthRateLimit?: Partial<RateLimitOptions>;
    /**
     * Explicit Express proxy trust policy. Omit for the secure direct-socket
     * default. Prefer a known hop count, subnet, or predicate; permissive
     * `true` is intentionally unsupported.
     */
    trustProxy?: TrustProxySetting;
    /** Exact browser origins allowed to call this server. Omit for public CORS. */
    allowedOrigins?: string[];
    /** Per-process in-flight request ceiling. Defaults to the selected resource profile (24 in standard). */
    maxConcurrentRequests?: number;
    /** Node HTTP timeout/connection policy overrides. */
    http?: Partial<HttpServerPolicyDefaults>;
    /** Security response-header and CSP overrides. */
    securityHeaders?: SecurityHeadersOptions;
    /** Emit one JSON log record for each authenticated RPC. Default: true. */
    logRpcRequests?: boolean;
    /** @deprecated Use structured RPC logging. Retained for compatibility. */
    logShortReqs?: boolean;
    /**
     * Optional provider-neutral timing for ingress, authentication, RPC
     * authorization, storage dispatch, and response formulation.
     */
    telemetry?: TelemetryConfig;
    /** Default item limit inserted for list/find RPC calls that omit one. Default: 1,000. */
    defaultRpcListLimit?: number;
    /** Largest caller-selected list/find item limit. Use -1 to disable this operator ceiling. */
    maxRpcListLimit?: number;
    /** Largest list/find/sync offset accepted at the RPC edge. Use -1 only for trusted tenants. */
    maxRpcListOffset?: number;
    /** Maximum elements in any decoded request array. Use -1 only for trusted callers. */
    maxRpcArrayItems?: number;
    /** Maximum serialized JSON-RPC response bytes. Use -1 to disable. */
    maxRpcResponseBytes?: number;
    /** Disable the additive durable transfer transport during a mixed-version rollout. Knex only. */
    syncTransfers?: boolean;
    /** Durable BRC-105 replay claims for monetized multi-replica deployments. */
    paymentReplayStore?: PaymentReplayStore;
}
export declare class StorageServer {
    private readonly syncTransfers?;
    private readonly app;
    private readonly host?;
    private readonly port;
    private readonly storage;
    private readonly wallet;
    private readonly monetize;
    private readonly calculateRequestPrice?;
    private readonly adminIdentityKeys?;
    private readonly makeLogger?;
    private readonly sessionManager?;
    private readonly rateLimitOptions?;
    private readonly preAuthRateLimitOptions?;
    private readonly trustProxy?;
    private readonly allowedOrigins?;
    private readonly maxConcurrentRequests;
    private readonly httpPolicy;
    private readonly securityHeadersPolicy;
    private readonly logRpcRequests;
    private readonly telemetry;
    private readonly telemetryConfig?;
    private readonly defaultRpcListLimit;
    private readonly maxRpcListLimit;
    private readonly maxRpcListOffset;
    private readonly maxRpcArrayItems;
    private readonly maxRpcResponseBytes;
    private readonly paymentReplayStore?;
    constructor(storage: StorageProvider, options: WalletStorageServerOptions);
    private setupShortReqLogging;
    private setupRoutes;
    private handleRpcRequest;
    private handleRpcRequestCore;
    private sendOversizedSyncResponse;
    private traceHttpRequest;
    private sendRpc;
    private enforceRpcRequestBudgets;
    private enforceRpcArrayBudget;
    private objectArgument;
    private normalizedRpcLimit;
    private normalizedRpcOffset;
    private sendRpcError;
    private createRpcLog;
    private dispatchRpcCall;
    private dispatchSyncTransfer;
    private traceRpcStep;
    private authorizeRpcCall;
    private logIgnoredLifecycleMutation;
    private authorizeAdminStats;
    private authorizeStandardRpcCall;
    private createRpcLogger;
    private finishRpcLogging;
    private authenticatedAuth;
    private bindAuthenticatedAuth;
    private validateParam0;
    server: any;
    start(): void;
    close(): Promise<void>;
    /** @see {@link validateDate} */
    validateDate(date: Date | string | number): Date;
    /**
     * Helper to force uniform behavior across database engines.
     * Use to process all individual records with time stamps retreived from database.
     * @see {@link validateEntity}
     */
    validateEntity<T extends EntityTimeStamp>(entity: T, dateFields?: string[]): T;
    /**
     * Helper to force uniform behavior across database engines.
     * Use to process all arrays of records with time stamps retreived from database.
     * @returns input `entities` array with contained values validated.
     * @see {@link validateEntities}
     */
    validateEntities<T extends EntityTimeStamp>(entities: T[], dateFields?: string[]): T[];
}
//# sourceMappingURL=StorageServer.d.ts.map