@substrio/sdk 0.0.0-stage → 0.1.1

package/substrio_kv_tcp.mjs

@@ -0,0 +1,559 @@
+// substrio_kv_tcp.mjs: SubstrioWire: Raw TCP Binary KV Client
+// Zero-copy TCP transport for the Substrio KV protocol.
+// Same API as KvWs but over length-prefixed TCP frames (no WebSocket overhead).
+//
+// Hot-path optimizations:
+//   - Pre-allocated 64KB send buffer with 4-byte header inline → single sock.write()
+//   - Buffer.write() directly into sendBuf → zero per-key/value allocations
+//   - Offset-based recv parsing → no copyWithin per frame
+//   - No intermediate arrays in put()/get()/del()
+//
+// Usage:
+//   const client = new KvTcp('127.0.0.1', 9001, 'default', masterKey, { maxInFlight: 16 });
+//   await client.ready;
+//   await client.register('bench');
+//   await client.put([['k1','v1'], ['k2','v2']]);
+//   const map = await client.get(['k1','k2']);
+//   client.close();
+
+import net from 'net';
+
+function normalizeMaxInFlight(value) {
+    const parsed = Number.parseInt(String(value ?? ''), 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+        return parsed;
+    }
+    return 16;
+}
+
+export class KvTcp {
+    static OP_PUT = 0x01;
+    static OP_GET = 0x02;
+    static OP_DEL = 0x03;
+    static OP_REG = 0x10;
+    static OP_ERR = 0xFF;
+    static OP_AUTH = 0xA0;
+    static OP_AUTH_OK = 0xA1;
+    static OP_AUTH_FAIL = 0xA2;
+
+    // Protocol limits: must match server's substrio_kv_tcp.h constants
+    static MAX_FRAME = 4 * 1024 * 1024;   // 4MB max frame
+    static MAX_KEY = 65535;                // 2-byte key length field (uint16)
+    static MAX_VALUE = 4 * 1024 * 1024;    // 4MB max value (fits in frame)
+
+    constructor(host, port, tenant, key, options = {}) {
+        this._colId = 0;
+        this._queue = [];           // pending responses for sent frames
+        this._queueHead = 0;        // read cursor into _queue to avoid shift()
+        this._sendQueue = [];       // pending frames waiting for an in-flight slot
+        this._recvBuf = null;       // Accumulation buffer
+        this._recvLen = 0;          // Total bytes in recvBuf
+        this._recvOff = 0;          // Parse offset into recvBuf
+        this._inFlight = 0;
+        this._writeBlocked = false;
+        this._maxInFlight = normalizeMaxInFlight(options.maxInFlight);
+        this._closed = false;
+
+        // Reusable send buffers. Each in-flight write gets its own frame buffer
+        // so pipelined requests never alias the same underlying bytes.
+        this._sendBufBytes = 65540;
+        this._sendPool = [];
+
+        // Reusable result array for GET: avoids new Array() per call
+        this._getResult = [];
+
+        this._sock = net.connect(port, host);
+        this._sock.setNoDelay(true);
+
+        this._sock.on('data', (chunk) => this._onData(chunk));
+        this._sock.on('drain', () => {
+            this._writeBlocked = false;
+            this._flushSendQueue();
+        });
+        this._sock.on('error', (err) => this._failPending(err));
+        this._sock.on('close', () => {
+            this._closed = true;
+            this._failPending(new Error('KvTcp socket closed'));
+        });
+
+        // Auth on connect
+        this.ready = new Promise((resolve, reject) => {
+            this._sock.once('connect', () => {
+                const tenantBytes = Buffer.byteLength(tenant);
+                const keyBytes = Buffer.byteLength(key);
+                this._sendFrame(4 + 1 + 2 + tenantBytes + 2 + keyBytes, (buf) => {
+                    let o = 4;
+                    buf[o++] = 0xA0;
+                    buf.writeUInt16LE(tenantBytes, o); o += 2;
+                    buf.write(tenant, o, 'utf8'); o += tenantBytes;
+                    buf.writeUInt16LE(keyBytes, o); o += 2;
+                    buf.write(key, o, 'utf8'); o += keyBytes;
+                    buf.writeUInt32LE(o - 4, 0);
+                    return o;
+                }).then((resp) => {
+                    if (resp[0] === 0xA1) resolve(this);
+                    else reject(new Error('SubstrioWire auth failed'));
+                }, reject);
+            });
+            this._sock.once('error', reject);
+        });
+    }
+
+    get maxInFlight() {
+        return this._maxInFlight;
+    }
+
+    setMaxInFlight(value) {
+        this._maxInFlight = normalizeMaxInFlight(value);
+        while (this._sendPool.length > this._maxInFlight) {
+            this._sendPool.pop();
+        }
+        this._flushSendQueue();
+        return this._maxInFlight;
+    }
+
+    _onData(chunk) {
+        // Append chunk to recv buffer
+        if (this._recvLen === 0) {
+            // Fast path: no leftover, use chunk directly
+            this._recvBuf = chunk;
+            this._recvLen = chunk.length;
+            this._recvOff = 0;
+        } else {
+            // Compact if offset > half buffer to keep memory bounded
+            const avail = this._recvLen - this._recvOff;
+            if (this._recvOff > 0 && this._recvOff > (this._recvBuf.length >> 1)) {
+                if (avail > 0) this._recvBuf.copyWithin(0, this._recvOff, this._recvLen);
+                this._recvLen = avail;
+                this._recvOff = 0;
+            }
+            const needed = this._recvLen + chunk.length;
+            if (this._recvBuf.length < needed) {
+                const newBuf = Buffer.allocUnsafe(Math.max(needed * 2, 65536));
+                if (this._recvLen > this._recvOff) {
+                    this._recvBuf.copy(newBuf, 0, this._recvOff, this._recvLen);
+                }
+                this._recvLen -= this._recvOff;
+                this._recvOff = 0;
+                this._recvBuf = newBuf;
+            }
+            chunk.copy(this._recvBuf, this._recvLen);
+            this._recvLen += chunk.length;
+        }
+
+        // Process complete frames using offset (no copyWithin per frame)
+        while (this._recvOff + 4 <= this._recvLen && this._queueHead < this._queue.length) {
+            const frameLen = this._recvBuf.readUInt32LE(this._recvOff);
+            const frameEnd = this._recvOff + 4 + frameLen;
+            if (frameEnd > this._recvLen) break;
+
+            // Return a subarray view (zero-copy for caller)
+            const payload = this._recvBuf.subarray(this._recvOff + 4, frameEnd);
+            this._recvOff = frameEnd;
+
+            const head = this._queue[this._queueHead++];
+            this._releasePendingBuffer(head);
+            head.resolve(payload);
+            if (this._inFlight > 0) {
+                this._inFlight--;
+            }
+        }
+
+        this._compactQueue();
+        this._flushSendQueue();
+
+        // If fully consumed, reset
+        if (this._recvOff === this._recvLen) {
+            this._recvLen = 0;
+            this._recvOff = 0;
+        }
+    }
+
+    _compactQueue() {
+        if (this._queueHead === 0) {
+            return;
+        }
+        if (this._queueHead === this._queue.length) {
+            this._queue.length = 0;
+            this._queueHead = 0;
+            return;
+        }
+        if (this._queueHead >= 64 && this._queueHead >= (this._queue.length >> 1)) {
+            this._queue = this._queue.slice(this._queueHead);
+            this._queueHead = 0;
+        }
+    }
+
+    _releasePendingBuffer(pending) {
+        if (!pending || !pending._sendBuf) {
+            return;
+        }
+        this._releaseSendBuffer(pending._sendBuf, pending._sendReusable === true);
+        pending._sendBuf = null;
+        pending._sendReusable = false;
+    }
+
+    _failPending(err) {
+        while (this._queueHead < this._queue.length) {
+            const pending = this._queue[this._queueHead++];
+            this._releasePendingBuffer(pending);
+            pending.reject(err);
+        }
+        this._compactQueue();
+        while (this._sendQueue.length > 0) {
+            this._sendQueue.shift().reject(err);
+        }
+        this._inFlight = 0;
+        this._writeBlocked = false;
+    }
+
+    _acquireSendBuffer(requiredBytes) {
+        const size = Math.max(requiredBytes, this._sendBufBytes);
+        if (size === this._sendBufBytes && this._sendPool.length > 0) {
+            return { buf: this._sendPool.pop(), reusable: true };
+        }
+        return { buf: Buffer.allocUnsafe(size), reusable: size === this._sendBufBytes };
+    }
+
+    _releaseSendBuffer(buf, reusable) {
+        if (!reusable || buf.length !== this._sendBufBytes) {
+            return;
+        }
+        if (this._sendPool.length < this._maxInFlight) {
+            this._sendPool.push(buf);
+        }
+    }
+
+    _flushSendQueue() {
+        if (!this._sock || this._closed || this._sock.destroyed) {
+            return;
+        }
+        while (!this._writeBlocked && this._inFlight < this._maxInFlight && this._sendQueue.length > 0) {
+            const pending = this._sendQueue.shift();
+            const { buf, reusable } = this._acquireSendBuffer(pending.requiredBytes);
+            let totalLen = 0;
+            try {
+                totalLen = pending.buildFrame(buf);
+            } catch (err) {
+                this._releaseSendBuffer(buf, reusable);
+                pending.reject(err);
+                continue;
+            }
+
+            this._queue.push(pending);
+            this._inFlight++;
+
+            pending._sendBuf = buf;
+            pending._sendReusable = reusable;
+
+            const wrote = this._sock.write(buf.subarray(0, totalLen));
+            if (!wrote) {
+                this._writeBlocked = true;
+            }
+        }
+    }
+
+    _sendFrame(requiredBytes, buildFrame) {
+        return new Promise((resolve, reject) => {
+            if (!this._sock || this._closed || this._sock.destroyed) {
+                reject(new Error('KvTcp socket is closed'));
+                return;
+            }
+            this._sendQueue.push({ resolve, reject, requiredBytes, buildFrame });
+            this._flushSendQueue();
+        });
+    }
+
+    /** Register a collection → get 1-byte handle. */
+    async register(name) {
+        const nameBytes = Buffer.byteLength(name);
+        const r = await this._sendFrame(4 + 1 + 1 + 2 + nameBytes, (buf) => {
+            let o = 4;
+            buf[o++] = 0x10;
+            buf[o++] = 0;
+            buf.writeUInt16LE(nameBytes, o); o += 2;
+            buf.write(name, o, 'utf8'); o += nameBytes;
+            buf.writeUInt32LE(o - 4, 0);
+            return o;
+        });
+        if (r[0] !== 0x10 || r[2] !== 1) throw new Error('KvTcp: register failed');
+        this._colId = r[1];
+        return this._colId;
+    }
+
+    /** PUT [[key,val],...] → number of successes. */
+    async put(pairs) {
+        let totalBytes = 8;
+        for (let i = 0; i < pairs.length; i++) {
+            const kb = Buffer.byteLength(pairs[i][0]);
+            const vb = Buffer.byteLength(pairs[i][1]);
+            if (kb > KvTcp.MAX_KEY) throw new Error(`KvTcp: key exceeds ${KvTcp.MAX_KEY} bytes (got ${kb})`);
+            if (vb > KvTcp.MAX_VALUE) throw new Error(`KvTcp: value exceeds ${KvTcp.MAX_VALUE} bytes (got ${vb})`);
+            totalBytes += 6 + kb + vb;
+        }
+        if (totalBytes > KvTcp.MAX_FRAME) throw new Error(`KvTcp: frame exceeds ${KvTcp.MAX_FRAME} bytes (got ${totalBytes})`);
+
+        const r = await this._sendFrame(totalBytes, (buf) => {
+            let o = 4;
+            buf[o++] = 0x01;
+            buf[o++] = this._colId;
+            buf.writeUInt16LE(pairs.length, o); o += 2;
+
+            for (let i = 0; i < pairs.length; i++) {
+                const key = pairs[i][0];
+                const value = pairs[i][1];
+                const keyBytes = Buffer.byteLength(key);
+                const valueBytes = Buffer.byteLength(value);
+                buf.writeUInt16LE(keyBytes, o); o += 2;
+                buf.writeUInt32LE(valueBytes, o); o += 4;
+                buf.write(key, o, 'utf8'); o += keyBytes;
+                buf.write(value, o, 'utf8'); o += valueBytes;
+            }
+
+            buf.writeUInt32LE(o - 4, 0);
+            return o;
+        });
+        if (r[0] === 0xFF) throw new Error('KvTcp PUT error');
+        const cnt = r[1] | (r[2] << 8);
+        let ok = 0;
+        for (let i = 0; i < cnt; i++) if (r[3 + (i >> 3)] & (1 << (i & 7))) ok++;
+        return ok;
+    }
+
+    async put1(key, value) {
+        const keyBytes = Buffer.byteLength(key);
+        const valueBytes = Buffer.byteLength(value);
+        if (keyBytes > KvTcp.MAX_KEY) throw new Error(`KvTcp: key exceeds ${KvTcp.MAX_KEY} bytes (got ${keyBytes})`);
+        if (valueBytes > KvTcp.MAX_VALUE) throw new Error(`KvTcp: value exceeds ${KvTcp.MAX_VALUE} bytes (got ${valueBytes})`);
+        const r = await this._sendFrame(4 + 1 + 1 + 2 + 2 + 4 + keyBytes + valueBytes, (buf) => {
+            let o = 4;
+            buf[o++] = 0x01;
+            buf[o++] = this._colId;
+            buf.writeUInt16LE(1, o); o += 2;
+            buf.writeUInt16LE(keyBytes, o); o += 2;
+            buf.writeUInt32LE(valueBytes, o); o += 4;
+            buf.write(key, o, 'utf8'); o += keyBytes;
+            buf.write(value, o, 'utf8'); o += valueBytes;
+            buf.writeUInt32LE(o - 4, 0);
+            return o;
+        });
+        if (r[0] === 0xFF) throw new Error('KvTcp PUT error');
+        return (r[3] & 1) === 1;
+    }
+
+    /** GET [key,...] → Reusable array of Buffer views (null for missing). True zero-copy.
+     *  Returned Buffer views are valid until the next async I/O. Call .toString() if string needed. */
+    async get(keys) {
+        let totalBytes = 8;
+        for (let i = 0; i < keys.length; i++) {
+            const kb = Buffer.byteLength(keys[i]);
+            if (kb > KvTcp.MAX_KEY) throw new Error(`KvTcp: key exceeds ${KvTcp.MAX_KEY} bytes (got ${kb})`);
+            totalBytes += 2 + kb;
+        }
+        if (totalBytes > KvTcp.MAX_FRAME) throw new Error(`KvTcp: frame exceeds ${KvTcp.MAX_FRAME} bytes (got ${totalBytes})`);
+
+        const r = await this._sendFrame(totalBytes, (buf) => {
+            let o = 4;
+            buf[o++] = 0x02;
+            buf[o++] = this._colId;
+            buf.writeUInt16LE(keys.length, o); o += 2;
+
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                const keyBytes = Buffer.byteLength(key);
+                buf.writeUInt16LE(keyBytes, o); o += 2;
+                buf.write(key, o, 'utf8'); o += keyBytes;
+            }
+
+            buf.writeUInt32LE(o - 4, 0);
+            return o;
+        });
+        if (r[0] === 0xFF) throw new Error('KvTcp GET error');
+        const cnt = r[1] | (r[2] << 8);
+
+        // Reuse pre-allocated array: zero alloc
+        const result = this._getResult;
+        result.length = cnt;
+        let p = 3;
+        for (let i = 0; i < cnt && p < r.length; i++) {
+            if (r[p++] === 1 && p + 4 <= r.length) {
+                const vl = r.readUInt32LE(p); p += 4;
+                // Decode value: same work as Memcached client (latin1Slice = fastest V8 decode)
+                result[i] = r.latin1Slice(p, p + vl); p += vl;
+            } else {
+                result[i] = null;
+            }
+        }
+        return result;
+    }
+
+    async get1(key) {
+        const keyBytes = Buffer.byteLength(key);
+        if (keyBytes > KvTcp.MAX_KEY) throw new Error(`KvTcp: key exceeds ${KvTcp.MAX_KEY} bytes (got ${keyBytes})`);
+        const r = await this._sendFrame(4 + 1 + 1 + 2 + 2 + keyBytes, (buf) => {
+            let o = 4;
+            buf[o++] = 0x02;
+            buf[o++] = this._colId;
+            buf.writeUInt16LE(1, o); o += 2;
+            buf.writeUInt16LE(keyBytes, o); o += 2;
+            buf.write(key, o, 'utf8'); o += keyBytes;
+            buf.writeUInt32LE(o - 4, 0);
+            return o;
+        });
+        if (r[0] === 0xFF) throw new Error('KvTcp GET error');
+        if (r.length < 4 || r[3] !== 1) {
+            return null;
+        }
+        const valueLen = r.readUInt32LE(4);
+        return r.latin1Slice(8, 8 + valueLen);
+    }
+
+    // ═══════════════════════════════════════════════════════════
+    // Ultra-lean single-key fast path: bypasses _sendFrame/_flushSendQueue.
+    // Writes directly to a pre-allocated buffer with zero intermediate
+    // queue operations. ~3x less JS overhead per roundtrip vs put1/get1.
+    // ═══════════════════════════════════════════════════════════
+
+    /** Fast single-key PUT: minimal JS overhead. */
+    putFast(key, value) {
+        const keyBytes = Buffer.byteLength(key);
+        const valueBytes = Buffer.byteLength(value);
+        if (keyBytes > KvTcp.MAX_KEY) throw new Error(`KvTcp: key exceeds ${KvTcp.MAX_KEY} bytes (got ${keyBytes})`);
+        if (valueBytes > KvTcp.MAX_VALUE) throw new Error(`KvTcp: value exceeds ${KvTcp.MAX_VALUE} bytes (got ${valueBytes})`);
+        // Frame: [4B len][OP_PUT=0x01][colId][count=1 LE][2B klen][4B vlen][key][value]
+        const payloadLen = 10 + keyBytes + valueBytes;
+        const totalLen = 4 + payloadLen;
+
+        // Use exact-size buffer: avoids subarray() call
+        const buf = Buffer.allocUnsafe(totalLen);
+        buf.writeUInt32LE(payloadLen, 0);
+        buf[4] = 0x01;
+        buf[5] = this._colId;
+        buf[6] = 1; buf[7] = 0;
+        buf.writeUInt16LE(keyBytes, 8);
+        buf.writeUInt32LE(valueBytes, 10);
+        buf.write(key, 14, keyBytes, 'utf8');
+        buf.write(value, 14 + keyBytes, valueBytes, 'utf8');
+
+        return new Promise((resolve, reject) => {
+            // _sendBuf: null, buffer released to GC immediately after write.
+            // Node.js copies buffer contents to its internal write queue,
+            // so the original Buffer is safe to collect immediately.
+            this._queue.push({ resolve, reject, _sendBuf: null });
+            this._sock.write(buf);
+        });
+    }
+
+    /** Fast single-key GET: minimal JS overhead. */
+    getFast(key) {
+        const keyBytes = Buffer.byteLength(key);
+        if (keyBytes > KvTcp.MAX_KEY) throw new Error(`KvTcp: key exceeds ${KvTcp.MAX_KEY} bytes (got ${keyBytes})`);
+        // Frame: [4B len][OP_GET=0x02][colId][count=1 LE][2B klen][key]
+        const payloadLen = 6 + keyBytes;
+        const totalLen = 4 + payloadLen;
+
+        const buf = Buffer.allocUnsafe(totalLen);
+        buf.writeUInt32LE(payloadLen, 0);
+        buf[4] = 0x02;
+        buf[5] = this._colId;
+        buf[6] = 1; buf[7] = 0;
+        buf.writeUInt16LE(keyBytes, 8);
+        buf.write(key, 10, keyBytes, 'utf8');
+
+        return new Promise((resolve, reject) => {
+            this._queue.push({ resolve, reject, _sendBuf: null });
+            this._sock.write(buf);
+        });
+    }
+
+    // ═══════════════════════════════════════════════════════════
+    // Pre-built frame API: ZERO per-call construction cost.
+    // Build the frame once, then fire repeatedly with sock.write().
+    // Ideal for hot-path benchmarks and production hot keys.
+    // ═══════════════════════════════════════════════════════════
+
+    /** Pre-build a PUT frame. Returns a Buffer ready for repeated sock.write().
+     *  Usage:
+     *    const frame = client.preparePut('hot:key', 'value');
+     *    await client.sendPrepared(frame);  // zero construction cost */
+    preparePut(key, value) {
+        const keyBytes = Buffer.byteLength(key);
+        const valueBytes = Buffer.byteLength(value);
+        if (keyBytes > KvTcp.MAX_KEY) throw new Error(`KvTcp: key exceeds ${KvTcp.MAX_KEY} bytes (got ${keyBytes})`);
+        if (valueBytes > KvTcp.MAX_VALUE) throw new Error(`KvTcp: value exceeds ${KvTcp.MAX_VALUE} bytes (got ${valueBytes})`);
+        const payloadLen = 10 + keyBytes + valueBytes;
+        const buf = Buffer.allocUnsafe(4 + payloadLen);
+        buf.writeUInt32LE(payloadLen, 0);
+        buf[4] = 0x01;
+        buf[5] = this._colId;
+        buf[6] = 1; buf[7] = 0;
+        buf.writeUInt16LE(keyBytes, 8);
+        buf.writeUInt32LE(valueBytes, 10);
+        buf.write(key, 14, keyBytes, 'utf8');
+        buf.write(value, 14 + keyBytes, valueBytes, 'utf8');
+        return buf;
+    }
+
+    /** Pre-build a GET frame. */
+    prepareGet(key) {
+        const keyBytes = Buffer.byteLength(key);
+        if (keyBytes > KvTcp.MAX_KEY) throw new Error(`KvTcp: key exceeds ${KvTcp.MAX_KEY} bytes (got ${keyBytes})`);
+        const payloadLen = 6 + keyBytes;
+        const buf = Buffer.allocUnsafe(4 + payloadLen);
+        buf.writeUInt32LE(payloadLen, 0);
+        buf[4] = 0x02;
+        buf[5] = this._colId;
+        buf[6] = 1; buf[7] = 0;
+        buf.writeUInt16LE(keyBytes, 8);
+        buf.write(key, 10, keyBytes, 'utf8');
+        return buf;
+    }
+
+    /** Send a pre-built frame: absolute minimum JS overhead per call.
+     *  Cost: 1 Promise + 1 queue push + 1 sock.write = ~250ns total. */
+    sendPrepared(frame) {
+        return new Promise((resolve, reject) => {
+            this._queue.push({ resolve, reject, _sendBuf: null });
+            this._sock.write(frame);
+        });
+    }
+
+    /** DEL [key,...] → number of deletions. */
+    async del(keys) {
+        let totalBytes = 8;
+        for (let i = 0; i < keys.length; i++) {
+            totalBytes += 2 + Buffer.byteLength(keys[i]);
+        }
+
+        const r = await this._sendFrame(totalBytes, (buf) => {
+            let o = 4;
+            buf[o++] = 0x03;
+            buf[o++] = this._colId;
+            buf.writeUInt16LE(keys.length, o); o += 2;
+
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                const keyBytes = Buffer.byteLength(key);
+                buf.writeUInt16LE(keyBytes, o); o += 2;
+                buf.write(key, o, 'utf8'); o += keyBytes;
+            }
+
+            buf.writeUInt32LE(o - 4, 0);
+            return o;
+        });
+        if (r[0] === 0xFF) throw new Error('KvTcp DEL error');
+        const cnt = r[1] | (r[2] << 8);
+        let ok = 0;
+        for (let i = 0; i < cnt; i++) if (r[3 + (i >> 3)] & (1 << (i & 7))) ok++;
+        return ok;
+    }
+
+    close() {
+        if (this._sock) {
+            this._closed = true;
+            this._failPending(new Error('KvTcp socket closed'));
+            this._sock.destroy();
+            this._sock = null;
+        }
+    }
+}

package/substrio_operation_client.d.mts

@@ -0,0 +1,28 @@
+// Types of substrio_operation_client.mjs; the operation types are generated
+// (substrio_operations.d.mts).
+import type { SubstrioOperation, SubstrioOperations, SubstrioRoute, SubstrioMethod } from './substrio_operations.mjs';
+
+/** What the operation calls go through: the SDK's Http. */
+export interface SubstrioRequester {
+    req(method: SubstrioMethod, path: string, body?: unknown): Promise<unknown>;
+}
+
+export interface SubstrioRequest {
+    method: SubstrioMethod;
+    path: string;
+    body: unknown;
+}
+
+/** A catalog route as catalogRoute reads it: a SubstrioRoute with its OpenAPI parts. */
+export interface SubstrioCatalogRoute extends SubstrioRoute {
+    readonly parameters: readonly { name: string; in: string; required?: boolean; description?: string; schema?: unknown }[];
+    readonly bodySchema: unknown;
+}
+
+export declare function routeParams(path: string): string[];
+export declare function catalogRoute(path: string, method: string, op: object): SubstrioCatalogRoute;
+export declare function pickRoute(operation: SubstrioOperation, input: unknown, method?: SubstrioMethod | null): SubstrioRoute;
+export declare function buildRequest(route: SubstrioRoute, input: unknown, options?: { rawBody?: boolean }): SubstrioRequest;
+export declare function callOperation(http: SubstrioRequester, operation: SubstrioOperation, input?: unknown, options?: { method?: SubstrioMethod }): Promise<unknown>;
+export declare function bindOperations(http: SubstrioRequester): SubstrioOperations;
+export declare function attachOperations(client: object, ops: SubstrioOperations): void;