speexjs 0.2.0

package/dist/jsx-DGrnv8QB.d.ts

@@ -0,0 +1,8 @@
+import { VNode } from './client/vdom/index.js';
+
+declare function createElement(tag: any, props: any, ...children: any[]): VNode;
+declare function Fragment(props: {
+    children?: any;
+}): VNode;
+
+export { Fragment as F, createElement as c };

package/dist/response-Ca8KWK5_.d.ts

@@ -0,0 +1,173 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Readable } from 'node:stream';
+
+declare class HeadersMap {
+    private data;
+    constructor(initial?: Record<string, string | string[]>);
+    get(name: string): string | undefined;
+    getAll(name: string): string[];
+    set(name: string, value: string): void;
+    append(name: string, value: string): void;
+    has(name: string): boolean;
+    delete(name: string): void;
+    entries(): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    toJSON(): Record<string, string | string[]>;
+    toNodeHeaders(): Record<string, string | string[]>;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+
+interface UploadedFile {
+    readonly fieldName: string;
+    readonly originalName: string;
+    readonly mimeType: string;
+    readonly size: number;
+    readonly path: string;
+    readonly extension: string;
+    move(destination: string, filename?: string): Promise<string>;
+    toBuffer(): Promise<Buffer>;
+    toBase64(): string;
+    isImage(): boolean;
+    isVideo(): boolean;
+}
+declare class SuperUploadedFile implements UploadedFile {
+    readonly fieldName: string;
+    readonly originalName: string;
+    readonly mimeType: string;
+    readonly size: number;
+    readonly path: string;
+    readonly extension: string;
+    private buffer;
+    constructor(opts: {
+        fieldName: string;
+        originalName: string;
+        mimeType: string;
+        size: number;
+        path: string;
+        buffer?: Buffer;
+    });
+    move(destination: string, filename?: string): Promise<string>;
+    toBuffer(): Promise<Buffer>;
+    toBase64(): string;
+    isImage(): boolean;
+    isVideo(): boolean;
+    static createFromBuffer(fieldName: string, originalName: string, mimeType: string, buffer: Buffer, tempDir?: string): Promise<SuperUploadedFile>;
+    cleanup(): Promise<void>;
+}
+
+interface Schema<T = unknown> {
+    parse(input: unknown): T;
+    validate(input: unknown): {
+        success: boolean;
+        data?: T;
+        errors?: {
+            message: string;
+            path?: string;
+        }[];
+    };
+}
+declare class SuperRequest {
+    private raw;
+    private _headers;
+    private _query;
+    private _cookies;
+    private _ip;
+    private _params;
+    private bodyCache;
+    private _bodyReadPromise;
+    constructor(raw: IncomingMessage);
+    readonly method: string;
+    readonly url: string;
+    readonly path: string;
+    get headers(): HeadersMap;
+    get query(): Record<string, string | string[]>;
+    get params(): Record<string, string>;
+    set params(value: Record<string, string>);
+    get ip(): string;
+    private ensureBody;
+    private readBodyFromStream;
+    private isContentType;
+    private getMultipartBoundary;
+    body(): Promise<unknown>;
+    json<T = unknown>(): Promise<T>;
+    text(): Promise<string>;
+    formData(): Promise<Record<string, string>>;
+    file(name: string): Promise<SuperUploadedFile | undefined>;
+    files(): Promise<Record<string, SuperUploadedFile>>;
+    cookie(name: string): string | undefined;
+    validate<T>(schema: Schema<T>): Promise<T>;
+    isAjax(): boolean;
+    wantsJson(): boolean;
+    bearerToken(): string | undefined;
+    get rawRequest(): IncomingMessage;
+}
+declare class ValidationError extends Error {
+    readonly errors: {
+        message: string;
+        path?: string;
+    }[];
+    constructor(message: string, errors: {
+        message: string;
+        path?: string;
+    }[]);
+}
+
+interface CookieOptions {
+    maxAge?: number;
+    expires?: Date;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+    signed?: boolean;
+}
+declare function parseCookies(header: string): Record<string, string>;
+declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;
+declare function clearCookie(name: string, options?: CookieOptions): string;
+
+interface FileOptions {
+    root?: string;
+    maxAge?: number;
+    acceptRanges?: boolean;
+    cacheControl?: boolean;
+    etag?: boolean;
+    lastModified?: boolean;
+    headers?: Record<string, string>;
+}
+declare class SuperResponse {
+    private raw;
+    private _statusCode;
+    private _headers;
+    private _cookies;
+    private _body;
+    private _sent;
+    private _contentTypeSet;
+    constructor(raw: ServerResponse);
+    status(code: number): this;
+    header(name: string, value: string): this;
+    setHeader(name: string, value: string): this;
+    getHeader(name: string): string | undefined;
+    removeHeader(name: string): this;
+    hasHeader(name: string): boolean;
+    type(contentType: string): this;
+    json<T>(data: T, status?: number): this;
+    send(body: string | Buffer, status?: number, contentType?: string): this;
+    html(html: string, status?: number): this;
+    redirect(url: string, status?: 301 | 302 | 307 | 308): this;
+    stream(stream: Readable, status?: number): this;
+    file(filePath: string, options?: FileOptions): Promise<this>;
+    download(filePath: string, filename?: string): Promise<this>;
+    attachment(filename?: string): this;
+    cookie(name: string, value: string, options?: CookieOptions): this;
+    clearCookie(name: string, options?: CookieOptions): this;
+    get statusCode(): number;
+    get headersSent(): boolean;
+    get rawResponse(): ServerResponse;
+    flush(): Promise<void>;
+    private flushHeaders;
+}
+
+export { type CookieOptions as C, type FileOptions as F, HeadersMap as H, SuperRequest as S, type UploadedFile as U, ValidationError as V, SuperResponse as a, type Schema as b, SuperUploadedFile as c, clearCookie as d, parseCookies as p, serializeCookie as s };

package/dist/rpc/index.d.ts

@@ -0,0 +1,70 @@
+import { S as Schema } from '../types-CXH8hPei.js';
+
+interface RpcProcedure<TInput = unknown, TOutput = unknown> {
+    input?: Schema<TInput>;
+    output?: Schema<TOutput>;
+    handler: (input: TInput, ctx: RpcContext) => TOutput | Promise<TOutput>;
+}
+interface RpcContext {
+    userId?: string | number;
+    user?: unknown;
+    meta: Record<string, unknown>;
+}
+interface RpcDefinitions {
+    [key: string]: RpcProcedure;
+}
+declare class RpcError extends Error {
+    code: string;
+    status: number;
+    details?: unknown | undefined;
+    constructor(code: string, message: string, status?: number, details?: unknown | undefined);
+}
+type InferRpcInput<T extends RpcDefinitions> = {
+    [K in keyof T]: T[K] extends RpcProcedure<infer I, any> ? I : never;
+};
+type InferRpcOutput<T extends RpcDefinitions> = {
+    [K in keyof T]: T[K] extends RpcProcedure<any, infer O> ? O : never;
+};
+
+interface RpcServerOptions<T extends RpcDefinitions> {
+    procedures: T;
+    context?: () => RpcContext | Promise<RpcContext>;
+    middleware?: RpcMiddleware[];
+}
+type RpcMiddleware = (name: string, input: unknown, ctx: RpcContext) => void | Promise<void>;
+declare class RpcServer<T extends RpcDefinitions> {
+    private procedures;
+    private contextFactory?;
+    private middleware;
+    constructor(options: RpcServerOptions<T>);
+    call<K extends keyof T & string>(name: K, input?: unknown): Promise<InferRpcOutput<T>[K]>;
+    toHandler(): (req: any, res: any) => Promise<void>;
+}
+declare function rpc<T extends RpcDefinitions>(options: RpcServerOptions<T>): RpcServer<T>;
+
+interface RpcClientOptions {
+    baseUrl: string;
+    headers?: Record<string, string>;
+    fetch?: typeof globalThis.fetch;
+}
+declare class RpcClient {
+    private baseUrl;
+    private headers;
+    private fetchFn;
+    constructor(options: RpcClientOptions);
+    setHeader(name: string, value: string): void;
+    call<T>(procedure: string, input?: unknown): Promise<T>;
+    batch<T extends unknown[]>(calls: {
+        procedure: string;
+        input?: unknown;
+    }[]): Promise<T>;
+}
+declare class RpcClientError extends Error {
+    code: string;
+    status: number;
+    details?: unknown | undefined;
+    constructor(code: string, message: string, status: number, details?: unknown | undefined);
+}
+declare function createClient(options: RpcClientOptions): RpcClient;
+
+export { type InferRpcInput, type InferRpcOutput, RpcClient, RpcClientError, type RpcClientOptions, type RpcContext, type RpcDefinitions, RpcError, type RpcProcedure, RpcServer, type RpcServerOptions, createClient, rpc };

package/dist/rpc/index.js

@@ -0,0 +1,136 @@
+// src/rpc/types.ts
+var RpcError = class extends Error {
+  constructor(code, message, status = 400, details) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = "RpcError";
+  }
+  code;
+  status;
+  details;
+};
+
+// src/rpc/server/index.ts
+var RpcServer = class {
+  procedures;
+  contextFactory;
+  middleware;
+  constructor(options) {
+    this.procedures = options.procedures;
+    this.contextFactory = options.context;
+    this.middleware = options.middleware || [];
+  }
+  async call(name, input) {
+    const proc = this.procedures[name];
+    if (!proc) throw new RpcError("NOT_FOUND", `Procedure '${name}' not found`, 404);
+    const ctx = this.contextFactory ? await this.contextFactory() : { meta: {} };
+    for (const mw of this.middleware) {
+      await mw(name, input, ctx);
+    }
+    let validatedInput = input;
+    if (proc.input) {
+      const result = proc.input.safeParse(input);
+      if (!result.success) {
+        throw new RpcError("VALIDATION_ERROR", result.error || "Invalid input", 422, result.error);
+      }
+      validatedInput = result.data;
+    }
+    const output = await proc.handler(validatedInput, ctx);
+    if (proc.output) {
+      const result = proc.output.safeParse(output);
+      if (!result.success) {
+        throw new RpcError("VALIDATION_ERROR", "Invalid output from server", 500);
+      }
+      return result.data;
+    }
+    return output;
+  }
+  toHandler() {
+    return async (req, res) => {
+      try {
+        const body = typeof req.body === "object" ? req.body : JSON.parse(req.body || "{}");
+        const { procedure, input } = body;
+        const output = await this.call(procedure, input);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: true, data: output }));
+      } catch (err) {
+        if (err instanceof RpcError) {
+          res.writeHead(err.status, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            success: false,
+            error: { code: err.code, message: err.message, details: err.details }
+          }));
+        } else {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: false, error: { code: "INTERNAL", message: "Internal server error" } }));
+        }
+      }
+    };
+  }
+};
+function rpc(options) {
+  return new RpcServer(options);
+}
+
+// src/rpc/client/index.ts
+var RpcClient = class {
+  baseUrl;
+  headers;
+  fetchFn;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.headers = options.headers || {};
+    this.fetchFn = options.fetch || globalThis.fetch;
+  }
+  setHeader(name, value) {
+    this.headers[name] = value;
+  }
+  async call(procedure, input) {
+    const response = await this.fetchFn(`${this.baseUrl}/rpc`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...this.headers },
+      body: JSON.stringify({ procedure, input })
+    });
+    const json = await response.json();
+    if (!json.success) {
+      throw new RpcClientError(json.error?.code || "UNKNOWN", json.error?.message || "Unknown error", response.status, json.error?.details);
+    }
+    return json.data;
+  }
+  async batch(calls) {
+    const response = await this.fetchFn(`${this.baseUrl}/rpc/batch`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...this.headers },
+      body: JSON.stringify({ calls })
+    });
+    const json = await response.json();
+    if (!json.success) throw new RpcClientError("BATCH_ERROR", json.error?.message || "Batch failed", response.status);
+    return json.data;
+  }
+};
+var RpcClientError = class extends Error {
+  constructor(code, message, status, details) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = "RpcClientError";
+  }
+  code;
+  status;
+  details;
+};
+function createClient(options) {
+  return new RpcClient(options);
+}
+export {
+  RpcClient,
+  RpcClientError,
+  RpcError,
+  RpcServer,
+  createClient,
+  rpc
+};
+//# sourceMappingURL=index.js.map

package/dist/rpc/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/rpc/types.ts","../../src/rpc/server/index.ts","../../src/rpc/client/index.ts"],"sourcesContent":["import type { Schema } from '../schema/index.js'\n\nexport interface RpcProcedure<TInput = unknown, TOutput = unknown> {\n  input?: Schema<TInput>\n  output?: Schema<TOutput>\n  handler: (input: TInput, ctx: RpcContext) => TOutput | Promise<TOutput>\n}\n\nexport interface RpcContext {\n  userId?: string | number\n  user?: unknown\n  meta: Record<string, unknown>\n}\n\nexport type RpcQuery<TInput, TOutput> = RpcProcedure<TInput, TOutput>\nexport type RpcMutation<TInput, TOutput> = RpcProcedure<TInput, TOutput>\n\nexport interface RpcDefinitions {\n  [key: string]: RpcProcedure\n}\n\nexport class RpcError extends Error {\n  constructor(\n    public code: string,\n    message: string,\n    public status: number = 400,\n    public details?: unknown\n  ) {\n    super(message)\n    this.name = 'RpcError'\n  }\n}\n\nexport type InferRpcInput<T extends RpcDefinitions> = {\n  [K in keyof T]: T[K] extends RpcProcedure<infer I, any> ? I : never\n}\n\nexport type InferRpcOutput<T extends RpcDefinitions> = {\n  [K in keyof T]: T[K] extends RpcProcedure<any, infer O> ? O : never\n}\n","import type { Schema } from '../../schema/index.js'\nimport type { RpcDefinitions, RpcContext, InferRpcOutput } from '../types.js'\nimport { RpcError } from '../types.js'\n\nexport interface RpcServerOptions<T extends RpcDefinitions> {\n  procedures: T\n  context?: () => RpcContext | Promise<RpcContext>\n  middleware?: RpcMiddleware[]\n}\n\ntype RpcMiddleware = (name: string, input: unknown, ctx: RpcContext) => void | Promise<void>\n\nexport class RpcServer<T extends RpcDefinitions> {\n  private procedures: T\n  private contextFactory?: () => RpcContext | Promise<RpcContext>\n  private middleware: RpcMiddleware[]\n\n  constructor(options: RpcServerOptions<T>) {\n    this.procedures = options.procedures\n    this.contextFactory = options.context\n    this.middleware = options.middleware || []\n  }\n\n  async call<K extends keyof T & string>(\n    name: K,\n    input?: unknown\n  ): Promise<InferRpcOutput<T>[K]> {\n    const proc = this.procedures[name]\n    if (!proc) throw new RpcError('NOT_FOUND', `Procedure '${name}' not found`, 404)\n\n    const ctx: RpcContext = this.contextFactory ? await this.contextFactory() : { meta: {} }\n\n    for (const mw of this.middleware) {\n      await mw(name, input, ctx)\n    }\n\n    let validatedInput = input\n    if (proc.input) {\n      const result = (proc.input as Schema<any>).safeParse(input)\n      if (!result.success) {\n        throw new RpcError('VALIDATION_ERROR', result.error || 'Invalid input', 422, result.error)\n      }\n      validatedInput = result.data\n    }\n\n    const output = await proc.handler(validatedInput, ctx)\n\n    if (proc.output) {\n      const result = (proc.output as Schema<any>).safeParse(output)\n      if (!result.success) {\n        throw new RpcError('VALIDATION_ERROR', 'Invalid output from server', 500)\n      }\n      return result.data as InferRpcOutput<T>[K]\n    }\n\n    return output as InferRpcOutput<T>[K]\n  }\n\n  toHandler(): (req: any, res: any) => Promise<void> {\n    return async (req, res) => {\n      try {\n        const body = typeof req.body === 'object' ? req.body : JSON.parse(req.body || '{}')\n        const { procedure, input } = body\n        const output = await this.call(procedure, input)\n        res.writeHead(200, { 'Content-Type': 'application/json' })\n        res.end(JSON.stringify({ success: true, data: output }))\n      } catch (err) {\n        if (err instanceof RpcError) {\n          res.writeHead(err.status, { 'Content-Type': 'application/json' })\n          res.end(JSON.stringify({\n            success: false,\n            error: { code: err.code, message: err.message, details: err.details }\n          }))\n        } else {\n          res.writeHead(500, { 'Content-Type': 'application/json' })\n          res.end(JSON.stringify({ success: false, error: { code: 'INTERNAL', message: 'Internal server error' } }))\n        }\n      }\n    }\n  }\n}\n\nexport function rpc<T extends RpcDefinitions>(options: RpcServerOptions<T>): RpcServer<T> {\n  return new RpcServer(options)\n}\n","export interface RpcClientOptions {\n  baseUrl: string\n  headers?: Record<string, string>\n  fetch?: typeof globalThis.fetch\n}\n\nexport class RpcClient {\n  private baseUrl: string\n  private headers: Record<string, string>\n  private fetchFn: typeof globalThis.fetch\n\n  constructor(options: RpcClientOptions) {\n    this.baseUrl = options.baseUrl.replace(/\\/$/, '')\n    this.headers = options.headers || {}\n    this.fetchFn = options.fetch || globalThis.fetch\n  }\n\n  setHeader(name: string, value: string): void {\n    this.headers[name] = value\n  }\n\n  async call<T>(procedure: string, input?: unknown): Promise<T> {\n    const response = await this.fetchFn(`${this.baseUrl}/rpc`, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json', ...this.headers },\n      body: JSON.stringify({ procedure, input }),\n    })\n\n    const json = await response.json()\n    if (!json.success) {\n      throw new RpcClientError(json.error?.code || 'UNKNOWN', json.error?.message || 'Unknown error', response.status, json.error?.details)\n    }\n    return json.data as T\n  }\n\n  async batch<T extends unknown[]>(calls: { procedure: string; input?: unknown }[]): Promise<T> {\n    const response = await this.fetchFn(`${this.baseUrl}/rpc/batch`, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json', ...this.headers },\n      body: JSON.stringify({ calls }),\n    })\n    const json = await response.json()\n    if (!json.success) throw new RpcClientError('BATCH_ERROR', json.error?.message || 'Batch failed', response.status)\n    return json.data as T\n  }\n}\n\nexport class RpcClientError extends Error {\n  constructor(\n    public code: string,\n    message: string,\n    public status: number,\n    public details?: unknown\n  ) {\n    super(message)\n    this.name = 'RpcClientError'\n  }\n}\n\nexport function createClient(options: RpcClientOptions): RpcClient {\n  return new RpcClient(options)\n}\n"],"mappings":"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","names":[]}

package/dist/schema/index.d.ts

@@ -0,0 +1,231 @@
+import { S as Schema, I as Infer } from '../types-CXH8hPei.js';
+export { a as SchemaError } from '../types-CXH8hPei.js';
+
+declare function setLocale(locale: 'id' | 'en'): void;
+declare function getLocale(): 'id' | 'en';
+
+declare class StringSchema extends Schema<string> {
+    private checks;
+    min(n: number): this;
+    max(n: number): this;
+    length(n: number): this;
+    email(): this;
+    url(): this;
+    regex(pattern: RegExp): this;
+    includes(substring: string): this;
+    startsWith(prefix: string): this;
+    endsWith(suffix: string): this;
+    trim(): StringTrimSchema;
+    lowercase(): StringLowercaseSchema;
+    uppercase(): StringUppercaseSchema;
+    _parse(value: unknown): string;
+}
+declare class StringTrimSchema extends Schema<string> {
+    private readonly inner;
+    constructor(inner: StringSchema);
+    _parse(value: unknown): string;
+}
+declare class StringLowercaseSchema extends Schema<string> {
+    private readonly inner;
+    constructor(inner: StringSchema);
+    _parse(value: unknown): string;
+}
+declare class StringUppercaseSchema extends Schema<string> {
+    private readonly inner;
+    constructor(inner: StringSchema);
+    _parse(value: unknown): string;
+}
+declare class NumberSchema extends Schema<number> {
+    private checks;
+    min(n: number): this;
+    max(n: number): this;
+    int(): this;
+    positive(): this;
+    negative(): this;
+    finite(): this;
+    safe(): this;
+    _parse(value: unknown): number;
+}
+declare class BooleanSchema extends Schema<boolean> {
+    _parse(value: unknown): boolean;
+}
+declare class BigIntSchema extends Schema<bigint> {
+    _parse(value: unknown): bigint;
+}
+declare class SymbolSchema extends Schema<symbol> {
+    _parse(value: unknown): symbol;
+}
+declare class UndefinedSchema extends Schema<undefined> {
+    _parse(value: unknown): undefined;
+}
+declare class NullSchema extends Schema<null> {
+    _parse(value: unknown): null;
+}
+declare class NaNSchema extends Schema<number> {
+    _parse(value: unknown): number;
+}
+
+type Shape = Record<string, Schema<unknown>>;
+declare class ObjectSchema<T extends Shape> extends Schema<{
+    [K in keyof T]: Infer<T[K]>;
+}> {
+    readonly shape: T;
+    private isStrictMode;
+    private isPassthroughMode;
+    constructor(shape: T);
+    strict(): this;
+    passthrough(): this;
+    partial(): ObjectSchema<{
+        [K in keyof T]: Schema<Infer<T[K]> | undefined>;
+    }>;
+    pick<K extends keyof T>(keys: K[]): ObjectSchema<Pick<T, K>>;
+    omit<K extends keyof T>(keys: K[]): ObjectSchema<Omit<T, K>>;
+    extend<U extends Shape>(shape: U): ObjectSchema<T & U>;
+    merge<U extends Shape>(other: ObjectSchema<U>): ObjectSchema<T & U>;
+    _parse(value: unknown): {
+        [K in keyof T]: Infer<T[K]>;
+    };
+}
+declare class ArraySchema<T> extends Schema<T[]> {
+    private readonly itemSchema;
+    private checks;
+    constructor(itemSchema: Schema<T>);
+    min(n: number): this;
+    max(n: number): this;
+    length(n: number): this;
+    nonempty(): this;
+    unique(): this;
+    _parse(value: unknown): T[];
+}
+type TupleSchemaTypes<T extends Schema<unknown>[]> = {
+    [K in keyof T]: Infer<T[K]>;
+};
+declare class TupleSchema<T extends Schema<unknown>[]> extends Schema<TupleSchemaTypes<T>> {
+    private readonly schemas;
+    constructor(schemas: [...T]);
+    _parse(value: unknown): TupleSchemaTypes<T>;
+}
+declare class EnumSchema<T extends string> extends Schema<T> {
+    private readonly values;
+    constructor(values: readonly T[]);
+    _parse(value: unknown): T;
+    get enum(): readonly T[];
+}
+declare class UnionSchema<T> extends Schema<T> {
+    private readonly schemas;
+    constructor(schemas: readonly Schema<unknown>[]);
+    _parse(value: unknown): T;
+}
+declare class IntersectionSchema<A, B> extends Schema<A & B> {
+    private readonly left;
+    private readonly right;
+    constructor(left: Schema<A>, right: Schema<B>);
+    _parse(value: unknown): A & B;
+}
+declare class RecordSchema<V> extends Schema<Record<string, V>> {
+    private readonly valueSchema;
+    constructor(valueSchema: Schema<V>);
+    _parse(value: unknown): Record<string, V>;
+}
+declare class MapSchema<K, V> extends Schema<Map<K, V>> {
+    private readonly keySchema;
+    private readonly valueSchema;
+    constructor(keySchema: Schema<K>, valueSchema: Schema<V>);
+    _parse(value: unknown): Map<K, V>;
+}
+declare class SetSchema<T> extends Schema<Set<T>> {
+    private readonly itemSchema;
+    constructor(itemSchema: Schema<T>);
+    _parse(value: unknown): Set<T>;
+}
+declare class DateSchema extends Schema<Date> {
+    _parse(value: unknown): Date;
+}
+type LiteralValue = string | number | boolean | null | undefined;
+declare class LiteralSchema<T extends LiteralValue> extends Schema<T> {
+    private readonly expected;
+    constructor(expected: T);
+    _parse(value: unknown): T;
+}
+declare class AnySchema extends Schema<any> {
+    _parse(value: unknown): any;
+}
+declare class UnknownSchema extends Schema<unknown> {
+    _parse(value: unknown): unknown;
+}
+
+declare class NIKSchema extends Schema<string> {
+    _parse(value: unknown): string;
+}
+declare class NPWPSchema extends Schema<string> {
+    _parse(value: unknown): string;
+}
+declare class PhoneSchema extends Schema<string> {
+    _parse(value: unknown): string;
+}
+declare class AlamatSchema extends Schema<string> {
+    _parse(value: unknown): string;
+}
+declare class KodeposSchema extends Schema<string> {
+    _parse(value: unknown): string;
+}
+declare class RekeningSchema extends Schema<string> {
+    _parse(value: unknown): string;
+}
+
+declare class CoerceStringSchema extends Schema<string> {
+    _parse(value: unknown): string;
+}
+declare class CoerceNumberSchema extends Schema<number> {
+    _parse(value: unknown): number;
+}
+declare class CoerceBooleanSchema extends Schema<boolean> {
+    _parse(value: unknown): boolean;
+}
+declare class CoerceDateSchema extends Schema<Date> {
+    _parse(value: unknown): Date;
+}
+declare class StandaloneTransformSchema<T> extends Schema<T> {
+    private readonly fn;
+    constructor(fn: (value: unknown) => T);
+    _parse(value: unknown): T;
+}
+
+declare const s: {
+    readonly string: () => StringSchema;
+    readonly number: () => NumberSchema;
+    readonly boolean: () => BooleanSchema;
+    readonly bigint: () => BigIntSchema;
+    readonly symbol: () => SymbolSchema;
+    readonly undefined: () => UndefinedSchema;
+    readonly null: () => NullSchema;
+    readonly nan: () => NaNSchema;
+    readonly object: <T extends Record<string, Schema<unknown>>>(shape: T) => ObjectSchema<T>;
+    readonly array: <T>(itemSchema: Schema<T>) => ArraySchema<T>;
+    readonly tuple: <T extends Schema<unknown>[]>(...schemas: T) => TupleSchema<T>;
+    readonly enum: <T extends string>(values: readonly T[]) => EnumSchema<T>;
+    readonly union: <T extends Schema<unknown>[]>(...schemas: T) => UnionSchema<T[number] extends Schema<infer U> ? U : never>;
+    readonly intersection: <A, B>(left: Schema<A>, right: Schema<B>) => IntersectionSchema<A, B>;
+    readonly record: <V>(valueSchema: Schema<V>) => RecordSchema<V>;
+    readonly map: <K, V>(keySchema: Schema<K>, valueSchema: Schema<V>) => MapSchema<K, V>;
+    readonly set: <T>(itemSchema: Schema<T>) => SetSchema<T>;
+    readonly date: () => DateSchema;
+    readonly literal: <T extends string | number | boolean | null | undefined>(value: T) => LiteralSchema<T>;
+    readonly any: () => AnySchema;
+    readonly unknown: () => UnknownSchema;
+    readonly nik: () => NIKSchema;
+    readonly npwp: () => NPWPSchema;
+    readonly phone: () => PhoneSchema;
+    readonly alamat: () => AlamatSchema;
+    readonly kodepos: () => KodeposSchema;
+    readonly rekening: () => RekeningSchema;
+    readonly coerce: {
+        readonly string: () => CoerceStringSchema;
+        readonly number: () => CoerceNumberSchema;
+        readonly boolean: () => CoerceBooleanSchema;
+        readonly date: () => CoerceDateSchema;
+    };
+    readonly transform: <T>(fn: (value: unknown) => T) => StandaloneTransformSchema<T>;
+};
+
+export { AlamatSchema, AnySchema, ArraySchema, BigIntSchema, BooleanSchema, CoerceBooleanSchema, CoerceDateSchema, CoerceNumberSchema, CoerceStringSchema, DateSchema, EnumSchema, Infer, IntersectionSchema, KodeposSchema, LiteralSchema, MapSchema, NIKSchema, NPWPSchema, NaNSchema, NullSchema, NumberSchema, ObjectSchema, PhoneSchema, RecordSchema, RekeningSchema, Schema, SetSchema, StringSchema, SymbolSchema, TupleSchema, UndefinedSchema, UnionSchema, UnknownSchema, getLocale, s, setLocale };