@onesi/genesis 0.0.1-stage → 0.2.0

package/dist/hives-platform.js

@@ -0,0 +1,183 @@
+import { GenesisError } from './errors.js';
+const bounded = (value, fallback, max, name) => {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) || value < 1 || value > max) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId: 'hives_stream_logs', message: `${name} must be an integer from 1 to ${max}.` });
+    }
+    return value;
+};
+function parseEvent(lines) {
+    let event = 'message';
+    let id;
+    const data = [];
+    for (const line of lines) {
+        if (!line || line.startsWith(':'))
+            continue; // SSE comments carry keepalives only.
+        const colon = line.indexOf(':');
+        const field = colon < 0 ? line : line.slice(0, colon);
+        let value = colon < 0 ? '' : line.slice(colon + 1);
+        if (value.startsWith(' '))
+            value = value.slice(1);
+        if (field === 'event')
+            event = value;
+        else if (field === 'id')
+            id = value;
+        else if (field === 'data')
+            data.push(value);
+    }
+    if (!data.length)
+        return undefined;
+    const text = data.join('\n');
+    let parsed = text;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch { /* non-JSON data such as heartbeat "ping" stays text */ }
+    return { event, ...(id === undefined ? {} : { id }), data: parsed };
+}
+/** Pull-based SSE reader. `cancel()` closes the connection even while a read is pending. */
+export function hivesSseReader(response) {
+    const reader = response.body?.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let lines = [];
+    let finished = !reader;
+    const take = () => {
+        let index;
+        while ((index = buffer.search(/\r\n|\r|\n/)) >= 0) {
+            const line = buffer.slice(0, index);
+            buffer = buffer.slice(index + (buffer.startsWith('\r\n', index) ? 2 : 1));
+            if (line !== '') {
+                lines.push(line);
+                continue;
+            }
+            const event = parseEvent(lines);
+            lines = [];
+            if (event)
+                return event;
+        }
+        return undefined;
+    };
+    return {
+        async next() {
+            for (;;) {
+                const ready = take();
+                if (ready)
+                    return ready;
+                if (finished) {
+                    const tail = parseEvent(buffer ? [...lines, buffer] : lines);
+                    buffer = '';
+                    lines = [];
+                    return tail;
+                }
+                const { done, value } = await reader.read();
+                if (done)
+                    finished = true;
+                else
+                    buffer += decoder.decode(value, { stream: true });
+            }
+        },
+        async cancel() { finished = true; await reader?.cancel().catch(() => { }); },
+    };
+}
+/** Yield SSE events until the caller stops iterating, the signal aborts or the server closes the stream. */
+export async function* hivesSseEvents(response) {
+    const sse = hivesSseReader(response);
+    try {
+        for (let event = await sse.next(); event; event = await sse.next())
+            yield event;
+    }
+    finally {
+        await sse.cancel();
+    }
+}
+/**
+ * Hives platform reads and actions the gateway already routes: project logs (query and live SSE), custom domains,
+ * the Hives identity, Hives fleets and remote sessions/SFTP.
+ */
+export function hivesPlatform(client) {
+    const open = async (project_id, q = {}, init = {}) => {
+        const res = await client.raw('hives_stream_logs', { ...q, project_id }, { signal: init.signal, headers: { accept: 'text/event-stream' } });
+        if (!(res.headers.get('content-type') ?? '').toLowerCase().startsWith('text/event-stream')) {
+            void res.body?.cancel().catch(() => { });
+            throw new GenesisError({ status: res.status, type: 'invalid_response', operationId: 'hives_stream_logs', message: 'Hives did not return a Server-Sent Events stream.',
+                requestId: res.headers.get('x-request-id') ?? undefined });
+        }
+        return res;
+    };
+    return {
+        logs: {
+            query: (project_id, q = {}) => client.request('hives_query_logs', { ...q, project_id }),
+            /** Live SSE events. Iterate and `break` (or abort the signal) to close the connection; it never ends on its own. */
+            stream: async function* (project_id, q = {}, init = {}) {
+                yield* hivesSseEvents(await open(project_id, q, init));
+            },
+            /** A bounded window of the live stream: the first `maxEvents` events or `seconds` of stream, whichever comes first. */
+            window: async (project_id, q = {}, options = {}) => {
+                const maxEvents = bounded(options.maxEvents, 100, 10_000, 'maxEvents');
+                const seconds = bounded(options.seconds, 10, 300, 'seconds');
+                const events = [];
+                // The window starts before the request, so a server that withholds headers cannot outlast it.
+                const deadline = new AbortController();
+                let timer;
+                const elapsed = new Promise((resolve) => { timer = setTimeout(() => { resolve('time'); deadline.abort(); }, seconds * 1000); });
+                const signal = options.signal ? AbortSignal.any([options.signal, deadline.signal]) : deadline.signal;
+                let sse;
+                try {
+                    const response = await Promise.race([open(project_id, q, { signal }), elapsed]);
+                    if (response === 'time')
+                        return { events, ended: 'time' };
+                    sse = hivesSseReader(response);
+                    for (;;) {
+                        const next = await Promise.race([sse.next(), elapsed]);
+                        if (next === 'time')
+                            return { events, ended: 'time' };
+                        if (!next)
+                            return { events, ended: 'closed' };
+                        events.push(next);
+                        if (events.length >= maxEvents)
+                            return { events, ended: 'max_events' };
+                    }
+                }
+                catch (error) {
+                    if (deadline.signal.aborted && !options.signal?.aborted)
+                        return { events, ended: 'time' };
+                    throw error;
+                }
+                finally {
+                    clearTimeout(timer);
+                    await sse?.cancel();
+                }
+            },
+        },
+        domains: {
+            list: (project_id, q = {}) => client.request('hives_list_domains', { ...q, project_id }),
+            add: (project_id, body) => client.request('hives_add_domain', { project_id, body }),
+            verify: (project_id, domain_id) => client.request('hives_verify_domain', { project_id, domain_id }),
+            provisionSsl: (project_id, domain_id) => client.request('hives_provision_ssl', { project_id, domain_id }),
+        },
+        auth: { me: () => client.request('hives_me') },
+        fleets: {
+            list: () => client.request('hives_list_fleets'),
+            deploy: (body) => client.request('hives_deploy_fleet', { body }),
+            status: (fleet_id) => client.request('hives_get_fleet_status', { fleet_id }),
+            teardown: (fleet_id) => client.request('hives_teardown_fleet', { fleet_id }),
+        },
+        remote: {
+            sessions: {
+                list: (project_id, q = {}) => client.request('hives_list_remote_sessions', { ...q, project_id }),
+                close: (project_id, session_id) => client.request('hives_close_remote_session', { project_id, session_id }),
+            },
+            ssh: (project_id, body) => client.request('hives_create_ssh_session', { project_id, body }),
+            terminal: (project_id, body) => client.request('hives_create_terminal_session', { project_id, body }),
+            debug: (project_id, body) => client.request('hives_create_debug_session', { project_id, body }),
+            sftp: {
+                list: (project_id, target_id, q = {}) => client.request('hives_sftp_list', { ...q, project_id, target_id }),
+                read: (project_id, target_id, path) => client.request('hives_sftp_read', { project_id, target_id, path }),
+                write: (project_id, target_id, body) => client.request('hives_sftp_write', { project_id, target_id, body }),
+                delete: (project_id, target_id, body) => client.request('hives_sftp_delete', { project_id, target_id, body }),
+            },
+        },
+    };
+}

package/dist/hives-queue-consumer.d.ts

@@ -0,0 +1,56 @@
+import type { GenesisClient } from './client.js';
+import { type HivesResourceOptions } from './hives-resources-transport.js';
+/** Every delivery setting must match the existing standard queue. */
+export interface HivesQueueConsumerConfig {
+    functionId: string;
+    queueName: string;
+    batchSize: 1;
+    maxConcurrent: 1;
+    visibilityTimeoutSecs: number;
+    maxRetries: number;
+    deadLetterQueue?: string | null;
+    autoAck: true;
+    enabled: boolean;
+}
+export interface HivesQueueConsumerBinding {
+    queueId: string;
+    projectId: string;
+    functionId: string;
+    enabled: boolean;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface HivesQueueConsumerAttempt {
+    id: string;
+    functionId: string;
+    consumerRevision: number;
+    messageId: string;
+    receiveCount: number;
+    status: 'running' | 'succeeded' | 'failed' | 'unconfirmed';
+    leaseExpiresAt: string;
+    startedAt: string;
+    completedAt: string | null;
+    executionId: string | null;
+    guestStatus: number | null;
+}
+export interface HivesQueueConsumerStatus {
+    consumer: {
+        binding: HivesQueueConsumerBinding | null;
+        latestAttempt: HivesQueueConsumerAttempt | null;
+        exhaustedMessages: number;
+    };
+    /** An operator setting, not evidence that an invocation succeeded. */
+    runtimeEnabled: boolean;
+    batchSize: 1;
+    maxConcurrent: 1;
+    autoAck: true;
+}
+export declare function hivesQueueConsumer(client: GenesisClient): {
+    get(project: string, queue: string, options?: HivesResourceOptions): Promise<HivesQueueConsumerStatus>;
+    configure(project: string, queue: string, input: HivesQueueConsumerConfig, options?: HivesResourceOptions): Promise<HivesQueueConsumerBinding>;
+    remove(project: string, queue: string, options?: HivesResourceOptions): Promise<{
+        success: true;
+        queueId: string;
+    }>;
+};

package/dist/hives-queue-consumer.js

@@ -0,0 +1,95 @@
+import { GenesisError } from './errors.js';
+import { hivesResourceCall, hivesResourceId, resourceError } from './hives-resources-transport.js';
+const badResponse = () => new GenesisError({ status: 0, type: 'invalid_response',
+    message: 'Hives returned an invalid or mismatched queue-consumer response. Read saved state before another mutation.' });
+function record(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw badResponse();
+    return value;
+}
+function id(value) {
+    if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value))
+        throw badResponse();
+    return value;
+}
+function integer(value, minimum) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < minimum)
+        throw badResponse();
+    return value;
+}
+function date(value) {
+    if (typeof value !== 'string' || !Number.isFinite(Date.parse(value)))
+        throw badResponse();
+    return value;
+}
+function binding(value, project, queue) {
+    const row = record(value);
+    if (row.queueId !== queue || row.projectId !== project || typeof row.enabled !== 'boolean')
+        throw badResponse();
+    return { queueId: queue, projectId: project, functionId: id(row.functionId), enabled: row.enabled,
+        revision: integer(row.revision, 1), createdAt: date(row.createdAt), updatedAt: date(row.updatedAt) };
+}
+function attempt(value) {
+    const row = record(value);
+    if (!['running', 'succeeded', 'failed', 'unconfirmed'].includes(row.status))
+        throw badResponse();
+    const confirmed = row.status === 'succeeded' || row.status === 'failed';
+    if (confirmed) {
+        if (typeof row.executionId !== 'string' || !/^exec_[a-f0-9]{32}$/.test(row.executionId)
+            || typeof row.guestStatus !== 'number' || !Number.isInteger(row.guestStatus)
+            || row.guestStatus < 200 || row.guestStatus > 599 || row.completedAt === null
+            || (row.status === 'succeeded') !== (row.guestStatus < 300))
+            throw badResponse();
+    }
+    else if (row.executionId !== null || row.guestStatus !== null || row.status === 'running' && row.completedAt !== null)
+        throw badResponse();
+    // History can belong to an earlier function/revision even after the binding is removed.
+    return { id: id(row.id), functionId: id(row.functionId), consumerRevision: integer(row.consumerRevision, 1),
+        messageId: id(row.messageId), receiveCount: integer(row.receiveCount, 1), status: row.status,
+        leaseExpiresAt: date(row.leaseExpiresAt), startedAt: date(row.startedAt),
+        completedAt: row.completedAt === null ? null : date(row.completedAt),
+        executionId: row.executionId, guestStatus: row.guestStatus };
+}
+function config(value) {
+    const allowed = ['functionId', 'queueName', 'batchSize', 'maxConcurrent', 'visibilityTimeoutSecs', 'maxRetries', 'deadLetterQueue', 'autoAck', 'enabled'];
+    if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(key => !allowed.includes(key))
+        || value.batchSize !== 1 || value.maxConcurrent !== 1 || value.autoAck !== true || typeof value.enabled !== 'boolean'
+        || !Number.isInteger(value.visibilityTimeoutSecs) || value.visibilityTimeoutSecs < 75 || value.visibilityTimeoutSecs > 4_294_967_295
+        || !Number.isInteger(value.maxRetries) || value.maxRetries < 0 || value.maxRetries > 9)
+        throw resourceError(0);
+    hivesResourceId(value.functionId);
+    hivesResourceId(value.queueName);
+    if (value.deadLetterQueue != null)
+        hivesResourceId(value.deadLetterQueue);
+    return { functionId: value.functionId, queueName: value.queueName, batchSize: 1, maxConcurrent: 1,
+        visibilityTimeoutSecs: value.visibilityTimeoutSecs, maxRetries: value.maxRetries,
+        deadLetterQueue: value.deadLetterQueue ?? null, autoAck: true, enabled: value.enabled };
+}
+export function hivesQueueConsumer(client) {
+    const params = (project, queue) => ({ project_id: hivesResourceId(project), queue_id: hivesResourceId(queue) });
+    const call = (operation, input, options) => hivesResourceCall(client, operation, input, options, 'json', 64 * 1024, 20_000, 200);
+    return {
+        async get(project, queue, options) {
+            const row = record(await call('hives_get_native_queue_consumer', params(project, queue), options));
+            const status = record(row.consumer);
+            if (typeof row.runtimeEnabled !== 'boolean' || row.batchSize !== 1 || row.maxConcurrent !== 1 || row.autoAck !== true)
+                throw badResponse();
+            return { consumer: { binding: status.binding === null ? null : binding(status.binding, project, queue),
+                    latestAttempt: status.latestAttempt === null ? null : attempt(status.latestAttempt), exhaustedMessages: integer(status.exhaustedMessages, 0) },
+                runtimeEnabled: row.runtimeEnabled, batchSize: 1, maxConcurrent: 1, autoAck: true };
+        },
+        async configure(project, queue, input, options) {
+            const body = config(input);
+            const result = binding(await call('hives_configure_native_queue_consumer', { ...params(project, queue), body }, options), project, queue);
+            if (result.functionId !== body.functionId || result.enabled !== body.enabled)
+                throw badResponse();
+            return result;
+        },
+        async remove(project, queue, options) {
+            const result = record(await call('hives_remove_native_queue_consumer', params(project, queue), options));
+            if (result.success !== true || result.queueId !== queue)
+                throw badResponse();
+            return { success: true, queueId: queue };
+        },
+    };
+}

package/dist/hives-queue-funding.d.ts

@@ -0,0 +1,28 @@
+import { GenesisError } from './errors.js';
+export interface HivesQueueSendOptions {
+    signal?: AbortSignal;
+    idempotencyKey?: string;
+}
+export interface HivesQueueOperation {
+    object: 'queue_send_operation';
+    operation_id: string;
+    state: 'prepared' | 'reserve_unknown' | 'reserved' | 'dispatch_unknown' | 'dispatch_authorized' | 'commit_unknown' | 'settle_unknown' | 'settled' | 'denied' | 'released';
+    code: string;
+    message_id: string | null;
+    funding_source: 'sandbox_allowance' | null;
+    reservation_id: string | null;
+    native_meter: 'hives.queue_operations';
+    quantity_base: string | null;
+    upper_bound_quantity_base: string;
+    retry_send: false;
+}
+export declare const isHivesQueueFundingOperation: (id: string) => id is "hives_send_native_queue" | "hives_get_operation_native_queue";
+export declare function hivesQueueOperationId(value: unknown): string;
+export declare function hivesQueueSendHeaders(options: HivesQueueSendOptions): Record<string, string>;
+export declare function hivesQueueOperation(value: unknown, expected: unknown): HivesQueueOperation;
+export declare class HivesQueueOperationError extends GenesisError {
+    readonly operation: HivesQueueOperation;
+    constructor(status: number, operation: HivesQueueOperation);
+}
+/** Only a bounded typed receipt is retained from an error; never an echoed message body. */
+export declare function hivesQueueOperationError(response: Response, expected?: unknown): Promise<HivesQueueOperationError | undefined>;

package/dist/hives-queue-funding.js

@@ -0,0 +1,81 @@
+import { GenesisError } from './errors.js';
+export const isHivesQueueFundingOperation = (id) => id === 'hives_send_native_queue' || id === 'hives_get_operation_native_queue';
+export function hivesQueueOperationId(value) {
+    if (typeof value !== 'string' || !/^qop_[0-9a-f]{12}7[0-9a-f]{3}[89ab][0-9a-f]{15}$/.test(value))
+        throw new Error('Use the original queue operation ID. No send was retried.');
+    return value;
+}
+export function hivesQueueSendHeaders(options) {
+    if (options.idempotencyKey === undefined)
+        return {};
+    if (typeof options.idempotencyKey !== 'string' || !/^[ -~]{1,128}$/.test(options.idempotencyKey))
+        throw new Error('Use one persisted queue Idempotency-Key of 1–128 printable ASCII bytes.');
+    return { 'idempotency-key': options.idempotencyKey };
+}
+export function hivesQueueOperation(value, expected) {
+    const operation = hivesQueueOperationId(expected), r = value;
+    const keys = ['object', 'operation_id', 'state', 'code', 'message_id', 'funding_source', 'reservation_id', 'native_meter', 'quantity_base', 'upper_bound_quantity_base', 'retry_send'];
+    if (!r || typeof r !== 'object' || Array.isArray(r) || Object.keys(r).length !== keys.length || keys.some(k => !Object.hasOwn(r, k))
+        || r.object !== 'queue_send_operation' || r.operation_id !== operation || r.retry_send !== false || r.native_meter !== 'hives.queue_operations'
+        || !['prepared', 'reserve_unknown', 'reserved', 'dispatch_unknown', 'dispatch_authorized', 'commit_unknown', 'settle_unknown', 'settled', 'denied', 'released'].includes(r.state)
+        || typeof r.code !== 'string' || !/^[a-z_]{1,80}$/.test(r.code)
+        || r.funding_source !== null && r.funding_source !== 'sandbox_allowance'
+        || r.reservation_id !== null && !/^gfr_[A-Za-z0-9_.:@-]{1,124}$/.test(r.reservation_id)
+        || r.message_id !== null && !/^msg_[0-9a-f]{12}7[0-9a-f]{3}[89ab][0-9a-f]{15}$/.test(r.message_id)
+        || typeof r.upper_bound_quantity_base !== 'string' || !/^[1-5]$/.test(r.upper_bound_quantity_base)
+        || r.quantity_base !== null && (typeof r.quantity_base !== 'string' || !/^[1-5]$/.test(r.quantity_base) || Number(r.quantity_base) > Number(r.upper_bound_quantity_base))
+        || r.quantity_base !== null && (!r.message_id || !r.reservation_id || !r.funding_source)
+        || r.state === 'settled' && (!r.quantity_base || !r.message_id || !r.reservation_id || !r.funding_source)) {
+        throw new Error('Queue operation receipt is invalid or mismatched. Retain its original identity; no send was retried.');
+    }
+    return Object.fromEntries(keys.map(k => [k, r[k]]));
+}
+export class HivesQueueOperationError extends GenesisError {
+    operation;
+    constructor(status, operation) {
+        super({ status, type: 'hives_queue_operation', message: 'Read the original queue operation. Do not retry the send with a new key.', body: operation });
+        this.operation = operation;
+    }
+}
+/** Only a bounded typed receipt is retained from an error; never an echoed message body. */
+export async function hivesQueueOperationError(response, expected) {
+    const id = response.headers.get('x-hives-operation-id');
+    try {
+        hivesQueueOperationId(id);
+        if (expected !== undefined && id !== hivesQueueOperationId(expected))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    if (!response.body || !response.headers.get('content-type')?.toLowerCase().includes('application/json'))
+        return undefined;
+    const reader = response.body.getReader(), chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            size += value.length;
+            if (size > 4096) {
+                await reader.cancel();
+                return undefined;
+            }
+            chunks.push(value);
+        }
+        const bytes = new Uint8Array(size);
+        let at = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, at);
+            at += chunk.length;
+        }
+        return new HivesQueueOperationError(response.status, hivesQueueOperation(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes)), id));
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/hives-queues.d.ts

@@ -0,0 +1,137 @@
+import { type HivesQueueOperation, type HivesQueueSendOptions } from './hives-queue-funding.js';
+import type { GenesisClient } from './client.js';
+import { type HivesResourceOptions } from './hives-resources-transport.js';
+export interface HivesQueueConfig {
+    retentionPeriod: number;
+    visibilityTimeout: number;
+    maxReceiveCount: number;
+    deadLetterQueueId?: string | null;
+}
+export interface HivesQueue extends HivesQueueConfig {
+    id: string;
+    projectId: string;
+    name: string;
+    type: 'standard' | 'dead_letter' | 'fifo';
+    status: 'active' | 'paused';
+    deliveryAvailable: boolean;
+    maxMessageSize: number;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+    messagesProcessing: number;
+    delayedMessages: number;
+    retainedMessages: number;
+    retainedPayloadBytes: number;
+    consumerCount: null;
+    throughputPerSecond: null;
+    avgProcessingTimeMs: null;
+}
+export interface HivesQueueCreate {
+    name: string;
+    type?: 'standard' | 'dead_letter' | 'fifo';
+    retentionPeriod?: number;
+    visibilityTimeout?: number;
+    maxReceiveCount?: number;
+    deadLetterQueueId?: string | null;
+}
+export interface HivesQueueSend {
+    body?: unknown;
+    body_base64?: string;
+    attributes?: Record<string, string>;
+    message_group_id?: string;
+    deduplication_id?: string;
+}
+export interface HivesQueueDelivery {
+    id: string;
+    body_base64: string;
+    attributes: Record<string, string>;
+    receive_count: number;
+    receipt_handle: string;
+    lease_expires_at: string;
+    created_at: string;
+    message_group_id?: string;
+    sequence_number?: number;
+}
+export interface HivesDeadLetter {
+    id: string;
+    queue_id: string;
+    original_queue_id: string | null;
+    original_message_id: string | null;
+    body_base64: string;
+    attributes: Record<string, string>;
+    receive_count: number;
+    reason: string | null;
+    moved_at: string | null;
+}
+export interface HivesDeadLetterStats {
+    total_messages: number;
+    oldest_message_at: string | null;
+    newest_message_at: string | null;
+    average_receive_count: number | null;
+    retained_payload_bytes: number;
+}
+export declare function hivesQueueBody(encoded: string): Uint8Array;
+export declare function hivesQueues(client: GenesisClient): {
+    consumer: {
+        get(project: string, queue: string, options?: HivesResourceOptions): Promise<import("./hives-queue-consumer.js").HivesQueueConsumerStatus>;
+        configure(project: string, queue: string, input: import("./hives-queue-consumer.js").HivesQueueConsumerConfig, options?: HivesResourceOptions): Promise<import("./hives-queue-consumer.js").HivesQueueConsumerBinding>;
+        remove(project: string, queue: string, options?: HivesResourceOptions): Promise<{
+            success: true;
+            queueId: string;
+        }>;
+    };
+    list(project: string, options?: HivesResourceOptions): Promise<{
+        data: HivesQueue[];
+        engine_available: true;
+    }>;
+    get(project: string, id: string, options?: HivesResourceOptions): Promise<HivesQueue>;
+    create(project: string, body: HivesQueueCreate, options?: HivesResourceOptions): Promise<HivesQueue>;
+    configure(project: string, id: string, body: HivesQueueConfig, options?: HivesResourceOptions): Promise<HivesQueue>;
+    remove(project: string, id: string, options?: HivesResourceOptions): Promise<{
+        deleted: true;
+    }>;
+    stats(project: string, id: string, options?: HivesResourceOptions): Promise<HivesQueue>;
+    consumers: (project: string, id: string, options?: HivesResourceOptions) => Promise<never>;
+    pause(project: string, id: string, options?: HivesResourceOptions): Promise<HivesQueue>;
+    resume(project: string, id: string, options?: HivesResourceOptions): Promise<HivesQueue>;
+    purge(project: string, id: string, options?: HivesResourceOptions): Promise<{
+        purged: number;
+    }>;
+    send(project: string, id: string, body: HivesQueueSend, options?: HivesQueueSendOptions): Promise<HivesQueueOperation | {
+        message_id: string;
+    }>;
+    operations: {
+        get(project: string, id: string, operationId: string, options?: HivesResourceOptions): Promise<HivesQueueOperation>;
+    };
+    receive(project: string, id: string, body?: {
+        maxMessages?: number;
+        waitSeconds?: number;
+    }, options?: HivesResourceOptions): Promise<{
+        messages: HivesQueueDelivery[];
+    }>;
+    ack: (project: string, id: string, message: string, receipt: string, options?: HivesResourceOptions) => Promise<{
+        acknowledged: boolean;
+        released: boolean;
+    }>;
+    nack: (project: string, id: string, message: string, receipt: string, options?: HivesResourceOptions) => Promise<{
+        acknowledged: boolean;
+        released: boolean;
+    }>;
+    deadLetters: (project: string, id: string, query?: {
+        limit?: number;
+        offset?: number;
+    }, options?: HivesResourceOptions) => Promise<{
+        messages: HivesDeadLetter[];
+    }>;
+    deadLetterStats: (project: string, id: string, options?: HivesResourceOptions) => Promise<HivesDeadLetterStats>;
+    replay(project: string, id: string, message: string, options?: HivesResourceOptions): Promise<{
+        message_id: string;
+        replayed: 1;
+    }>;
+    deleteDeadLetter(project: string, id: string, message: string, options?: HivesResourceOptions): Promise<{
+        deleted: true;
+    }>;
+    purgeDeadLetters(project: string, id: string, options?: HivesResourceOptions): Promise<{
+        purged: number;
+    }>;
+};