@adukilabs/sdk 0.0.0-stage → 0.1.2

package/dist/api/store.js

@@ -0,0 +1,352 @@
+// The workspace drive on Aduki Store for a program (machine access): the
+// metadata API on `store.aduki.pro/v1` and the content API on
+// `files.aduki.pro/v1`, with the DPoP-bound service-client token of
+// `IdClient` (audience `store`).
+//
+// What Store gives a service client (its docs, "Programs of a workspace"):
+// the workspace drive only, outside the Space folder, at the level of the
+// client's bits: `store.read` reads, `store.write` also creates, renames,
+// moves, trashes, restores and uploads. Never a drive of its own, never a
+// member's or a personal drive (their ids answer `404`). Shares, public
+// links, devices, reports, search, tickets and the change feed are for people:
+// `403 access.denied` with reason `client` (`ClientRefusedError`), so this
+// class has no calls for them.
+//
+// Uploads use the same chunking and hashing as the web Store module
+// (FastCDC 2020 cut points, BLAKE3 chunk and manifest hashes): begin a version
+// with the manifest, PUT the chunks the server lacks, commit; the same `key`
+// resumes an interrupted upload.
+import { failure, parse, rejection } from '../envelope.js';
+import { NetworkError, ProtocolError } from '../errors.js';
+import { url } from '../http.js';
+import { blob, manifest } from '../store/chunks.js';
+import * as model from '../store/model.js';
+/** Store's metadata API. */
+export const STORE = 'https://store.aduki.pro/v1';
+/** Store's content API (chunks, downloads). */
+export const FILES = 'https://files.aduki.pro/v1';
+const HEX = /^[0-9a-f]{16}$/;
+/** The workspace drive (see the module notes for what a program may not do). */
+export class StoreApi {
+    root;
+    files;
+    #fetch;
+    #sleep;
+    constructor(session, options = {}) {
+        this.#fetch = (input, init) => session.fetch('store', input, init);
+        this.root = (options.root ?? STORE).replace(/\/+$/, '');
+        this.files = (options.files ?? FILES).replace(/\/+$/, '');
+        this.#sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    }
+    /** The workspace drive's numbers: `owner` (the workspace), `cap`, `per`, `used` (`GET /v1/quota`). */
+    async quota() {
+        return (await this.call('GET', 'quota'));
+    }
+    /** The live children of folder `parent`, or of the drive root; with `trashed`, the trash (`GET /v1/folders`). */
+    async list(options = {}) {
+        const query = { parent: options.parent && id(options.parent, 'parent'), trashed: options.trashed ? true : undefined };
+        return model.listing(await this.call('GET', 'folders', { query }));
+    }
+    /** Folder `folder` (`GET /v1/folders/{id}`); one outside the workspace drive is `404`. */
+    async folder(folder) {
+        return model.folder(await this.call('GET', `folders/${id(folder, 'folder')}`));
+    }
+    /** File `file` (`GET /v1/files/{id}`). */
+    async file(file) {
+        return model.file(await this.call('GET', `files/${id(file, 'file')}`));
+    }
+    /** Creates a folder in `parent` (default the drive root) (`POST /v1/folders`, `store.write`); a name in use is 409. */
+    async createFolder(name, options = {}) {
+        const body = { name };
+        if (options.parent)
+            body.parent = id(options.parent, 'parent');
+        return model.folder(await this.call('POST', 'folders', { body }));
+    }
+    /** Creates an empty file to upload a version into (`POST /v1/files`). `upload` does this for you. */
+    async createFile(name, options = {}) {
+        const body = { name };
+        if (options.folder)
+            body.folder = id(options.folder, 'folder');
+        if (options.mime)
+            body.mime = options.mime;
+        return model.file(await this.call('POST', 'files', { body }));
+    }
+    /** Renames, moves (`parent: null` is the drive root), trashes or restores a folder (`PATCH /v1/folders/{id}`). */
+    async updateFolder(folder, change) {
+        const body = {};
+        if (change.name !== undefined)
+            body.name = change.name;
+        if (change.parent !== undefined)
+            body.parent = change.parent === null ? null : id(change.parent, 'parent');
+        if (change.trashed !== undefined)
+            body.trashed = change.trashed;
+        return model.folder(await this.call('PATCH', `folders/${id(folder, 'folder')}`, { body }));
+    }
+    /** Renames, moves (`folder: null` is the drive root), trashes or restores a file (`PATCH /v1/files/{id}`). */
+    async updateFile(file, change) {
+        const body = {};
+        if (change.name !== undefined)
+            body.name = change.name;
+        if (change.folder !== undefined)
+            body.folder = change.folder === null ? null : id(change.folder, 'folder');
+        if (change.trashed !== undefined)
+            body.trashed = change.trashed;
+        return model.file(await this.call('PATCH', `files/${id(file, 'file')}`, { body }));
+    }
+    /** Moves a folder and everything in it to the trash (`DELETE /v1/folders/{id}`). */
+    async trashFolder(folder) {
+        return model.folder(await this.call('DELETE', `folders/${id(folder, 'folder')}`));
+    }
+    /** Moves a file to the trash (`DELETE /v1/files/{id}`). */
+    async trashFile(file) {
+        return model.file(await this.call('DELETE', `files/${id(file, 'file')}`));
+    }
+    /** Takes a folder out of the trash. */
+    restoreFolder(folder) {
+        return this.updateFolder(folder, { trashed: false });
+    }
+    /** Takes a file out of the trash. */
+    restoreFile(file) {
+        return this.updateFile(file, { trashed: false });
+    }
+    // ---- versions and uploads ------------------------------------------
+    /** The versions of a file, newest first (`GET /v1/files/{id}/versions`). */
+    async versions(file) {
+        const list = await this.call('GET', `files/${id(file, 'file')}/versions`);
+        return (Array.isArray(list) ? list : []).map(model.version);
+    }
+    /** A version and the chunk positions still missing (`GET /v1/versions/{id}`). */
+    async version(version) {
+        return model.status(await this.call('GET', `versions/${id(version, 'version')}`));
+    }
+    /** Begins a version of `file` with its manifest (`POST /v1/files/{id}/versions`); `key` (a UUID) makes it idempotent. */
+    async begin(file, plan, options = {}) {
+        const fields = {
+            size: plan.size,
+            hash: plan.hash,
+            chunks: plan.chunks.map((c) => ({ hash: c.hash, size: c.size })),
+        };
+        if (options.base)
+            fields.base = id(options.base, 'base');
+        if (options.key)
+            fields.idempotency = options.key;
+        let body = JSON.stringify(fields);
+        if (options.attrs) {
+            // mtime_ns passes 2^53: written as an exact integer, not through a double
+            const ms = options.attrs.mtime instanceof Date ? options.attrs.mtime.getTime() : options.attrs.mtime;
+            if (!Number.isFinite(ms))
+                throw new TypeError('attrs.mtime is not a time');
+            const ns = (BigInt(Math.round(ms)) * 1000000n).toString();
+            body = `${body.slice(0, -1)},"attrs":{"mtime_ns":${ns},"exec":${options.attrs.exec ? 'true' : 'false'}}}`;
+        }
+        const headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
+        if (options.key)
+            headers['Idempotency-Key'] = options.key;
+        const data = await this.#raw(url(this.root, `files/${id(file, 'file')}/versions`), { method: 'POST', headers, body }, 'Begin');
+        return { version: data.version, state: data.state, missing: data.missing ?? [], expires: data.expires ?? null, reserved: data.reserved ?? 0 };
+    }
+    /**
+     * Sends one chunk of an open version (`PUT /v1/chunks/{owner}/{hash}` on
+     * the content host): true when stored, false when the drive already held
+     * it. A chunk being reclaimed (`409 chunk.busy`) is retried after the
+     * server's wait, up to three times.
+     */
+    async putChunk(owner, version, hash, bytes, signal) {
+        const target = url(this.files, `chunks/${id(owner, 'owner')}/${digest(hash)}`);
+        for (let attempt = 0;; attempt++) {
+            const init = {
+                method: 'PUT',
+                headers: { 'X-Version': id(version, 'version'), 'Content-Type': 'application/octet-stream' },
+                body: bytes instanceof Uint8Array ? new Uint8Array(bytes) : bytes,
+            };
+            if (signal)
+                init.signal = signal;
+            const response = await this.#fetch(target, init);
+            if (response.status === 201 || response.status === 204) {
+                await response.arrayBuffer().catch(() => { });
+                return response.status === 201;
+            }
+            const text = await response.text();
+            const error = failure(text);
+            if (response.status === 409 && error?.kind === 'chunk.busy' && attempt < 3) {
+                const wait = Number(error.details?.retry) || 5;
+                await this.#sleep(wait * 1000);
+                continue;
+            }
+            throw rejection(response, text, 'Chunk');
+        }
+    }
+    /** Commits a version (`POST /v1/files/{id}/commits`); chunks still missing are `409` with `details.missing`. */
+    async commit(file, version) {
+        return (await this.call('POST', `files/${id(file, 'file')}/commits`, { body: { version: id(version, 'version') } }));
+    }
+    /** Aborts an uncommitted version and frees its reservation (`DELETE /v1/files/{id}/versions/{version}`). */
+    async abort(file, version) {
+        return (await this.call('DELETE', `files/${id(file, 'file')}/versions/${id(version, 'version')}`));
+    }
+    /**
+     * Uploads `content` as a new file (`name`, `folder`) or as a new version of
+     * `file`: hashes it, begins the version, sends the missing chunks and
+     * commits. Run again with the same `key` to resume: only the chunks the
+     * server still lacks are sent. The version is `pending` until scanned.
+     */
+    async upload(content, options = {}) {
+        const source = blob(content);
+        let file;
+        let base = options.base;
+        if (options.file) {
+            file = await this.file(options.file);
+            base ??= file.version ?? undefined;
+        }
+        else {
+            const named = source.name;
+            const name = options.name ?? (typeof named === 'string' ? named : '');
+            if (!name)
+                throw new TypeError('upload needs a name or a file');
+            const place = { folder: options.folder ?? null };
+            const mime = options.mime ?? source.type;
+            if (mime)
+                place.mime = mime;
+            file = await this.createFile(name, place);
+        }
+        const owner = file.owner;
+        if (!owner)
+            throw new ProtocolError('The file has no owner');
+        const plan = options.manifest ?? (await manifest(source, (done) => options.progress?.({ phase: 'hash', done, total: source.size })));
+        const begin = { key: options.key ?? crypto.randomUUID() };
+        if (base)
+            begin.base = base;
+        if (options.attrs)
+            begin.attrs = options.attrs;
+        const begun = await this.begin(file.id, plan, begin);
+        if (begun.state === 'fast')
+            return { file, version: begun.version, state: 'ready', sent: 0 };
+        let sent = 0;
+        const total = begun.missing.reduce((n, i) => n + (plan.chunks[i]?.size ?? 0), 0);
+        const push = async (missing) => {
+            for (const index of missing) {
+                const chunk = plan.chunks[index];
+                if (!chunk)
+                    throw new ProtocolError(`The server asked for chunk ${index}, which the manifest does not have`);
+                options.signal?.throwIfAborted();
+                await this.putChunk(owner, begun.version, chunk.hash, source.slice(chunk.offset, chunk.offset + chunk.size), options.signal);
+                sent += chunk.size;
+                options.progress?.({ phase: 'send', done: sent, total: Math.max(total, sent) });
+            }
+        };
+        await push(begun.missing);
+        for (let round = 0;; round++) {
+            try {
+                const done = await this.commit(file.id, begun.version);
+                return { file, version: done.version, state: done.state, sent };
+            }
+            catch (error) {
+                const missing = error?.details;
+                if (round < 2 && error instanceof NetworkError && error.status === 409 && Array.isArray(missing?.missing)) {
+                    await push(missing.missing);
+                    continue;
+                }
+                throw error;
+            }
+        }
+    }
+    // ---- downloads and renditions -------------------------------------
+    /**
+     * The content of a file as a Response (`GET /v1/files/{id}/content` on the
+     * content host): `200`, `206` for a range, `304` for an unchanged `etag`;
+     * `ETag`, `Content-Type`, `Content-Range` headers. A failure throws (`416`
+     * for a range past the end).
+     */
+    async content(file, options = {}) {
+        const version = options.version ? `?version=${id(options.version, 'version')}` : '';
+        const headers = {};
+        if (options.range)
+            headers.Range = range(options.range);
+        if (options.etag)
+            headers['If-None-Match'] = options.etag.startsWith('"') ? options.etag : `"${options.etag}"`;
+        const init = { headers };
+        if (options.signal)
+            init.signal = options.signal;
+        const response = await this.#fetch(`${url(this.files, `files/${id(file, 'file')}/content`)}${version}`, init);
+        if (response.ok || response.status === 304)
+            return response;
+        throw rejection(response, await response.text(), 'Download');
+    }
+    /** The content of a file as a Blob (the whole file, or `range`). */
+    async download(file, options = {}) {
+        const response = await this.content(file, options);
+        if (response.status === 304)
+            throw new ProtocolError('Download answered 304: pass no etag to download');
+        return response.blob();
+    }
+    /** The renditions (thumbnails, posters, previews) of a version (`GET /v1/versions/{id}/media`). */
+    async media(version) {
+        const list = await this.call('GET', `versions/${id(version, 'version')}/media`);
+        return Array.isArray(list) ? list : [];
+    }
+    /** The bytes of a ready rendition (`GET /v1/derivatives/{id}/content` on the content host), or a `range` of them. */
+    async derivative(derivative, options = {}) {
+        const headers = {};
+        if (options.range)
+            headers.Range = range(options.range);
+        const init = { headers };
+        if (options.signal)
+            init.signal = options.signal;
+        const response = await this.#fetch(url(this.files, `derivatives/${id(derivative, 'derivative')}/content`), init);
+        if (response.ok)
+            return response;
+        throw rejection(response, await response.text(), 'Derivative');
+    }
+    // ---- any other route ----------------------------------------------
+    /**
+     * Any metadata route under `/v1` (`path` without it): returns the
+     * envelope's `data`; a refusal throws the typed error of `errors.refusal`
+     * (`ClientRefusedError` for a route that is not for programs).
+     */
+    async call(method, path, options = {}) {
+        const params = new URLSearchParams();
+        for (const [k, v] of Object.entries(options.query ?? {}))
+            if (v !== undefined && v !== '')
+                params.set(k, String(v));
+        const q = params.toString();
+        const clean = path.replace(/^\/+/, '');
+        const headers = { Accept: 'application/json' };
+        const init = { method, headers };
+        if (options.body !== undefined) {
+            headers['Content-Type'] = 'application/json';
+            init.body = JSON.stringify(options.body);
+        }
+        if (options.signal)
+            init.signal = options.signal;
+        return this.#raw(`${url(this.root, clean)}${q ? `?${q}` : ''}`, init, `${method} /v1/${clean.split('?')[0]}`);
+    }
+    async #raw(target, init, what) {
+        const response = await this.#fetch(target, init);
+        const text = await response.text();
+        if (!response.ok)
+            throw rejection(response, text, what);
+        const envelope = parse(text);
+        if (!envelope || envelope.success !== true)
+            throw new ProtocolError(`${what}: the answer is not a success envelope`);
+        if (envelope.data === undefined)
+            throw new NetworkError(`Empty response from ${what}`, { status: response.status });
+        return envelope.data;
+    }
+}
+/** A public id (16 lowercase hex digits), or TypeError. */
+function id(value, what) {
+    if (!HEX.test(value))
+        throw new TypeError(`${what} is not an id (16 lowercase hex digits)`);
+    return value;
+}
+function digest(value) {
+    if (!/^[0-9a-f]{64}$/.test(value))
+        throw new TypeError('A chunk hash is 64 lowercase hex digits');
+    return value;
+}
+function range(r) {
+    if (!(Number.isInteger(r.start) && r.start >= 0) || (r.end !== undefined && !(Number.isInteger(r.end) && r.end >= r.start))) {
+        throw new TypeError('A range is whole byte offsets, start <= end');
+    }
+    return `bytes=${r.start}-${r.end ?? ''}`;
+}

package/dist/api/tenant.d.ts

@@ -0,0 +1,319 @@
+import type { Api } from './api.js';
+import type * as model from './model.js';
+import type { Page, PageQuery } from './model.js';
+/** The workspace: profile, members, audits, usage and the mail admin routes. */
+export declare class Tenant {
+    #private;
+    readonly members: TenantMembers;
+    readonly audits: TenantAudits;
+    readonly usage: TenantUsage;
+    readonly domains: TenantDomains;
+    readonly aliases: TenantAliases;
+    readonly quotas: TenantQuotas;
+    readonly rules: TenantRules;
+    readonly webhooks: TenantWebhooks;
+    readonly holidays: TenantHolidays;
+    readonly schedule: TenantSchedule;
+    constructor(api: Api);
+    /** `GET /v1/tenant`: the workspace's profile (scope `tenants:read`). */
+    get(): Promise<model.TenantProfile>;
+    /** `GET /v1/tenant/view/slug/{slug}` (`tenants:read`; another workspace's slug is `403`). */
+    bySlug(slug: string): Promise<model.TenantProfile>;
+    /** `GET /v1/tenant/security`: MTA-STS, TLSA, BIMI and the DMARC/TLS reports (`security:read`). */
+    security(): Promise<model.SecurityStatus>;
+    /** `GET /v1/tenant/mail/services`: the mail services and whether this workspace may use each (`mailservices:read`). */
+    services(): Promise<{
+        services: model.MailService[];
+    }>;
+}
+/**
+ * The members as Aduki Mail sees them. Listing all needs `tenants:read`, the
+ * filtered lists `members:read`; removing `tenants:write`. Inviting, roles
+ * and closing an account are Aduki ID's and need a signed-in person.
+ */
+export declare class TenantMembers {
+    #private;
+    constructor(api: Api);
+    /** `GET /v1/tenant/members`, `.../active` or `.../owners`. */
+    list(query?: PageQuery & {
+        state?: 'active' | 'owners';
+    }): Promise<Page<model.MemberRow>>;
+    /** `GET /v1/tenant/members/search/{q}`. */
+    search(text: string, query?: PageQuery): Promise<Page<model.MemberRow>>;
+    /** `DELETE /v1/tenant/members/{user}`: removes the member's mail account from the workspace (`404` for a non-member). */
+    remove(user: string): Promise<void>;
+}
+/** The workspace's audit trail (`audits:read`; one record by hex: `tenants:read`). */
+export declare class TenantAudits {
+    #private;
+    constructor(api: Api);
+    /**
+     * `GET /v1/tenant/audits[/user/{user}][/action/{action} | /failed |
+     * /successful | /ip/{ip}]`: one filter besides `user` at a time (the
+     * server has no route for two).
+     */
+    list(query?: PageQuery & {
+        user?: string;
+        action?: string;
+        outcome?: 'failed' | 'successful';
+        ip?: string;
+    }): Promise<Page<model.AuditRow>>;
+    /** `GET /v1/tenant/view/audit/{hex}`: one record with its `meta` (`tenants:read`). */
+    get(hex: string): Promise<model.AuditDetail>;
+}
+/** Metered usage (`usage:read`). */
+export declare class TenantUsage {
+    #private;
+    constructor(api: Api);
+    /** `GET /v1/tenant/usage`. */
+    list(query?: PageQuery): Promise<Page<model.UsageRow>>;
+    /** `GET /v1/tenant/usage/summary`: one row per metric, no paging. */
+    summary(): Promise<model.UsageRow[]>;
+    /** `GET /v1/tenant/usage/metric/{metric}`. */
+    metric(metric: string, query?: PageQuery): Promise<Page<model.UsageRow>>;
+}
+/**
+ * Mail domains: `domains:read`, `domains:write` to change. The DNS records
+ * to publish are on the domain (`dkim`, and `pending` of a DKIM rotation).
+ */
+export declare class TenantDomains {
+    #private;
+    readonly dkim: TenantDkim;
+    constructor(api: Api);
+    /** `POST /v1/tenant/domains`: registers a domain (status `pending`); returns its hex. */
+    add(input: model.DomainCreate): Promise<string>;
+    /** `GET /v1/tenant/domains`, `.../active` or `.../pending`. */
+    list(query?: PageQuery & {
+        state?: 'active' | 'pending';
+    }): Promise<Page<model.DomainRow>>;
+    /** `GET /v1/tenant/domains/{hex}`: the full record with its DNS snapshots. */
+    get(hex: string): Promise<model.Domain>;
+    /** `GET /v1/tenant/domains/lookup/name?name=`: a domain by name (`404` when none). */
+    byName(name: string): Promise<model.Domain>;
+    /** `PATCH /v1/tenant/domains/{hex}/name`. */
+    rename(hex: string, name: string): Promise<void>;
+    /** `PATCH /v1/tenant/domains/{hex}/kind`: `primary`, `sending`, `receiving` or `alias`. */
+    kind(hex: string, kind: string): Promise<void>;
+    /** `PATCH /v1/tenant/domains/{hex}/selector`: the DKIM selector, before the domain has a key (`409` after). */
+    selector(hex: string, selector: string): Promise<void>;
+    /** `PATCH /v1/tenant/domains/{hex}/auth`: the SPF, DMARC, MTA-STS and BIMI settings, all four. */
+    auth(hex: string, input: {
+        spf: unknown;
+        dmarc: unknown;
+        mta_sts: unknown;
+        bimi: unknown;
+    }): Promise<void>;
+    /** `PATCH /v1/tenant/domains/{hex}/meta`. */
+    meta(hex: string, meta: Record<string, unknown>): Promise<void>;
+    /** `DELETE /v1/tenant/domains/{hex}`. */
+    delete(hex: string): Promise<void>;
+}
+/**
+ * DKIM key rotation without a gap: stage a key the server makes, publish its
+ * TXT record, check, confirm. No private key is sent or returned.
+ */
+export declare class TenantDkim {
+    #private;
+    constructor(api: Api);
+    /** `GET /v1/tenant/domains/{hex}/dkim/rotation`: the active, staged and retired records (`domains:read`). */
+    state(hex: string): Promise<model.DkimRotation>;
+    /** `POST .../dkim/rotation`: stages the next key (a retry returns the same one); publish `pending.value` at `pending.name`. */
+    stage(hex: string, input?: {
+        selector?: string;
+    }): Promise<model.DkimRotation>;
+    /** `POST .../dkim/rotation/check`: whether DNS carries the staged record; changes nothing (`domains:read`). */
+    check(hex: string): Promise<{
+        ready: boolean;
+        reason?: string;
+        pending?: unknown;
+        [field: string]: unknown;
+    }>;
+    /** `POST .../dkim/rotation/confirm`: switches signing to the staged key (`409` while DNS does not carry it). */
+    confirm(hex: string): Promise<model.DkimRotation>;
+    /** `DELETE .../dkim/rotation`: drops the staged key (`404` when none). */
+    cancel(hex: string): Promise<void>;
+}
+/** Members' extra addresses on the workspace's verified domains: `aliases:read`, `aliases:write`. */
+export declare class TenantAliases {
+    #private;
+    constructor(api: Api);
+    /** `POST /v1/tenant/aliases`: `created` is false when the member already had it. */
+    add(user: string, address: string): Promise<model.Alias & {
+        created: boolean;
+    }>;
+    /** `GET /v1/tenant/aliases[?user=]`: at most 1000, by address. */
+    list(query?: {
+        user?: string;
+    }): Promise<{
+        items: model.Alias[];
+    }>;
+    /** `DELETE /v1/tenant/aliases/{address}`. */
+    remove(address: string): Promise<void>;
+}
+/** The workspace's own usage ceilings per metric: `quotas:read`, `quotas:write`. */
+export declare class TenantQuotas {
+    #private;
+    constructor(api: Api);
+    /** `POST /v1/tenant/quotas`. */
+    add(input: {
+        metric: string;
+        ceiling: number;
+        reason?: string;
+        expires?: string;
+    }): Promise<model.Quota>;
+    /** `GET /v1/tenant/quotas`. */
+    list(query?: PageQuery): Promise<Page<model.QuotaRow>>;
+    /** `GET /v1/tenant/quotas/{metric}`. */
+    get(metric: string): Promise<model.Quota>;
+    /** `PATCH /v1/tenant/quotas/{metric}/ceiling`, `/expires`, `/reason`: the fields given, one call each. */
+    edit(metric: string, change: {
+        ceiling?: number;
+        expires?: string;
+        reason?: string;
+    }): Promise<void>;
+    /** `DELETE /v1/tenant/quotas/{metric}`. */
+    delete(metric: string): Promise<void>;
+}
+/** Spam rules of the workspace: `rules:read`, `rules:write`. */
+export declare class TenantRules {
+    #private;
+    constructor(api: Api);
+    /** `POST /v1/tenant/rules`. */
+    add(input: model.RuleCreate): Promise<model.Rule>;
+    /** `GET /v1/tenant/rules`, `.../active`, or `.../target/{target}`. */
+    list(query?: PageQuery & {
+        active?: boolean;
+        target?: string;
+    }): Promise<Page<model.RuleRow>>;
+    /** `GET /v1/tenant/rules/{hex}/detail`: the rule with its `meta`. */
+    get(hex: string): Promise<model.Rule>;
+    /** `GET /v1/tenant/rules/name/{name}`. */
+    byName(name: string): Promise<model.Rule>;
+    /**
+     * `PATCH /v1/tenant/rules/{hex}/{field}` for each field given (`regex` is
+     * sent after `pattern`, so a new pattern and `regex: true` go together).
+     */
+    edit(hex: string, change: {
+        name?: string;
+        target?: string;
+        pattern?: string;
+        regex?: boolean;
+        score?: number;
+        active?: boolean;
+    }): Promise<void>;
+    /** `DELETE /v1/tenant/rules/{hex}`. */
+    delete(hex: string): Promise<void>;
+}
+/** Delivery-event webhooks: `webhooks:read`, `webhooks:write`. */
+export declare class TenantWebhooks {
+    #private;
+    constructor(api: Api);
+    /** `POST /v1/tenant/webhooks`: returns the hex and the signing secret, shown this once. */
+    add(input: model.WebhookCreate): Promise<{
+        hex: string;
+        secret: string;
+    }>;
+    /** `GET /v1/tenant/webhooks`, `.../active`, or `.../subscribers/{event}`. */
+    list(query?: PageQuery & {
+        active?: boolean;
+        event?: string;
+    }): Promise<Page<model.WebhookRow>>;
+    /** `GET /v1/tenant/webhooks/{hex}`: the record, never the secret. */
+    get(hex: string): Promise<model.Webhook>;
+    /** `PATCH /v1/tenant/webhooks/{hex}/{field}` for each field given (`url` is checked again: `https`, a public host). */
+    edit(hex: string, change: {
+        url?: string;
+        events?: string[];
+        domains?: string[];
+        active?: boolean;
+        secret?: string;
+    }): Promise<void>;
+    /** `POST /v1/tenant/webhooks/{hex}/secret/rotate`: a new secret made by the server, returned once. */
+    rotate(hex: string): Promise<string>;
+    /** `DELETE /v1/tenant/webhooks/{hex}`. */
+    delete(hex: string): Promise<void>;
+}
+/** The workspace's holidays and closures: reading `tenant:read`, writing `tenants:write`. */
+export declare class TenantHolidays {
+    #private;
+    constructor(api: Api);
+    /** `GET /v1/tenant/holidays?region&year`: the effective days (`region` defaults to the workspace's). */
+    list(query?: {
+        region?: string;
+        year?: number;
+    }): Promise<model.Holiday[]>;
+    /**
+     * `POST /v1/tenant/holidays`: a day or range of the workspace's own
+     * (`kind` `closure` by default, or `observance`), or `{exclude: true,
+     * region, date}` to drop the platform's day on that date.
+     */
+    add(input: {
+        date: string;
+        until?: string;
+        name: string;
+        kind?: 'closure' | 'observance';
+        region?: string;
+    } | {
+        exclude: true;
+        region: string;
+        date: string;
+    }): Promise<model.Holiday>;
+    /** `DELETE /v1/tenant/holidays/{hex}`: one of the workspace's own rows. */
+    remove(hex: string): Promise<void>;
+    /** `GET /v1/tenant/holidays/region`: the default region, or null. */
+    region(): Promise<{
+        region: string;
+        subdivision?: string | null;
+        updated: string;
+    } | null>;
+    /** `PUT /v1/tenant/holidays/region` (`422` for a region with no data); `null` clears it (`DELETE`). */
+    setRegion(region: {
+        region: string;
+        subdivision?: string;
+    } | null): Promise<void>;
+}
+/** Scheduling templates and resources: reading `tenant:read`, writing `tenants:write`. */
+export declare class TenantSchedule {
+    #private;
+    constructor(api: Api);
+    /** `GET /v1/tenant/schedule/templates`. */
+    templates(): Promise<model.ScheduleTemplate[]>;
+    /** `GET /v1/tenant/schedule/templates/{hex}`. */
+    template(hex: string): Promise<model.ScheduleTemplate>;
+    /** `POST /v1/tenant/schedule/templates` (rules default to weekdays 09:00-17:00, zone to UTC). */
+    addTemplate(input: {
+        name: string;
+        zone?: string;
+        rules?: unknown[];
+    }): Promise<model.ScheduleTemplate>;
+    /** `PATCH /v1/tenant/schedule/templates/{hex}`: name and zone. */
+    editTemplate(hex: string, change: {
+        name?: string;
+        zone?: string;
+    }): Promise<model.ScheduleTemplate>;
+    /** `PUT /v1/tenant/schedule/templates/{hex}/rules`: replaces the weekly rules. */
+    setRules(hex: string, rules: unknown[]): Promise<model.ScheduleTemplate>;
+    /** `DELETE /v1/tenant/schedule/templates/{hex}` (`409` while followed or used). */
+    deleteTemplate(hex: string): Promise<void>;
+    /** `GET /v1/tenant/schedule/resources`: rooms and equipment, live ones first. */
+    resources(): Promise<model.ScheduleResource[]>;
+    /** `GET /v1/tenant/schedule/resources/{hex}`. */
+    resource(hex: string): Promise<model.ScheduleResource>;
+    /** `POST /v1/tenant/schedule/resources` (`409` for a name in use). */
+    addResource(input: {
+        name: string;
+        kind: 'room' | 'equipment';
+        capacity?: number;
+        schedule?: string;
+    }): Promise<model.ScheduleResource>;
+    /** `PATCH /v1/tenant/schedule/resources/{hex}`: `null` clears `capacity` and `schedule`; `retired` stops offering it. */
+    editResource(hex: string, change: {
+        name?: string;
+        kind?: 'room' | 'equipment';
+        capacity?: number | null;
+        schedule?: string | null;
+        retired?: boolean;
+    }): Promise<model.ScheduleResource>;
+    /** `DELETE /v1/tenant/schedule/resources/{hex}` (`409` once booked: retire it instead). */
+    deleteResource(hex: string): Promise<void>;
+}