@ws-kit/valibot/dist/runtime.d.ts

Valibot validator adapter for WS-Kit with lightweight runtime validation and minimal bundle size

/**
 * Runtime envelope builders for Valibot schemas.
 * Provides two forms: object-oriented (primary) and positional (compact).
 *
 * Both return strict Valibot root objects with non-enumerable hints for the router
 * and per-schema options (validateOutgoing, strict) for granular control.
 *
 * Users can compose schemas before wrapping to preserve type safety:
 * const JoinPayload = v.pipe(v.object({roomId: v.string()}), v.transform(...));
 * const Join = message({ type: "JOIN", payload: JoinPayload, options: {...} });
 *
 * Mirrors the Zod runtime.ts pattern for parity.
 */
import { type SchemaOpts } from "@ws-kit/core/internal";
import { type GenericSchema } from "valibot";
import type { BrandedSchema, InferMetaShape, InferPayloadShape, SafeParseResult } from "./types.js";
/**
 * Symbol for Valibot payload schema (validator-specific).
 * Stores the Valibot schema for the payload field.
 */
export declare const VALIBOT_PAYLOAD: unique symbol;
/**
 * Creates a strict Valibot root message schema.
 * Supports two forms: object-oriented (primary) and positional (compact).
 *
 * Object form (recommended for clarity and extensibility):
 * ```typescript
 * const Join = message({
 *   type: "USER_JOIN",
 *   payload: v.object({ roomId: v.string() }),
 *   options: { strict: true }
 * });
 * ```
 *
 * Positional form (for small, one-off schemas):
 * ```typescript
 * const Ping = message("PING");
 * const Join = message("USER_JOIN", { roomId: v.string() });
 * ```
 */
export declare function message<const T extends string, P extends Record<string, GenericSchema> | GenericSchema | undefined = undefined, M extends Record<string, GenericSchema> | undefined = undefined>(spec: {
    readonly type: T;
    readonly payload?: P;
    readonly meta?: M;
    readonly options?: SchemaOpts;
}): GenericSchema & BrandedSchema<T, P extends undefined ? never : InferPayloadShape<P>, never, InferMetaShape<M>> & {
    readonly _types?: unknown;
    readonly __valibot_payload: P;
    readonly __descriptor: {
        readonly messageType: T;
        readonly kind: "event";
    };
    readonly __runtime: "ws-kit-schema";
    readonly safeParse: (data: unknown) => SafeParseResult;
    readonly parse: (data: unknown) => Promise<any>;
};
export declare function message<const T extends string, P extends Record<string, GenericSchema> | GenericSchema | undefined = undefined, M extends Record<string, GenericSchema> | undefined = undefined>(type: T, payload?: P, metaShape?: M): GenericSchema & BrandedSchema<T, P extends undefined ? never : InferPayloadShape<P>, never, InferMetaShape<M>> & {
    readonly messageType: T;
    readonly _types?: unknown;
    readonly __valibot_payload: P;
    readonly __descriptor: {
        readonly messageType: T;
        readonly kind: "event";
    };
    readonly __runtime: "ws-kit-schema";
    readonly safeParse: (data: unknown) => SafeParseResult;
    readonly parse: (data: unknown) => Promise<any>;
};
/**
 * Creates an RPC schema with separate request and response message definitions.
 * Supports two forms: object-oriented (primary) and positional (compact).
 *
 * Object form (recommended for granular control):
 * ```typescript
 * const GetUser = rpc({
 *   req: {
 *     type: "GET_USER",
 *     payload: v.object({ id: v.string() })
 *   },
 *   res: {
 *     type: "USER",
 *     payload: v.object({ id: v.string(), name: v.string() }),
 *     options: { validateOutgoing: true }
 *   }
 * });
 * ```
 *
 * Positional form (for simple, compact contracts):
 * ```typescript
 * const GetUser = rpc(
 *   "GET_USER", { id: v.string() },
 *   "USER",     { id: v.string(), name: v.string() }
 * );
 * ```
 */
export declare function rpc<const ReqT extends string, ReqP extends Record<string, GenericSchema> | GenericSchema | undefined, ResT extends string, ResP extends Record<string, GenericSchema> | GenericSchema | undefined, ReqM extends Record<string, GenericSchema> | undefined = undefined, ResM extends Record<string, GenericSchema> | undefined = undefined>(spec: {
    readonly req: {
        readonly type: ReqT;
        readonly payload?: ReqP;
        readonly meta?: ReqM;
        readonly options?: SchemaOpts;
    };
    readonly res: {
        readonly type: ResT;
        readonly payload?: ResP;
        readonly meta?: ResM;
        readonly options?: SchemaOpts;
    };
}): GenericSchema & BrandedSchema<ReqT, InferPayloadShape<ReqP>, InferPayloadShape<ResP>, InferMetaShape<ReqM>> & {
    readonly response: GenericSchema & BrandedSchema<ResT, InferPayloadShape<ResP>, never, InferMetaShape<ResM>> & {
        readonly messageType: ResT;
        readonly _types?: unknown;
        readonly __valibot_payload: ResP;
        readonly __descriptor: {
            readonly messageType: ResT;
            readonly kind: "event";
        };
        readonly __runtime: "ws-kit-schema";
        readonly safeParse: (data: unknown) => SafeParseResult;
        readonly parse: (data: unknown) => Promise<any>;
    };
    readonly messageType: ReqT;
    readonly _types?: unknown;
    readonly __valibot_payload: ReqP;
    readonly __descriptor: {
        readonly messageType: ReqT;
        readonly kind: "rpc";
    };
    readonly __runtime: "ws-kit-schema";
    readonly safeParse: (data: unknown) => SafeParseResult;
    readonly parse: (data: unknown) => Promise<any>;
};
export declare function rpc<const ReqT extends string, ReqP extends Record<string, GenericSchema> | GenericSchema | undefined, ResT extends string, ResP extends Record<string, GenericSchema> | GenericSchema | undefined>(requestType: ReqT, requestPayload: ReqP, responseType: ResT, responsePayload: ResP): GenericSchema & BrandedSchema<ReqT, InferPayloadShape<ReqP>, InferPayloadShape<ResP>, {
    timestamp?: number;
    correlationId?: string;
}> & {
    readonly response: GenericSchema & BrandedSchema<ResT, InferPayloadShape<ResP>, never, {
        timestamp?: number;
        correlationId?: string;
    }> & {
        readonly messageType: ResT;
        readonly _types?: unknown;
        readonly __valibot_payload: ResP;
        readonly __descriptor: {
            readonly messageType: ResT;
            readonly kind: "event";
        };
        readonly __runtime: "ws-kit-schema";
        readonly safeParse: (data: unknown) => SafeParseResult;
        readonly parse: (data: unknown) => Promise<any>;
    };
    readonly messageType: ReqT;
    readonly _types?: unknown;
    readonly __valibot_payload: ReqP;
    readonly __descriptor: {
        readonly messageType: ReqT;
        readonly kind: "rpc";
    };
    readonly __runtime: "ws-kit-schema";
    readonly safeParse: (data: unknown) => SafeParseResult;
    readonly parse: (data: unknown) => Promise<any>;
};
//# sourceMappingURL=runtime.d.ts.map