@xrystal/dto 26.6.27-v12

package/dist/core/assemble-log.d.ts

@@ -0,0 +1 @@
+export { assembleLogBody } from '../dto/log/assemble.js';

package/dist/core/assemble-queue.d.ts

@@ -0,0 +1 @@
+export { assembleQueueMessage } from '../dto/queue/assemble.js';

package/dist/core/assemble.d.ts

@@ -0,0 +1,9 @@
+import type { Payload, ResponseBody } from '../types/response.js';
+export interface AssembleInput<T> {
+    status: boolean;
+    message: string;
+    payload?: Payload<T>;
+    code: number;
+}
+/** Guarantees JSON key order: status → message → payload? → code */
+export declare function assembleResponseBody<T>(input: AssembleInput<T>): ResponseBody<T>;

package/dist/core/builder.d.ts

@@ -0,0 +1,49 @@
+import type { HeaderValue } from '../types/codes.js';
+import type { RequestContext } from '../types/context.js';
+import type { MetadataOptions } from '../types/metadata.js';
+import type { BuilderOptions } from '../types/options.js';
+import type { Dispatcher } from '../types/plugin.js';
+import type { FinalResult, Payload, SchemaInput } from '../types/response.js';
+import { ResponseDTO } from '../dto/response/dto.js';
+import { ResponsePresets } from './presets.js';
+/**
+ * Request-scoped response builder — composes {@link ResponseDTO} (body) with transport and dispatch.
+ */
+export declare class Builder<T = unknown> {
+    private readonly dispatcher?;
+    private readonly options;
+    private readonly context?;
+    private readonly plugins;
+    private body;
+    private _statusCode;
+    private _headers;
+    private _cookies;
+    private _presets?;
+    constructor(dispatcher?: Dispatcher<T>, options?: BuilderOptions, context?: RequestContext);
+    get dto(): ResponseDTO<T>;
+    httpStatus(code: number): this;
+    code(code: number): this;
+    status(value: boolean): this;
+    message(msg: string): this;
+    data(data: T | undefined): this;
+    payload(partial: Payload<T>): this;
+    schema(input?: SchemaInput<T>): this;
+    setMeta(meta: Record<string, unknown>): this;
+    withMetadata(options?: MetadataOptions): this;
+    paginate(total: number, page: number, limit: number): this;
+    setHeaders(key: string, value: HeaderValue): this;
+    setHeaders(headers: Record<string, HeaderValue>): this;
+    header(key: string, value: HeaderValue): this;
+    setCookies(name: string, value: string, options?: Record<string, unknown>): this;
+    setCookies(cookies: Record<string, string>, options?: Record<string, unknown>): this;
+    fromError(error: unknown): this;
+    wrap(promise: Promise<T>): Promise<this>;
+    transform<U>(fn: (data: T) => U): Builder<U>;
+    when(condition: boolean, fn: (builder: this) => void): this;
+    get as(): ResponsePresets<T>;
+    build(): FinalResult<T> | unknown;
+    private resolvePublicErrorMessage;
+    private createPluginContext;
+    private emitHook;
+}
+export declare function createBuilderProxy<T = unknown>(dispatcher?: Dispatcher<T>, options?: BuilderOptions, context?: RequestContext): Builder<T>;

package/dist/core/config.d.ts

@@ -0,0 +1,10 @@
+import type { BuilderOptions } from '../types/options.js';
+export declare function resolveBuilderConfig(options?: BuilderOptions): {
+    verbose: boolean;
+    includeStack: boolean | undefined;
+    withDefaultBody: boolean;
+    codes: import("../index.js").CodeMap;
+    hooks: import("../index.js").HookBus | undefined;
+    plugins: import("../index.js").Plugin<unknown>[];
+};
+export type ResolvedBuilderConfig = ReturnType<typeof resolveBuilderConfig>;

package/dist/core/context.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingHttpRequest, RequestContext, ContextFactoryOptions } from '../types/context.js';
+export declare class ContextFactory {
+    static create(req: IncomingHttpRequest, options?: ContextFactoryOptions): RequestContext;
+    static fromId(requestId: string): RequestContext;
+}

package/dist/core/hooks.d.ts

@@ -0,0 +1,8 @@
+import type { HookEvent, HookFn } from '../types/hooks.js';
+export declare class Hooks {
+    private readonly listeners;
+    private emittingError;
+    on(event: HookEvent, fn: HookFn): this;
+    hasListeners(event: HookEvent): boolean;
+    emit(event: HookEvent, payload: unknown): void;
+}