tina4-nodejs 3.13.92 → 3.13.95

package/types/core/src/graphql.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Tina4 GraphQL — Zero-dependency GraphQL engine.
+ *
+ * Recursive-descent parser, schema builder, and query executor.
+ *
+ *   import { GraphQL } from "@tina4/core";
+ *
+ *   const gql = new GraphQL();
+ *   gql.addType("User", { id: { type: "ID" }, name: { type: "String" } });
+ *   gql.addQuery("user", { id: "ID!" }, "User", (root, args) => getUser(args.id));
+ *   const result = gql.execute('{ user(id: "1") { name } }');
+ *
+ * Supported:
+ *   - Queries, mutations
+ *   - Variables, default values
+ *   - Aliases
+ *   - Nested selections
+ *   - List types ([Type])
+ *   - Non-null types (Type!)
+ *   - Error capture (resolver exceptions become GraphQL errors)
+ */
+export interface GraphQLField {
+    type: string;
+    description?: string;
+}
+export type ResolverFn = (root: unknown, args: Record<string, unknown>, context?: Record<string, unknown>) => unknown;
+export interface GraphQLResult {
+    data: Record<string, unknown> | null;
+    errors?: Array<{
+        message: string;
+        path?: string[];
+    }>;
+}
+interface Token {
+    type: string;
+    value: string;
+    pos: number;
+}
+export declare function tokenize(source: string): Token[];
+export declare class ParseError extends Error {
+    constructor(message: string);
+}
+/**
+ * URL the GraphQL handler should be mounted at.
+ * `TINA4_GRAPHQL_ENDPOINT` overrides the default `/graphql`.
+ */
+export declare function graphqlEndpoint(): string;
+/**
+ * Whether to auto-generate the schema from registered ORM models.
+ * `TINA4_GRAPHQL_AUTO_SCHEMA=true` (default) lets the dev server build a
+ * usable schema with no manual wiring; set to `false` to require explicit
+ * `addType` / `addQuery` calls.
+ */
+export declare function graphqlAutoSchemaEnabled(): boolean;
+/**
+ * Maximum selection-set nesting depth. A deeply nested query (or a circular
+ * fragment) would otherwise recurse without bound — a classic GraphQL DoS /
+ * stack-overflow vector. `TINA4_GRAPHQL_MAX_DEPTH` overrides the default (50);
+ * set `<= 0` to disable the guard. A non-numeric value falls back to 50.
+ */
+export declare function graphqlMaxDepth(): number;
+export declare class GraphQL {
+    private types;
+    private queries;
+    private mutations;
+    /** Object-type field resolvers indexed by `[typeName][fieldName]`. */
+    private fieldResolvers;
+    private static classResolvers;
+    private static defaultInstance;
+    /**
+     * Maximum selection-set nesting depth (read from `TINA4_GRAPHQL_MAX_DEPTH`,
+     * default 50; `<= 0` disables the guard). Public so tests can set it and the
+     * dev app can introspect it. Counted per selection level AND per fragment
+     * spread / inline fragment, so circular fragments are caught too.
+     */
+    maxDepth: number;
+    /**
+     * Decorator-style resolver registration.
+     *
+     * Resolvers may be synchronous OR async (return a Promise) — `execute()`
+     * awaits every resolver, so an `async` resolver's value is resolved before
+     * the field is serialized. Return a value directly, or `await` your data
+     * (e.g. an async DB driver) and the executor will await it for you.
+     *
+     *     GraphQL.resolve("Query", "products", async (root, args) =>
+     *       (await db.fetch("SELECT * FROM products")).records);
+     *
+     *     GraphQL.resolve("Mutation", "createProduct", async (root, args) => {
+     *       const p = new Product(args.input);
+     *       await p.save();
+     *       return p.toDict();
+     *     });
+     *
+     *     GraphQL.resolve("Product", "reviews", async (product, args) =>
+     *       (await db.fetch("SELECT * FROM reviews WHERE product_id = ?", [product.id])).records);
+     *
+     * Resolvers registered before any GraphQL instance exists accumulate
+     * in the class-level registry. `new GraphQL()` drains them into its
+     * schema. Resolvers registered after `setDefault(gql)` wire into the
+     * live schema immediately.
+     */
+    static resolve(typeName: string, fieldName: string, resolver: ResolverFn): void;
+    /**
+     * Designate `instance` as the default singleton. Post-startup
+     * `GraphQL.resolve()` calls wire into this instance's live schema.
+     */
+    static setDefault(instance: GraphQL): void;
+    /** Test-only — clear the class-level registry. */
+    static _clearClassResolvers(): void;
+    constructor();
+    /** Wire a single resolver into the live schema. */
+    private attachResolver;
+    /**
+     * Get the field resolver registered for an object type, if any.
+     * Used by the executor during nested field resolution.
+     */
+    getFieldResolver(typeName: string, fieldName: string): ResolverFn | undefined;
+    /**
+     * Return schema metadata for debugging.
+     */
+    introspect(): Record<string, unknown>;
+    /**
+     * Register a named type with its fields.
+     */
+    addType(name: string, fields: Record<string, GraphQLField>): GraphQL;
+    /**
+     * Register a query resolver.
+     */
+    addQuery(name: string, args: Record<string, string>, returnType: string, resolver: ResolverFn): GraphQL;
+    /**
+     * Register a mutation resolver.
+     */
+    addMutation(name: string, args: Record<string, string>, returnType: string, resolver: ResolverFn): GraphQL;
+    /**
+     * Execute a GraphQL query string.
+     */
+    execute(query: string, variables?: Record<string, unknown>, context?: Record<string, unknown>): Promise<GraphQLResult>;
+    /**
+     * Resolve a list of selections and merge results into the `target` dict.
+     * Fragment spreads and inline fragments are merged (not nested).
+     *
+     * `depth` is incremented on every recursive entry (field sub-selections,
+     * fragment spreads, inline fragments) and checked against `maxDepth` so an
+     * over-deep query or a circular fragment fails with a structured error
+     * instead of recursing until the interpreter stack overflows. Top-level
+     * starts at depth 1; `maxDepth <= 0` disables the guard.
+     */
+    private resolveSelectionsInto;
+    /**
+     * Generate SDL schema string.
+     */
+    schemaSdl(): string;
+    /**
+     * Auto-generate type, queries, and CRUD mutations from an ORM model class.
+     *
+     * The model class must have static `tableName` (string) and `fields`
+     * (Record<string, { type: string; primaryKey?: boolean }>).
+     *
+     * Creates:
+     *   - A GraphQL type from the model's fields
+     *   - Queries: {modelName}(id: ID!): Type, {modelNames}(limit: Int, offset: Int): [Type]
+     *   - Mutations: create{ModelName}, update{ModelName}, delete{ModelName}
+     *
+     * @param modelClass - The model class with static tableName and fields
+     * @param adapter - Optional database adapter; if omitted, resolvers will
+     *                  import getAdapter from @tina4/orm at call time
+     */
+    fromOrm(modelClass: {
+        tableName: string;
+        fields: Record<string, {
+            type: string;
+            primaryKey?: boolean;
+        }>;
+        name?: string;
+    }, adapter?: {
+        query: <T = Record<string, unknown>>(sql: string, params?: unknown[]) => T[];
+        execute: (sql: string, params?: unknown[]) => unknown;
+    }): GraphQL;
+    private formatArgs;
+    private resolveField;
+    private resolveArgs;
+    /**
+     * Check directives: @skip, @include, @auth, @role, @guest.
+     * Returns true if the field should be included, false to skip.
+     */
+    private checkDirectives;
+    /**
+     * Validate resolved args against declared types.
+     */
+    private validateArgs;
+    private coerceValue;
+}
+/**
+ * Lightweight GraphQL type wrapper matching Ruby's GraphQLType.
+ */
+export declare class GraphQLType {
+    static readonly SCALARS: string[];
+    name: string;
+    kind: string;
+    ofType: GraphQLType | null;
+    constructor(name: string, kind?: string, ofType?: GraphQLType | null);
+    /**
+     * Parse a GraphQL type string like "String", "String!", "[Int!]!".
+     */
+    static parse(typeStr: string): GraphQLType;
+}
+export {};

package/types/core/src/health.d.ts

@@ -0,0 +1,22 @@
+import type { RouteDefinition } from "./types.js";
+/**
+ * Resolve the health route path. Priority:
+ *   1. `TINA4_HEALTH_PATH` env var
+ *   2. Default `/__health` (matches Python parity — under-prefix avoids
+ *      colliding with app routes named /health)
+ */
+export declare function healthPath(): string;
+/**
+ * Create the primary health route definition.
+ *
+ * Tests use this directly. Server bootstrap goes through createHealthRoutes()
+ * to also register the legacy `/health` alias when TINA4_HEALTH_PATH points
+ * elsewhere — matching Python behaviour so existing probes don't break.
+ */
+export declare function createHealthRoute(version?: string): RouteDefinition;
+/**
+ * Create one or two health routes — the env-defined path always, plus a
+ * legacy `/health` alias when the env path differs. Mirrors
+ * tina4-python's two-line registration in `core/server.py`.
+ */
+export declare function createHealthRoutes(version?: string): RouteDefinition[];

package/types/core/src/htmlElement.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Programmatic HTML builder — avoids string concatenation.
+ *
+ * Usage:
+ *   const el = new HtmlElement("div", { class: "card" }, ["Hello"]);
+ *   el.toString();  // '<div class="card">Hello</div>'
+ *
+ *   // Builder pattern
+ *   const el = htmlElement("div")(htmlElement("p")("Text"));
+ *
+ *   // Helper functions
+ *   const h: Record<string, any> = {};
+ *   addHtmlHelpers(h);
+ *   const html = h._div({ class: "card" }, h._p("Hello"));
+ */
+/**
+ * Raw — marker for trusted, pre-sanitised HTML that must render UNESCAPED.
+ *
+ * String/scalar children of an HtmlElement are HTML-escaped by default to
+ * prevent stored/reflected XSS. Wrap a value in Raw to opt out of escaping
+ * when (and only when) you have already sanitised it yourself.
+ *
+ *   new HtmlElement("div", {}, ["<b>x</b>"]).toString()           // &lt;b&gt;x&lt;/b&gt;  (escaped)
+ *   new HtmlElement("div", {}, [new Raw("<b>x</b>")]).toString()  // <b>x</b>              (raw)
+ *
+ * Alias: SafeString.
+ */
+export declare class Raw {
+    readonly value: string;
+    constructor(value: string);
+    toString(): string;
+}
+export declare const SafeString: typeof Raw;
+type Attrs = Record<string, string | number | boolean | null | undefined>;
+type Child = string | number | HtmlElement | Raw;
+/**
+ * HtmlElement — a single HTML tag with attributes and children.
+ */
+export declare class HtmlElement {
+    readonly tag: string;
+    readonly attrs: Attrs;
+    readonly children: Child[];
+    constructor(tag: string, attrs?: Attrs, children?: Child[]);
+    /**
+     * Render to HTML string.
+     */
+    toString(): string;
+}
+/**
+ * Create a callable HTML element builder.
+ * Returns a function that, when called with children/attrs, produces a new HtmlElement.
+ *
+ * Usage:
+ *   const div = htmlElement("div");
+ *   const el = div({ class: "card" }, "Hello");
+ *   console.log(el.toString());  // '<div class="card">Hello</div>'
+ */
+export declare function htmlElement(tag: string, attrs?: Attrs, children?: Child[]): {
+    (...args: (Child | Attrs | Child[])[]): /*elided*/ any;
+    tag: string;
+    attrs: Attrs;
+    children: Child[];
+    toString(): string;
+    _isHtmlElement: boolean;
+};
+/**
+ * Injects helper functions (_div, _p, _a, _span, etc.) into the target object.
+ *
+ * Usage:
+ *   const h: Record<string, any> = {};
+ *   addHtmlHelpers(h);
+ *   const html = h._div({ class: "card" }, h._p("Hello"));
+ */
+export declare function addHtmlHelpers(target: Record<string, unknown>): void;
+export {};

package/types/core/src/i18n.d.ts

@@ -0,0 +1,37 @@
+export declare class I18n {
+    private _localeDir;
+    private _defaultLocale;
+    private _currentLocale;
+    private _translations;
+    /**
+     * @param locale  Default locale code (e.g. "en"). Falls back to
+     *                TINA4_LOCALE, then "en".
+     * @param path    Directory holding the JSON/YAML locale files. Falls back to
+     *                TINA4_LOCALE_DIR, then "src/locales".
+     *
+     * Arg order is (locale, path) to match the Python master `I18n(locale, path)`
+     * (BUG-7, BREAKING in 3.13.x — was previously (localeDir, defaultLocale)).
+     */
+    constructor(locale?: string, path?: string);
+    setLocale(locale: string): void;
+    getLocale(): string;
+    /**
+     * Translate a key. Supports {placeholder} interpolation.
+     * Falls back to default locale, then returns the key itself.
+     */
+    t(key: string, params?: Record<string, string>, locale?: string): string;
+    /** Alias for t() */
+    translate(key: string, params?: Record<string, string>, locale?: string): string;
+    /** Load and return translations for a locale. */
+    loadTranslations(locale: string): Record<string, string>;
+    /** Add a single translation key/value to a locale (in-memory only). */
+    addTranslation(locale: string, key: string, value: string): void;
+    /** List available locale codes based on JSON files in the locale directory. */
+    availableLocales(): string[];
+    /** Load a locale file if not already loaded. */
+    private _loadLocale;
+    /** Flatten nested objects: {"a": {"b": "c"}} → {"a.b": "c"} */
+    /** Zero-dep YAML parser for simple key: value locale files. */
+    private static _parseSimpleYaml;
+    private static _flatten;
+}

package/types/core/src/index.d.ts

@@ -0,0 +1,92 @@
+export type { Tina4Request, Tina4Response, RouteHandler, RouteDefinition, RouteMeta, Tina4Config, Middleware, MiddlewareClass, MiddlewareSpec, UploadedFile, CookieOptions, WebSocketRouteHandler, WebSocketRouteDefinition, } from "./types.js";
+export { startServer, resolvePortAndHost, handle, start, stop, httpReason, resolveTemplate, resetTemplateCache, templateAutoRoutingEnabled, isBannerSuppressed } from "./server.js";
+export { background, stopAllBackgroundTasks, backgroundTaskCount } from "./background.js";
+export { Router, RouteGroup, RouteRef, WsRouteRef, defaultRouter, runRouteMiddlewares, resolveStringMiddleware, isTrailingSlashRedirectEnabled } from "./router.js";
+export { get, post, put, patch, del, any, websocket, del as delete } from "./router.js";
+export type { RouteInfo } from "./router.js";
+export { discoverRoutes } from "./routeDiscovery.js";
+export { MiddlewareChain, MiddlewareRunner, cors, requestLogger, CorsMiddleware, RateLimiterMiddleware, RequestLogger, SecurityHeadersMiddleware, CsrfMiddleware } from "./middleware.js";
+export type { CorsConfig } from "./middleware.js";
+export { createRequest, makeCaseInsensitiveHeaders } from "./request.js";
+export { createResponse, errorResponse, setDefaultTemplatesDir, getFrond, setFrond, getFrameworkFrond } from "./response.js";
+export { tryServeStatic } from "./static.js";
+export { loadEnv, getEnv, requireEnv, hasEnv, allEnv, resetEnv, isTruthy } from "./dotenv.js";
+export { Env } from "./env.js";
+export { Log } from "./logger.js";
+export { createHealthRoute, createHealthRoutes, healthPath } from "./health.js";
+export { rateLimiter } from "./rateLimiter.js";
+export { isTrustedProxy, trustedProxyNetworks, resolveClientIp, resetTrustedProxyCache } from "./trustedProxy.js";
+export type { RateLimiterConfig } from "./rateLimiter.js";
+export { HTTP_OK, HTTP_CREATED, HTTP_ACCEPTED, HTTP_NO_CONTENT, HTTP_MOVED, HTTP_REDIRECT, HTTP_NOT_MODIFIED, HTTP_BAD_REQUEST, HTTP_UNAUTHORIZED, HTTP_FORBIDDEN, HTTP_NOT_FOUND, HTTP_METHOD_NOT_ALLOWED, HTTP_CONFLICT, HTTP_GONE, HTTP_UNPROCESSABLE, HTTP_TOO_MANY, HTTP_SERVER_ERROR, HTTP_BAD_GATEWAY, HTTP_UNAVAILABLE, APPLICATION_JSON, APPLICATION_XML, APPLICATION_FORM, APPLICATION_OCTET, TEXT_HTML, TEXT_PLAIN, TEXT_CSV, TEXT_XML, } from "./constants.js";
+export { getToken, validToken, getPayload, hashPassword, checkPassword, authMiddleware, refreshToken, authenticateRequest, validateApiKey, ensureDevSecret, resolveAlgorithm, algorithmAvailable, availableAlgorithms, Auth, } from "./auth.js";
+export { Session, FileSessionHandler, RedisSessionHandler, buildSessionCookie, isSecureScheme, isValidSessionId, sessionCookieName, VALID_SESSION_BACKENDS, CANONICAL_SESSION_BACKENDS } from "./session.js";
+export type { SessionConfig, SessionHandler } from "./session.js";
+export { I18n } from "./i18n.js";
+export { FakeData } from "./fakeData.js";
+export { ScssCompiler } from "./scss.js";
+export type { ScssConfig } from "./scss.js";
+export { Queue } from "./queue.js";
+export type { QueueConfig, QueueJob, ProcessOptions } from "./queue.js";
+export { createJob } from "./job.js";
+export type { JobData, JobQueueBridge } from "./job.js";
+export { Mqtt, MqttError, MqttTimeoutError } from "./mqtt.js";
+export type { MqttOptions, ParsedMqttUrl } from "./mqtt.js";
+export { MqttMessage } from "./mqttMessage.js";
+export type { MqttAcknowledger } from "./mqttMessage.js";
+export { GraphQL, ParseError, graphqlEndpoint, graphqlAutoSchemaEnabled, graphqlMaxDepth } from "./graphql.js";
+export type { GraphQLField, ResolverFn, GraphQLResult } from "./graphql.js";
+export { WebSocketServer, devReloadWs, computeAcceptKey, parseUpgradeHeaders, buildFrame, parseFrame, originAllowed, wsToken, wsAuthorized, offeredBearerSubprotocol, serveWebSocketRoute, wsRouteManager, OP_TEXT, OP_BINARY, OP_CLOSE, OP_PING, OP_PONG, CLOSE_NORMAL, CLOSE_GOING_AWAY, CLOSE_PROTOCOL_ERROR, CLOSE_POLICY_VIOLATION, } from "./websocket.js";
+export type { WebSocketClient } from "./websocket.js";
+export { ServiceRunner, Tina4Service, matchCronField, matchesCron } from "./service.js";
+export type { ServiceOptions, ServiceContext, ServiceHandler, ServiceInfo } from "./service.js";
+export { responseCache, clearCache, cacheStats, cacheGet, cacheSet, cacheDelete, cacheClear, cacheBackendStats, sweep, createBackend, _resetBackend } from "./cache.js";
+export type { ResponseCacheConfig, CacheBackend } from "./cache.js";
+export { Api } from "./api.js";
+export type { ApiResult, ApiOptions, ApiTransport, DownloadResult, UploadOptions } from "./api.js";
+export { Context, defaultContext, existingContext, fts5Supported, _sharedContexts } from "./context/index.js";
+export type { SearchHit } from "./context/index.js";
+export { Events } from "./events.js";
+export { DevAdmin, MessageLog, RequestInspector, ErrorTracker, DevMailboxStore, DevQueue, WsTracker, supervisorBaseUrl, devAdminLanguage } from "./devAdmin.js";
+export { feedbackEnabled, feedbackWhitelist, feedbackIdentifyUser, feedbackIsWhitelisted, feedbackRateLimitOk, injectFeedbackWidget, handleFeedbackTurn, handleFeedbackWidgetJs, registerFeedbackRoutes, } from "./feedback.js";
+export { Messenger, MessengerConnectionError, createMessenger } from "./messenger.js";
+export type { SendResult, EmailMessage } from "./messenger.js";
+export { DevMailbox } from "./devMailbox.js";
+export { WSDLService, WSDLOperation } from "./wsdl.js";
+export type { WSDLOperationMeta } from "./wsdl.js";
+export { HtmlElement, htmlElement, addHtmlHelpers, Raw, SafeString } from "./htmlElement.js";
+export { renderErrorOverlay, renderProductionError, isDebugMode } from "./errorOverlay.js";
+export { AI_TOOLS, isInstalled, showMenu, installSelected, installAll, generateContext } from "./ai.js";
+export type { AiTool } from "./ai.js";
+export type { ImapMessage, ImapFullMessage } from "./messenger.js";
+export { LiteBackend } from "./queueBackends/liteBackend.js";
+export { RabbitMQBackend, parseAmqpUrl } from "./queueBackends/rabbitmqBackend.js";
+export type { RabbitMQConfig } from "./queueBackends/rabbitmqBackend.js";
+export { KafkaBackend, kafkaSecurityConfig } from "./queueBackends/kafkaBackend.js";
+export type { KafkaConfig, KafkaSecurityConfig, KafkaClientConfig, } from "./queueBackends/kafkaBackend.js";
+export { MongoBackend } from "./queueBackends/mongoBackend.js";
+export type { MongoConfig as MongoQueueConfig } from "./queueBackends/mongoBackend.js";
+export { DatabaseSessionHandler } from "./sessionHandlers/databaseHandler.js";
+export type { DatabaseSessionConfig } from "./sessionHandlers/databaseHandler.js";
+export { MongoSessionHandler } from "./sessionHandlers/mongoHandler.js";
+export type { MongoSessionConfig } from "./sessionHandlers/mongoHandler.js";
+export { ValkeySessionHandler } from "./sessionHandlers/valkeyHandler.js";
+export type { ValkeySessionConfig } from "./sessionHandlers/valkeyHandler.js";
+export { tests, assertEqual, assertRaises, assertTrue, assertFalse, runAll, reset } from "./testing.js";
+export { TestClient, TestResponse } from "./testClient.js";
+export { Tina4Test, AssertionError as Tina4AssertionError } from "./test.js";
+export type { TestRunResults } from "./test.js";
+export { Container, container } from "./container.js";
+export { Validator } from "./validator.js";
+export type { ValidationError } from "./validator.js";
+export type { WebSocketConnection } from "./websocketConnection.js";
+export { RedisBackplane, NATSBackplane, createBackplane, WsBackplaneManager, buildEnvelope, WS_BACKPLANE_CHANNEL, } from "./websocketBackplane.js";
+export type { WebSocketBackplane, WsEnvelope, WsEnvelopeKind, WsBackplaneLogger, } from "./websocketBackplane.js";
+export { McpServer, mcpTool, mcpResource, registerDevTools, getDefaultDevServer, encodeResponse, encodeError, encodeNotification, decodeRequest, schemaFromParams, isLocalhost, isLoopback, mcpEnabled, isRequestAllowed, mcpPort, PARSE_ERROR, INVALID_REQUEST, METHOD_NOT_FOUND, INVALID_PARAMS, INTERNAL_ERROR, } from "./mcp.js";
+export type { JsonRpcMessage, McpToolDefinition, McpResourceDefinition, JsonSchema, McpToolParam } from "./mcp.js";
+export { Plan } from "./plan.js";
+export type { PlanStep, ParsedPlan, PlanSummary, ExecutionSummary, CurrentPlan } from "./plan.js";
+export { ProjectIndex } from "./projectIndex.js";
+export type { FileEntry, FileRoute } from "./projectIndex.js";
+export { Docs } from "./docs.js";
+export type { DocsHit, ClassSpec, MethodSpec, IndexEntry, DriftHit } from "./docs.js";
+export { writeMcpDiscovery } from "./docsAutoDiscovery.js";

package/types/core/src/job.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Tina4 Queue Job — a single queue job with lifecycle methods.
+ */
+export interface JobData {
+    id: string;
+    payload: unknown;
+    status: "pending" | "reserved" | "failed" | "dead" | "completed";
+    createdAt: string;
+    attempts: number;
+    delayUntil: string | null;
+    priority: number;
+    topic: string;
+    error?: string;
+}
+export interface JobLifecycle {
+    /** Mark this job as completed. */
+    complete(): void;
+    /** Mark this job as failed with a reason. */
+    fail(reason?: string): void;
+    /** Reject this job with a reason. Alias for fail(). */
+    reject(reason?: string): void;
+    /** Re-queue this job with incremented attempts and optional delay. */
+    retry(delaySeconds?: number): void;
+    /** Return job fields as a flat array of values. */
+    toArray(): unknown[];
+    /** Return job as a plain object. */
+    toHash(): Record<string, unknown>;
+    /** Return job as a JSON string. */
+    toJson(): string;
+}
+export type QueueJob = JobData & JobLifecycle;
+export interface JobQueueBridge {
+    _failJob(topic: string, job: QueueJob, reason: string, maxRetries: number): void;
+    _retryJob(topic: string, job: QueueJob, delaySeconds?: number): void;
+    _completeJob(topic: string, job: QueueJob): void;
+    getMaxRetries(): number;
+}
+/** Create a QueueJob with lifecycle methods bound to a Queue instance. */
+export declare function createJob(data: JobData, queue: JobQueueBridge): QueueJob;