@synapseone/sdk 0.0.0-stage → 0.7.0-dev.43

package/dist/client.test.js

@@ -0,0 +1,292 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * Offline SDK tests — local echo server, no platform needed.
+ */
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_http_1 = __importDefault(require("node:http"));
+const index_1 = require("./index");
+let base = '';
+let lastHeaders = {};
+let lastPath = '';
+let lastMethod = '';
+let lastBody = '';
+let server;
+(0, node_test_1.before)(() => new Promise((resolve) => {
+    server = node_http_1.default
+        .createServer((req, res) => {
+        lastHeaders = { ...req.headers };
+        lastPath = req.url || '';
+        lastMethod = req.method || '';
+        let body = '';
+        req.on('data', (c) => (body += c));
+        req.on('end', () => {
+            lastBody = body;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ ok: true, path: req.url }));
+        });
+    })
+        .listen(0, '127.0.0.1', () => {
+        const a = server.address();
+        base = `http://127.0.0.1:${typeof a === 'object' && a ? a.port : 0}`;
+        resolve();
+    });
+}));
+(0, node_test_1.after)(() => new Promise((resolve) => server.close(() => resolve())));
+(0, node_test_1.describe)('SynapseOneClient', () => {
+    (0, node_test_1.it)('keeps the SynapseDX alias identical during the rebrand window', () => {
+        strict_1.default.equal(index_1.SynapseDXClient, index_1.SynapseOneClient);
+        strict_1.default.equal(index_1.SynapseDXError, index_1.SynapseOneError);
+    });
+    (0, node_test_1.it)('trims trailing slash', () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: 'http://x:8080/' });
+        strict_1.default.equal(c.baseUrl, 'http://x:8080');
+    });
+    (0, node_test_1.it)('sends Bearer token', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        c.setToken('tok123');
+        await c.listOrgs();
+        strict_1.default.equal(lastHeaders['authorization'], 'Bearer tok123');
+        strict_1.default.equal(lastPath, '/v1/orgs');
+    });
+    (0, node_test_1.it)('sends X-API-Key', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base, apiKey: 'k1' });
+        await c.listTemplates();
+        strict_1.default.equal(lastHeaders['x-api-key'], 'k1');
+    });
+    (0, node_test_1.it)('throws rich error on non-2xx', async () => {
+        const bad = new index_1.SynapseOneClient({ baseUrl: 'http://127.0.0.1:1' });
+        await strict_1.default.rejects(() => bad.listOrgs(), /synapseone/);
+    });
+    (0, node_test_1.it)('encodes ids in paths', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.getWorkflow('a/b');
+        strict_1.default.equal(lastPath, '/v1/workflows/a%2Fb');
+    });
+    (0, node_test_1.it)('covers new endpoints', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.userPolicies('u1');
+        strict_1.default.equal(lastPath, '/v1/users/u1/policies');
+        await c.getTemplate('webhook-to-log');
+        strict_1.default.equal(lastPath, '/v1/templates/webhook-to-log');
+        await c.listExecutions('limit=5');
+        strict_1.default.equal(lastPath, '/v1/executions?limit=5');
+        await c.executeWorkflow('w1', {});
+        strict_1.default.equal(lastPath, '/v1/workflows/w1/execute');
+        await c.updateWorkflow('w1', { name: 'renamed' });
+        strict_1.default.equal(lastPath, '/v1/workflows/w1');
+        await c.deleteWorkflow('w1');
+        strict_1.default.equal(lastPath, '/v1/workflows/w1');
+        await c.detachPolicy('r1', 'p1');
+        strict_1.default.equal(lastPath, '/v1/roles/r1/policies/p1');
+        await c.rolePolicies('r1');
+        strict_1.default.equal(lastPath, '/v1/roles/r1/policies');
+        await c.unassignRole('u1', 'r1');
+        strict_1.default.equal(lastPath, '/v1/users/u1/roles/r1');
+        await c.userRoles('u1');
+        strict_1.default.equal(lastPath, '/v1/users/u1/roles');
+        await c.listApiKeys('a1');
+        strict_1.default.equal(lastPath, '/v1/accounts/a1/keys');
+        await c.verifyApiKey('k');
+        strict_1.default.equal(lastPath, '/v1/keys/verify');
+        await c.deactivateWorkflow('w1');
+        strict_1.default.equal(lastPath, '/v1/workflows/w1/deactivate');
+    });
+    (0, node_test_1.it)('serviceAccountToken omits scopes unless explicitly given', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.serviceAccountToken('sa1');
+        strict_1.default.equal(lastPath, '/v1/service-accounts/sa1/token');
+        strict_1.default.deepEqual(JSON.parse(lastBody), {});
+        await c.serviceAccountToken('sa1', ['workflow:Execute']);
+        strict_1.default.deepEqual(JSON.parse(lastBody), { scopes: ['workflow:Execute'] });
+        await c.serviceAccountToken('sa1', []);
+        strict_1.default.deepEqual(JSON.parse(lastBody), { scopes: [] });
+    });
+    (0, node_test_1.it)('testRun posts definition+input', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        const def = { nodes: [], connections: {} };
+        await c.testRun(def, { value: 21 });
+        strict_1.default.equal(lastPath, '/v1/workflows/test-run');
+        strict_1.default.equal(lastMethod, 'POST');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { definition: def, input: { value: 21 } });
+    });
+    (0, node_test_1.it)('listExecutions accepts the allowlisted dict form', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.listExecutions({ workflowId: 'w1', status: 'error', limit: 20, offset: 0, includeData: true });
+        strict_1.default.ok(lastPath.startsWith('/v1/executions?'), lastPath);
+        strict_1.default.ok(lastPath.includes('workflowId=w1'), lastPath);
+        strict_1.default.ok(lastPath.includes('status=error'), lastPath);
+        strict_1.default.ok(lastPath.includes('limit=20'), lastPath);
+        strict_1.default.ok(lastPath.includes('includeData=true'), lastPath);
+    });
+    (0, node_test_1.it)('getExecution supports includeData', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.getExecution('e1', true);
+        strict_1.default.equal(lastPath, '/v1/executions/e1?includeData=true');
+    });
+    (0, node_test_1.it)('iam usageSummary and usageEvents hit the right endpoints', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.iam.usageSummary({ feature: 'workflows' });
+        strict_1.default.equal(lastPath, '/v1/usage/summary?feature=workflows');
+        strict_1.default.equal(lastMethod, 'GET');
+        await c.iam.usageEvents({ limit: 25, offset: 50, q: 'test' });
+        strict_1.default.ok(lastPath.startsWith('/v1/usage/events?'));
+        strict_1.default.ok(lastPath.includes('limit=25'));
+        strict_1.default.ok(lastPath.includes('offset=50'));
+        strict_1.default.ok(lastPath.includes('q=test'));
+        strict_1.default.equal(lastMethod, 'GET');
+    });
+    (0, node_test_1.it)('unwrapExecutions accepts envelope and bare array', () => {
+        strict_1.default.deepEqual((0, index_1.unwrapExecutions)({ data: [{ id: 'e1' }] }), [{ id: 'e1' }]);
+        strict_1.default.deepEqual((0, index_1.unwrapExecutions)([{ id: 'e2' }]), [{ id: 'e2' }]);
+        strict_1.default.deepEqual((0, index_1.unwrapExecutions)(null), []);
+    });
+    (0, node_test_1.it)('triggerWebhook posts to /webhook/:path without auth', async () => {
+        const out = await (0, index_1.triggerWebhook)(base, 'transform', { value: 21 });
+        strict_1.default.equal(lastPath, '/webhook/transform');
+        strict_1.default.equal(lastMethod, 'POST');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { value: 21 });
+        strict_1.default.equal(out.ok, true);
+    });
+    (0, node_test_1.it)('call() passes any method/path/body through', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.call('POST', '/v1/accounts/a1/credentials', { name: 'x' });
+        strict_1.default.equal(lastPath, '/v1/accounts/a1/credentials');
+        strict_1.default.equal(lastMethod, 'POST');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { name: 'x' });
+        await c.call('get', 'v1/workflows');
+        strict_1.default.equal(lastPath, '/v1/workflows');
+        strict_1.default.equal(lastMethod, 'GET');
+    });
+    (0, node_test_1.it)('credentials CRUD hits the workflow credentials paths', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.createCredential('a1', { name: 'stripe-live', type: 'bearer', secret: 's3cr3t', expiresAt: '2027-01-01T00:00:00Z' });
+        strict_1.default.equal(lastPath, '/v1/credentials');
+        strict_1.default.equal(lastMethod, 'POST');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { accountId: 'a1', name: 'stripe-live', kind: 'bearer', secret: 's3cr3t' });
+        await c.listCredentials('a1');
+        strict_1.default.equal(lastPath, '/v1/credentials?accountId=a1');
+        strict_1.default.equal(lastMethod, 'GET');
+        await c.getCredential('c1');
+        strict_1.default.equal(lastPath, '/v1/credentials/c1');
+        await c.rotateCredential('c1', 'n3w');
+        strict_1.default.equal(lastPath, '/v1/credentials/c1/rotate');
+        strict_1.default.equal(lastMethod, 'POST');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { secret: 'n3w' });
+        await c.deleteCredential('c1');
+        strict_1.default.equal(lastPath, '/v1/credentials/c1');
+        strict_1.default.equal(lastMethod, 'DELETE');
+    });
+    (0, node_test_1.it)('ai agent posts question and history', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.ai.agent('how to create a workflow', [{ role: 'user', text: 'hi' }]);
+        strict_1.default.equal(lastPath, '/v1/ai/agent');
+        strict_1.default.equal(lastMethod, 'POST');
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            question: 'how to create a workflow',
+            history: [{ role: 'user', text: 'hi' }],
+        });
+    });
+    (0, node_test_1.it)('ldsLicenses lists the license catalog', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.ldsLicenses();
+        strict_1.default.equal(lastPath, '/v1/lds/licenses');
+        strict_1.default.equal(lastMethod, 'GET');
+    });
+    (0, node_test_1.it)('ldsDatasources passes orgId/accountId filters', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.ldsDatasources({ orgId: 'o1', accountId: 'a1' });
+        strict_1.default.equal(lastPath, '/v1/lds/datasources?orgId=o1&accountId=a1');
+        await c.ldsDatasources();
+        strict_1.default.equal(lastPath, '/v1/lds/datasources');
+    });
+    (0, node_test_1.it)('ldsCreateDatasource posts the contract body', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        const input = {
+            name: 'Weather', slug: 'weather', entityType: 'WeatherObserved', license: 'CC-BY-4.0',
+            licenseUrl: 'https://creativecommons.org/licenses/by/4.0/',
+            contexts: ['https://uri.etsi.org/ngsi-ld/v1/ngsi-ld-core-context.jsonld'],
+            defaultVisibility: 'public', description: 'demo datasource', orgId: 'o1', accountId: 'a1',
+        };
+        await c.ldsCreateDatasource(input);
+        strict_1.default.equal(lastPath, '/v1/lds/datasources');
+        strict_1.default.equal(lastMethod, 'POST');
+        strict_1.default.deepEqual(JSON.parse(lastBody), input);
+    });
+    (0, node_test_1.it)('covers LDS datasource/attribute CRUD paths', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.ldsDatasource('ds1');
+        strict_1.default.equal(lastPath, '/v1/lds/datasources/ds1');
+        await c.ldsUpdateDatasource('ds1', { name: 'renamed' });
+        strict_1.default.equal(lastPath, '/v1/lds/datasources/ds1');
+        strict_1.default.equal(lastMethod, 'PATCH');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { name: 'renamed' });
+        await c.ldsDeleteDatasource('ds1');
+        strict_1.default.equal(lastPath, '/v1/lds/datasources/ds1');
+        strict_1.default.equal(lastMethod, 'DELETE');
+        await c.ldsAttributes('ds1');
+        strict_1.default.equal(lastPath, '/v1/lds/datasources/ds1/attributes');
+        await c.ldsSetAttributes('ds1', [{ name: 'temperature', ngsiLdType: 'Property', visibility: 'public' }]);
+        strict_1.default.equal(lastPath, '/v1/lds/datasources/ds1/attributes');
+        strict_1.default.equal(lastMethod, 'PUT');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { attributes: [{ name: 'temperature', ngsiLdType: 'Property', visibility: 'public' }] });
+        await c.ldsStats('ds1');
+        strict_1.default.equal(lastPath, '/v1/lds/datasources/ds1/stats');
+        await c.ldsEntity('ds1', 'urn:ngsi-ld:Thing:t1');
+        strict_1.default.equal(lastPath, '/v1/lds/datasources/ds1/entities/urn%3Angsi-ld%3AThing%3At1');
+    });
+    (0, node_test_1.it)('ldsIngest normalizes single/array/wrapped record bodies', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.ldsIngest('ds1', { sensor: 's1', temperature: 21 });
+        strict_1.default.equal(lastPath, '/v1/lds/datasources/ds1/records');
+        strict_1.default.equal(lastMethod, 'POST');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { record: { sensor: 's1', temperature: 21 } });
+        await c.ldsIngest('ds1', [{ sensor: 's1' }, { sensor: 's2' }]);
+        strict_1.default.deepEqual(JSON.parse(lastBody), { records: [{ sensor: 's1' }, { sensor: 's2' }] });
+        await c.ldsIngest('ds1', { records: [{ sensor: 's3' }] });
+        strict_1.default.deepEqual(JSON.parse(lastBody), { records: [{ sensor: 's3' }] });
+    });
+    (0, node_test_1.it)('ldsEntities sends limit/offset/visibility query params', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.ldsEntities('ds1', { limit: 50, offset: 10, visibility: 'public' });
+        strict_1.default.equal(lastPath, '/v1/lds/datasources/ds1/entities?limit=50&offset=10&visibility=public');
+        await c.ldsEntities('ds1');
+        strict_1.default.equal(lastPath, '/v1/lds/datasources/ds1/entities');
+    });
+    (0, node_test_1.it)('ldsSetAttributes surfaces the 400 reserved_attribute error', async () => {
+        let errMethod = '';
+        let errPath = '';
+        let errBody = '';
+        const errSrv = node_http_1.default.createServer((req, res) => {
+            errMethod = req.method || '';
+            errPath = req.url || '';
+            let body = '';
+            req.on('data', (ch) => (body += ch));
+            req.on('end', () => {
+                errBody = body;
+                res.statusCode = 400;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ error: 'reserved_attribute', message: 'attribute name "id" is reserved' }));
+            });
+        });
+        await new Promise((resolve) => errSrv.listen(0, '127.0.0.1', resolve));
+        const a = errSrv.address();
+        const errBase = `http://127.0.0.1:${typeof a === 'object' && a ? a.port : 0}`;
+        try {
+            const c = new index_1.SynapseOneClient({ baseUrl: errBase });
+            await strict_1.default.rejects(() => c.ldsSetAttributes('ds1', [{ name: 'id' }]), /synapseone 400 .*reserved_attribute/);
+            strict_1.default.equal(errMethod, 'PUT');
+            strict_1.default.equal(errPath, '/v1/lds/datasources/ds1/attributes');
+            strict_1.default.deepEqual(JSON.parse(errBody), { attributes: [{ name: 'id' }] });
+        }
+        finally {
+            await new Promise((resolve) => errSrv.close(() => resolve()));
+        }
+    });
+});

package/dist/example.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/example.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ */
+const index_1 = require("./index");
+async function main() {
+    const c = new index_1.SynapseOneClient({ baseUrl: process.env.SYNAPSEONE_BASE_URL || 'http://localhost:8080' });
+    const login = await c.login('demo@acme.local');
+    console.log('login ok:', login.user?.email);
+    c.setToken(login.accessToken);
+    console.log(await c.listOrgs());
+    console.log('lds datasources:', await c.ldsDatasources());
+}
+main().catch((e) => { console.error(e); process.exit(1); });

package/dist/faststore.d.ts

@@ -0,0 +1,108 @@
+import { HttpClient } from './_http';
+export declare class FaststoreService {
+    private readonly http;
+    constructor(http: HttpClient);
+    private key;
+    stats(): Promise<unknown>;
+    /** Scan keys; returns `{keys, cursor, truncated}` (pass `cursor` back to continue). */
+    listKeys(query?: {
+        prefix?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        keys: any[];
+        cursor: string | null;
+        truncated: boolean;
+    }>;
+    exists(key: string): Promise<boolean>;
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown, opts?: {
+        ttlSeconds?: number;
+        ifNotExists?: boolean;
+        ifExists?: boolean;
+    }): Promise<unknown>;
+    delete(key: string): Promise<unknown>;
+    ttl(key: string): Promise<unknown>;
+    expire(key: string, ttlSeconds: number): Promise<unknown>;
+    incr(key: string, opts?: {
+        by?: number;
+        ttlSeconds?: number;
+    }): Promise<unknown>;
+    batch(operations: Record<string, unknown>[]): Promise<{
+        results: any[];
+        ok: boolean;
+    }>;
+    hashGet(key: string): Promise<unknown>;
+    hashSet(key: string, values: Record<string, unknown>, opts?: {
+        ttlSeconds?: number;
+    }): Promise<unknown>;
+    hashDelete(key: string): Promise<unknown>;
+    hashLength(key: string): Promise<unknown>;
+    hashGetField(key: string, field: string): Promise<unknown>;
+    hashSetField(key: string, field: string, value: unknown, opts?: {
+        ttlSeconds?: number;
+    }): Promise<unknown>;
+    hashDeleteField(key: string, field: string): Promise<unknown>;
+    hashIncr(key: string, field: string, opts?: {
+        by?: number;
+        ttlSeconds?: number;
+    }): Promise<unknown>;
+    listRange(key: string, start?: number, stop?: number): Promise<unknown>;
+    listDelete(key: string): Promise<unknown>;
+    listPush(key: string, values: unknown[], opts?: {
+        side?: 'left' | 'right';
+        ttlSeconds?: number;
+    }): Promise<unknown>;
+    listPop(key: string, opts?: {
+        side?: 'left' | 'right';
+        count?: number;
+    }): Promise<unknown>;
+    listTrim(key: string, start: number, stop: number): Promise<unknown>;
+    listLength(key: string): Promise<unknown>;
+    setMembers(key: string): Promise<unknown>;
+    setDelete(key: string): Promise<unknown>;
+    setAdd(key: string, members: unknown[], opts?: {
+        ttlSeconds?: number;
+    }): Promise<unknown>;
+    setRemove(key: string, members: unknown[]): Promise<unknown>;
+    setContains(key: string, member: unknown): Promise<unknown>;
+    setCard(key: string): Promise<unknown>;
+    zsetRange(key: string, opts?: {
+        start?: number;
+        stop?: number;
+        rev?: boolean;
+        withScores?: boolean;
+    }): Promise<unknown>;
+    zsetDelete(key: string): Promise<unknown>;
+    zsetAdd(key: string, members: Array<{
+        member: unknown;
+        score: number;
+    }>, opts?: {
+        ttlSeconds?: number;
+    }): Promise<unknown>;
+    zsetIncr(key: string, member: unknown, opts?: {
+        by?: number;
+        ttlSeconds?: number;
+    }): Promise<unknown>;
+    zsetRemove(key: string, members: unknown[]): Promise<unknown>;
+    zsetScore(key: string, member: unknown): Promise<unknown>;
+    zsetRank(key: string, member: unknown, opts?: {
+        rev?: boolean;
+    }): Promise<unknown>;
+    zsetCard(key: string): Promise<unknown>;
+    lockAcquire(name: string, opts?: {
+        ttlSeconds?: number;
+        waitMs?: number;
+        token?: string;
+    }): Promise<{
+        acquired: boolean;
+        lock: string;
+        token?: string;
+        ttlSeconds?: number;
+        expiresAt?: string;
+    }>;
+    lockRelease(name: string, token: string): Promise<unknown>;
+    lockExtend(name: string, token: string, opts?: {
+        ttlSeconds?: number;
+    }): Promise<unknown>;
+}

package/dist/faststore.js

@@ -0,0 +1,201 @@
+"use strict";
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * Synapse Faststore client: Redis-backed cache/KV with strings, hashes, lists,
+ * sets, sorted sets, TTLs, counters, scans, batches and distributed locks.
+ *
+ * Every operation is scoped to the caller's tenant (org / account / user).
+ * Platform callers set `tenant` on the client (x-synapseone-tenant).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaststoreService = void 0;
+const _http_1 = require("./_http");
+const P = '/v1/faststore';
+class FaststoreService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    key(key) {
+        return encodeURIComponent(key);
+    }
+    // ---- stats / scans ----
+    stats() { return this.http.req(`${P}/stats`); }
+    /** Scan keys; returns `{keys, cursor, truncated}` (pass `cursor` back to continue). */
+    listKeys(query = {}) {
+        const p = new URLSearchParams();
+        if (query.prefix)
+            p.set('prefix', query.prefix);
+        if (query.limit !== undefined)
+            p.set('limit', String(query.limit));
+        if (query.cursor !== undefined)
+            p.set('cursor', query.cursor);
+        const s = p.toString();
+        return this.http.req(`${P}/keys${s ? `?${s}` : ''}`);
+    }
+    async exists(key) {
+        try {
+            await this.get(key);
+            return true;
+        }
+        catch (e) {
+            if (e instanceof _http_1.SynapseOneError && e.status === 404)
+                return false;
+            throw e;
+        }
+    }
+    // ---- key/value ----
+    get(key) { return this.http.req(`${P}/keys/${this.key(key)}`); }
+    set(key, value, opts = {}) {
+        return this.http.req(`${P}/keys/${this.key(key)}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                value,
+                ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}),
+                ...(opts.ifNotExists ? { ifNotExists: true } : {}),
+                ...(opts.ifExists ? { ifExists: true } : {}),
+            }),
+        });
+    }
+    delete(key) { return this.http.req(`${P}/keys/${this.key(key)}`, { method: 'DELETE' }); }
+    ttl(key) { return this.http.req(`${P}/keys/${this.key(key)}/ttl`); }
+    expire(key, ttlSeconds) {
+        return this.http.req(`${P}/keys/${this.key(key)}/expire`, { method: 'POST', body: JSON.stringify({ ttlSeconds }) });
+    }
+    incr(key, opts = {}) {
+        return this.http.req(`${P}/keys/${this.key(key)}/incr`, {
+            method: 'POST',
+            body: JSON.stringify({
+                by: opts.by ?? 1,
+                ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}),
+            }),
+        });
+    }
+    batch(operations) {
+        return this.http.req(`${P}/batch`, { method: 'POST', body: JSON.stringify({ operations }) });
+    }
+    // ---- hashes ----
+    hashGet(key) { return this.http.req(`${P}/hashes/${this.key(key)}`); }
+    hashSet(key, values, opts = {}) {
+        return this.http.req(`${P}/hashes/${this.key(key)}`, {
+            method: 'PUT',
+            body: JSON.stringify({ values, ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}) }),
+        });
+    }
+    hashDelete(key) { return this.http.req(`${P}/hashes/${this.key(key)}`, { method: 'DELETE' }); }
+    hashLength(key) { return this.http.req(`${P}/hashes/${this.key(key)}/length`); }
+    hashGetField(key, field) {
+        return this.http.req(`${P}/hashes/${this.key(key)}/${encodeURIComponent(field)}`);
+    }
+    hashSetField(key, field, value, opts = {}) {
+        return this.http.req(`${P}/hashes/${this.key(key)}/${encodeURIComponent(field)}`, {
+            method: 'PUT',
+            body: JSON.stringify({ value, ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}) }),
+        });
+    }
+    hashDeleteField(key, field) {
+        return this.http.req(`${P}/hashes/${this.key(key)}/${encodeURIComponent(field)}`, { method: 'DELETE' });
+    }
+    hashIncr(key, field, opts = {}) {
+        return this.http.req(`${P}/hashes/${this.key(key)}/incr`, {
+            method: 'POST',
+            body: JSON.stringify({ field, by: opts.by ?? 1, ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}) }),
+        });
+    }
+    // ---- lists ----
+    listRange(key, start = 0, stop = -1) {
+        return this.http.req(`${P}/lists/${this.key(key)}?start=${start}&stop=${stop}`);
+    }
+    listDelete(key) { return this.http.req(`${P}/lists/${this.key(key)}`, { method: 'DELETE' }); }
+    listPush(key, values, opts = {}) {
+        return this.http.req(`${P}/lists/${this.key(key)}/push`, {
+            method: 'POST',
+            body: JSON.stringify({ values, side: opts.side ?? 'right', ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}) }),
+        });
+    }
+    listPop(key, opts = {}) {
+        return this.http.req(`${P}/lists/${this.key(key)}/pop`, {
+            method: 'POST',
+            body: JSON.stringify({ side: opts.side ?? 'left', count: opts.count ?? 1 }),
+        });
+    }
+    listTrim(key, start, stop) {
+        return this.http.req(`${P}/lists/${this.key(key)}/trim`, { method: 'POST', body: JSON.stringify({ start, stop }) });
+    }
+    listLength(key) { return this.http.req(`${P}/lists/${this.key(key)}/length`); }
+    // ---- sets ----
+    setMembers(key) { return this.http.req(`${P}/sets/${this.key(key)}`); }
+    setDelete(key) { return this.http.req(`${P}/sets/${this.key(key)}`, { method: 'DELETE' }); }
+    setAdd(key, members, opts = {}) {
+        return this.http.req(`${P}/sets/${this.key(key)}/add`, {
+            method: 'POST',
+            body: JSON.stringify({ members, ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}) }),
+        });
+    }
+    setRemove(key, members) {
+        return this.http.req(`${P}/sets/${this.key(key)}/remove`, { method: 'POST', body: JSON.stringify({ members }) });
+    }
+    setContains(key, member) {
+        return this.http.req(`${P}/sets/${this.key(key)}/contains`, { method: 'POST', body: JSON.stringify({ member }) });
+    }
+    setCard(key) { return this.http.req(`${P}/sets/${this.key(key)}/card`); }
+    // ---- sorted sets ----
+    zsetRange(key, opts = {}) {
+        const p = new URLSearchParams();
+        p.set('start', String(opts.start ?? 0));
+        p.set('stop', String(opts.stop ?? -1));
+        if (opts.rev)
+            p.set('rev', 'true');
+        if (opts.withScores)
+            p.set('withScores', 'true');
+        return this.http.req(`${P}/zsets/${this.key(key)}?${p.toString()}`);
+    }
+    zsetDelete(key) { return this.http.req(`${P}/zsets/${this.key(key)}`, { method: 'DELETE' }); }
+    zsetAdd(key, members, opts = {}) {
+        return this.http.req(`${P}/zsets/${this.key(key)}/add`, {
+            method: 'POST',
+            body: JSON.stringify({ members, ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}) }),
+        });
+    }
+    zsetIncr(key, member, opts = {}) {
+        return this.http.req(`${P}/zsets/${this.key(key)}/incr`, {
+            method: 'POST',
+            body: JSON.stringify({ member, by: opts.by ?? 1, ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}) }),
+        });
+    }
+    zsetRemove(key, members) {
+        return this.http.req(`${P}/zsets/${this.key(key)}/remove`, { method: 'POST', body: JSON.stringify({ members }) });
+    }
+    zsetScore(key, member) {
+        return this.http.req(`${P}/zsets/${this.key(key)}/score`, { method: 'POST', body: JSON.stringify({ member }) });
+    }
+    zsetRank(key, member, opts = {}) {
+        return this.http.req(`${P}/zsets/${this.key(key)}/rank`, {
+            method: 'POST',
+            body: JSON.stringify({ member, ...(opts.rev ? { rev: true } : {}) }),
+        });
+    }
+    zsetCard(key) { return this.http.req(`${P}/zsets/${this.key(key)}/card`); }
+    // ---- distributed locks ----
+    lockAcquire(name, opts = {}) {
+        return this.http.req(`${P}/locks/${encodeURIComponent(name)}/acquire`, {
+            method: 'POST',
+            body: JSON.stringify({
+                waitMs: opts.waitMs ?? 0,
+                ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}),
+                ...(opts.token !== undefined ? { token: opts.token } : {}),
+            }),
+        });
+    }
+    lockRelease(name, token) {
+        return this.http.req(`${P}/locks/${encodeURIComponent(name)}/release`, { method: 'POST', body: JSON.stringify({ token }) });
+    }
+    lockExtend(name, token, opts = {}) {
+        return this.http.req(`${P}/locks/${encodeURIComponent(name)}/extend`, {
+            method: 'POST',
+            body: JSON.stringify({ token, ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}) }),
+        });
+    }
+}
+exports.FaststoreService = FaststoreService;