@acms-subir/client 0.1.0

package/dist/editor.js

@@ -0,0 +1,354 @@
+import { AcmsError } from './errors.js';
+export const webCrypto = {
+    randomBytes(length) {
+        const c = globalThis.crypto;
+        if (!c?.getRandomValues)
+            throw new TypeError('No secure random source: pass a PkceCrypto (expo-crypto) implementation.');
+        return c.getRandomValues(new Uint8Array(length));
+    },
+    async sha256(data) {
+        const subtle = globalThis.crypto?.subtle;
+        if (!subtle)
+            throw new TypeError('No Web Crypto SHA-256: pass a PkceCrypto (expo-crypto) implementation.');
+        return subtle.digest('SHA-256', data);
+    },
+};
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+/** base64url without padding (no btoa: works in every JS runtime) */
+export function base64url(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length; i += 3) {
+        const n = (bytes[i] << 16) | ((bytes[i + 1] ?? 0) << 8) | (bytes[i + 2] ?? 0);
+        out += B64[(n >> 18) & 63] + B64[(n >> 12) & 63] + (i + 1 < bytes.length ? B64[(n >> 6) & 63] : '') + (i + 2 < bytes.length ? B64[n & 63] : '');
+    }
+    return out;
+}
+async function random(crypto, length) {
+    const bytes = await crypto.randomBytes(length);
+    if (!(bytes instanceof Uint8Array) || bytes.length !== length)
+        throw new TypeError('randomBytes must return a Uint8Array of the requested length.');
+    return bytes;
+}
+/** a 43-character verifier (32 random bytes), RFC 7636 */
+export async function createCodeVerifier(crypto = webCrypto) { return base64url(await random(crypto, 32)); }
+export async function codeChallengeFor(verifier, crypto = webCrypto) {
+    if (!/^[A-Za-z0-9._~-]{43,128}$/.test(verifier))
+        throw new TypeError('A PKCE verifier is 43–128 unreserved characters.');
+    const ascii = new Uint8Array(verifier.length);
+    for (let i = 0; i < verifier.length; i++)
+        ascii[i] = verifier.charCodeAt(i);
+    return base64url(new Uint8Array(await crypto.sha256(ascii)));
+}
+export async function createPkce(crypto = webCrypto) {
+    const verifier = await createCodeVerifier(crypto);
+    return { verifier, challenge: await codeChallengeFor(verifier, crypto), method: 'S256' };
+}
+export async function createState(crypto = webCrypto) { return base64url(await random(crypto, 16)); }
+export const toTokens = (t, now = Date.now()) => ({ accessToken: t.access_token, refreshToken: t.refresh_token, expiresAt: now + t.expires_in * 1000, user: t.user, device: t.device });
+const origin = (baseUrl) => {
+    const u = new URL(baseUrl);
+    if (!['http:', 'https:'].includes(u.protocol) || u.username || u.password || u.search || u.hash)
+        throw new TypeError('baseUrl must be an HTTP(S) URL without credentials, query or fragment.');
+    return { site: u.origin + u.pathname.replace(/\/+$/, '').replace(/\/api\/v1$/, ''), api: (u.origin + u.pathname.replace(/\/+$/, '').replace(/\/api\/v1$/, '')) + '/api/v1' };
+};
+function withTimeout(ms, signal) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new AcmsError(0, 'timeout', 'Request timed out.')), ms);
+    const abort = () => controller.abort(new AcmsError(0, 'aborted', 'Request aborted.'));
+    if (signal?.aborted)
+        abort();
+    else
+        signal?.addEventListener('abort', abort, { once: true });
+    return { signal: controller.signal, done: () => { clearTimeout(timer); signal?.removeEventListener('abort', abort); } };
+}
+export function createEditorAuth(options) {
+    const { site, api } = origin(options.baseUrl);
+    const fetcher = options.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!fetcher)
+        throw new TypeError('A fetch implementation is required.');
+    const crypto = options.crypto ?? webCrypto;
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    async function post(path, body) {
+        const t = withTimeout(timeoutMs);
+        try {
+            let res;
+            try {
+                res = await fetcher(api + path, { method: 'POST', credentials: 'omit', signal: t.signal,
+                    headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' }, body: new URLSearchParams(body).toString() });
+            }
+            catch (error) {
+                if (t.signal.aborted)
+                    throw t.signal.reason;
+                throw new AcmsError(0, 'network_error', error instanceof Error ? error.message : 'Network request failed.');
+            }
+            let json = null;
+            try {
+                json = await res.json();
+            }
+            catch { /* handled below */ }
+            if (!res.ok) {
+                const retry = Number(res.headers.get('Retry-After')) || undefined;
+                throw new AcmsError(res.status, String(json?.error ?? 'http_error'), String(json?.error_description ?? `HTTP ${res.status}`), retry);
+            }
+            if (!json)
+                throw new AcmsError(res.status, 'invalid_response', 'Expected a JSON response.');
+            return json;
+        }
+        finally {
+            t.done();
+        }
+    }
+    const auth = {
+        buildAuthorizeUrl({ codeChallenge, state, deviceName }) {
+            const url = new URL(site + '/admin/app-auth');
+            url.searchParams.set('response_type', 'code');
+            url.searchParams.set('client_id', options.clientId);
+            url.searchParams.set('redirect_uri', options.redirectUri);
+            url.searchParams.set('code_challenge', codeChallenge);
+            url.searchParams.set('code_challenge_method', 'S256');
+            url.searchParams.set('state', state);
+            if (deviceName)
+                url.searchParams.set('device_name', deviceName.slice(0, 60));
+            return url.href;
+        },
+        async start(o = {}) {
+            const pkce = await createPkce(crypto);
+            const state = await createState(crypto);
+            return { url: auth.buildAuthorizeUrl({ codeChallenge: pkce.challenge, state, deviceName: o.deviceName }), verifier: pkce.verifier, state };
+        },
+        parseRedirect(url, expectedState) {
+            let params;
+            try {
+                params = new URL(url).searchParams;
+            }
+            catch {
+                throw new AcmsError(0, 'invalid_response', 'The sign-in redirect is not a URL.');
+            }
+            const state = params.get('state') ?? '';
+            // compare without early exit
+            let diff = state.length ^ expectedState.length;
+            for (let i = 0; i < Math.max(state.length, expectedState.length); i++)
+                diff |= (state.charCodeAt(i) || 0) ^ (expectedState.charCodeAt(i) || 0);
+            if (!expectedState || diff !== 0)
+                throw new AcmsError(0, 'state_mismatch', 'The sign-in response did not match this request. Try again.');
+            const error = params.get('error');
+            if (error)
+                throw new AcmsError(error === 'access_denied' ? 0 : 400, error, params.get('error_description') ?? 'Sign-in failed.');
+            const code = params.get('code');
+            if (!code)
+                throw new AcmsError(0, 'invalid_response', 'The sign-in response has no code.');
+            return { code };
+        },
+        async exchangeCode({ code, codeVerifier }) {
+            return toTokens(await post('/auth/token', { grant_type: 'authorization_code', code, code_verifier: codeVerifier, redirect_uri: options.redirectUri, client_id: options.clientId }));
+        },
+        async refresh(refreshToken) {
+            return toTokens(await post('/auth/token', { grant_type: 'refresh_token', refresh_token: refreshToken, client_id: options.clientId }));
+        },
+        async revoke(token) { await post('/auth/revoke', { token }); },
+    };
+    return auth;
+}
+/** refresh failures that mean "sign in again" (as opposed to being offline) */
+const signedOut = (e) => e instanceof AcmsError && (e.code === 'invalid_grant' || e.status === 400 || e.status === 401 || e.status === 404);
+export function createEditorSession(o) {
+    const now = o.now ?? Date.now;
+    const skew = o.refreshSkewMs ?? 60_000;
+    let inflight = null;
+    const session = {
+        tokens: async () => o.storage.get(),
+        async getAccessToken() {
+            const t = await o.storage.get();
+            if (!t)
+                return null;
+            return t.expiresAt - skew > now() ? t.accessToken : session.refresh();
+        },
+        refresh() {
+            inflight ??= (async () => {
+                const t = await o.storage.get();
+                if (!t)
+                    return null;
+                try {
+                    const next = await o.auth.refresh(t.refreshToken);
+                    await o.storage.set(next);
+                    return next.accessToken;
+                }
+                catch (error) {
+                    if (signedOut(error)) {
+                        await o.storage.set(null);
+                        o.onSignedOut?.();
+                        return null;
+                    }
+                    throw error;
+                }
+            })().finally(() => { inflight = null; });
+            return inflight;
+        },
+        async signIn(tokens) { await o.storage.set(tokens); },
+        async signOut() {
+            const t = await o.storage.get();
+            await o.storage.set(null);
+            if (t)
+                await o.auth.revoke(t.refreshToken).catch(() => { });
+        },
+    };
+    return session;
+}
+// ---- the admin API -----------------------------------------------------------
+export const authEndpoints = {
+    exchangeCode: { method: 'POST', path: '/auth/token' }, revoke: { method: 'POST', path: '/auth/revoke' },
+};
+export const editorEndpoints = {
+    me: { method: 'GET', path: '/admin/me' },
+    listDocuments: { method: 'GET', path: '/admin/documents' }, createDocument: { method: 'POST', path: '/admin/documents' },
+    getDocument: { method: 'GET', path: '/admin/documents/{kind}/{id}' }, saveDocument: { method: 'PUT', path: '/admin/documents/{kind}/{id}' },
+    publishDocument: { method: 'POST', path: '/admin/documents/{kind}/{id}/publish' }, unpublishDocument: { method: 'POST', path: '/admin/documents/{kind}/{id}/unpublish' },
+    scheduleDocument: { method: 'POST', path: '/admin/documents/{kind}/{id}/schedule' }, discardDocument: { method: 'POST', path: '/admin/documents/{kind}/{id}/discard' },
+    getDocumentTranslation: { method: 'GET', path: '/admin/documents/{kind}/{id}/translations/{locale}' },
+    setDocumentTranslation: { method: 'PUT', path: '/admin/documents/{kind}/{id}/translations/{locale}' },
+    reviewDocumentTranslation: { method: 'POST', path: '/admin/documents/{kind}/{id}/translations/{locale}/review' },
+    draftDocumentTranslation: { method: 'POST', path: '/admin/documents/{kind}/{id}/translations/{locale}/ai-draft' },
+    listSections: { method: 'GET', path: '/admin/sections' },
+    updateSection: { method: 'PATCH', path: '/admin/sections/{pageId}/{sectionId}' },
+    publishSection: { method: 'POST', path: '/admin/sections/{pageId}/{sectionId}/publish' },
+    getSectionTranslation: { method: 'GET', path: '/admin/sections/{pageId}/{sectionId}/translations/{locale}' },
+    setSectionTranslation: { method: 'PUT', path: '/admin/sections/{pageId}/{sectionId}/translations/{locale}' },
+    reviewSectionTranslation: { method: 'POST', path: '/admin/sections/{pageId}/{sectionId}/translations/{locale}/review' },
+    draftSectionTranslation: { method: 'POST', path: '/admin/sections/{pageId}/{sectionId}/translations/{locale}/ai-draft' },
+    listMedia: { method: 'GET', path: '/admin/media' }, uploadMedia: { method: 'POST', path: '/admin/media' },
+    listBookings: { method: 'GET', path: '/admin/bookings' },
+    approveBooking: { method: 'POST', path: '/admin/bookings/{id}/approve' },
+    declineBooking: { method: 'POST', path: '/admin/bookings/{id}/decline' },
+    cancelBooking: { method: 'POST', path: '/admin/bookings/{id}/cancel' },
+};
+export function createEditorClient(options) {
+    const { api } = origin(options.baseUrl);
+    const fetcher = options.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!fetcher)
+        throw new TypeError('A fetch implementation is required.');
+    const getToken = options.session ? () => options.session.getAccessToken() : options.getAccessToken;
+    const refreshToken = options.session ? () => options.session.refresh() : options.refresh;
+    if (!getToken)
+        throw new TypeError('Pass a session or getAccessToken.');
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    // one refresh at a time even when several requests hit 401 together
+    let refreshing = null;
+    const refresh = () => {
+        if (!refreshToken)
+            return Promise.resolve(null);
+        refreshing ??= refreshToken().finally(() => { refreshing = null; });
+        return refreshing;
+    };
+    const authError = (message) => { const e = new AcmsError(401, 'unauthorized', message); options.onAuthError?.(e); return e; };
+    async function call(name, params = {}, o = {}) {
+        const endpoint = editorEndpoints[name];
+        const path = endpoint.path.replace(/\{(\w+)\}/g, (_, key) => {
+            const v = params[key];
+            if (!v || v === '.' || v === '..')
+                throw new TypeError(`A nonempty ${key} is required.`);
+            return encodeURIComponent(v);
+        });
+        const url = new URL(api + path);
+        for (const [k, v] of Object.entries(o.query ?? {}))
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        let token = await getToken();
+        if (!token)
+            token = await refresh();
+        if (!token)
+            throw authError('Sign in to continue.');
+        for (let attempt = 0;; attempt++) {
+            const headers = new Headers({ Accept: 'application/json', Authorization: `Bearer ${token}` });
+            if (o.body !== undefined)
+                headers.set('Content-Type', 'application/json');
+            const t = withTimeout(timeoutMs, o.signal);
+            let res;
+            try {
+                try {
+                    res = await fetcher(url.href, { method: endpoint.method, headers, credentials: 'omit', signal: t.signal,
+                        body: o.form ?? (o.body !== undefined ? JSON.stringify(o.body) : undefined) });
+                }
+                catch (error) {
+                    if (t.signal.aborted)
+                        throw t.signal.reason;
+                    // reads retry transient network failures; writes never replay blindly
+                    if (endpoint.method === 'GET' && attempt < 2) {
+                        await new Promise((r) => setTimeout(r, 250 * 2 ** attempt));
+                        continue;
+                    }
+                    throw new AcmsError(0, 'network_error', error instanceof Error ? error.message : 'Network request failed.');
+                }
+                // an expired or rotated access token: refresh once and replay (the server rejected it before doing anything)
+                if (res.status === 401 && attempt === 0) {
+                    await res.body?.cancel().catch(() => { });
+                    const next = await refresh();
+                    if (!next)
+                        throw authError('Your session ended. Sign in again.');
+                    token = next;
+                    continue;
+                }
+                let json = null;
+                try {
+                    json = await res.json();
+                }
+                catch { /* below */ }
+                if (!res.ok) {
+                    const e = new AcmsError(res.status, json?.error?.code ?? 'http_error', json?.error?.message ?? `HTTP ${res.status}`, Number(res.headers.get('Retry-After')) || undefined, json?.error?.issues);
+                    if (res.status === 401)
+                        options.onAuthError?.(e);
+                    throw e;
+                }
+                if (json?.version !== 1 || !Object.prototype.hasOwnProperty.call(json, 'data'))
+                    throw new AcmsError(res.status, 'invalid_response', 'Expected an ACMS v1 response.');
+                return json.data;
+            }
+            finally {
+                t.done();
+            }
+        }
+    }
+    const R = (o) => ({ signal: o?.signal });
+    return {
+        me: (o) => call('me', {}, R(o)),
+        listDocuments: (q = {}, o) => call('listDocuments', {}, { ...R(o), query: q }),
+        createDocument: (input, o) => call('createDocument', {}, { ...R(o), body: input }),
+        getDocument: (kind, id, o) => call('getDocument', { kind, id }, R(o)),
+        /** send the revision you loaded; 409 means someone saved first */
+        saveDocument: (kind, id, input, o) => call('saveDocument', { kind, id }, { ...R(o), body: input }),
+        publishDocument: (kind, id, revision, o) => call('publishDocument', { kind, id }, { ...R(o), body: { revision } }),
+        unpublishDocument: (kind, id, revision, o) => call('unpublishDocument', { kind, id }, { ...R(o), body: { revision } }),
+        scheduleDocument: (kind, id, revision, at, o) => call('scheduleDocument', { kind, id }, { ...R(o), body: { revision, at: at instanceof Date ? at.toISOString() : at } }),
+        discardDocument: (kind, id, revision, o) => call('discardDocument', { kind, id }, { ...R(o), body: { revision } }),
+        getDocumentTranslation: (kind, id, locale, o) => call('getDocumentTranslation', { kind, id, locale }, R(o)),
+        setDocumentTranslation: (kind, id, locale, input, o) => call('setDocumentTranslation', { kind, id, locale }, { ...R(o), body: input }),
+        reviewDocumentTranslation: (kind, id, locale, input, o) => call('reviewDocumentTranslation', { kind, id, locale }, { ...R(o), body: input }),
+        draftDocumentTranslation: (kind, id, locale, input, o) => call('draftDocumentTranslation', { kind, id, locale }, { ...R(o), body: input }),
+        listSections: (q = {}, o) => call('listSections', {}, { ...R(o), query: q }),
+        updateSection: (pageId, sectionId, input, o) => call('updateSection', { pageId, sectionId }, { ...R(o), body: input }),
+        publishSection: (pageId, sectionId, revision, o) => call('publishSection', { pageId, sectionId }, { ...R(o), body: { revision } }),
+        getSectionTranslation: (pageId, sectionId, locale, o) => call('getSectionTranslation', { pageId, sectionId, locale }, R(o)),
+        setSectionTranslation: (pageId, sectionId, locale, input, o) => call('setSectionTranslation', { pageId, sectionId, locale }, { ...R(o), body: input }),
+        reviewSectionTranslation: (pageId, sectionId, locale, input, o) => call('reviewSectionTranslation', { pageId, sectionId, locale }, { ...R(o), body: input }),
+        draftSectionTranslation: (pageId, sectionId, locale, input, o) => call('draftSectionTranslation', { pageId, sectionId, locale }, { ...R(o), body: input }),
+        listMedia: (q = {}, o) => call('listMedia', {}, { ...R(o), query: q }),
+        /** compress images on the device first (same limits as the admin: 30 MB images, 25 MB documents) */
+        uploadMedia: (file, meta = {}, o) => {
+            const form = new FormData();
+            if (typeof Blob !== 'undefined' && file instanceof Blob)
+                form.append('file', file, meta.name ?? file.name ?? 'upload');
+            else
+                form.append('file', file);
+            if (meta.alt)
+                form.append('alt', meta.alt);
+            if (meta.width)
+                form.append('width', String(meta.width));
+            if (meta.height)
+                form.append('height', String(meta.height));
+            return call('uploadMedia', {}, { ...R(o), form });
+        },
+        listBookings: (q = {}, o) => call('listBookings', {}, { ...R(o), query: q }),
+        approveBooking: (id, input = {}, o) => call('approveBooking', { id }, { ...R(o), body: input }),
+        declineBooking: (id, input = {}, o) => call('declineBooking', { id }, { ...R(o), body: input }),
+        cancelBooking: (id, input = {}, o) => call('cancelBooking', { id }, { ...R(o), body: input }),
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+import type { ApiErrorResponse } from './types.js';
+export declare class AcmsError extends Error {
+    readonly status: number;
+    readonly code: string;
+    /** Retry-After in seconds (HTTP dates are converted relative to receipt). */
+    readonly retryAfter?: number | undefined;
+    readonly issues?: ApiErrorResponse['error']['issues'];
+    /** Retain this key for a later retry if a booking result is uncertain. */
+    readonly idempotencyKey?: string | undefined;
+    constructor(status: number, code: string, message: string, 
+    /** Retry-After in seconds (HTTP dates are converted relative to receipt). */
+    retryAfter?: number | undefined, issues?: ApiErrorResponse['error']['issues'], 
+    /** Retain this key for a later retry if a booking result is uncertain. */
+    idempotencyKey?: string | undefined);
+}
+export declare const isAcmsError: (error: unknown) => error is AcmsError;

package/dist/errors.js

@@ -0,0 +1,21 @@
+export class AcmsError extends Error {
+    status;
+    code;
+    retryAfter;
+    issues;
+    idempotencyKey;
+    constructor(status, code, message, 
+    /** Retry-After in seconds (HTTP dates are converted relative to receipt). */
+    retryAfter, issues, 
+    /** Retain this key for a later retry if a booking result is uncertain. */
+    idempotencyKey) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.retryAfter = retryAfter;
+        this.issues = issues;
+        this.idempotencyKey = idempotencyKey;
+        this.name = 'AcmsError';
+    }
+}
+export const isAcmsError = (error) => error instanceof AcmsError;

package/dist/index.d.ts

@@ -0,0 +1,171 @@
+import type { Site, Theme, Page, Content, Post, ContentList, Events, Event, Calendars, Resources, Resource, Availability, BookingInput, BookingResult, Device, DeviceInput, DeviceUpdate, DeviceRegistration, DeviceRemoved, PushTopics } from './types.js';
+export { AcmsError, isAcmsError } from './errors.js';
+export type * from './types.js';
+export * from './editor.js';
+export interface RequestOptions {
+    locale?: string;
+    signal?: AbortSignal;
+}
+export interface ListOptions extends RequestOptions {
+    page?: number;
+    limit?: number; /** A page number, not an opaque server cursor. */
+    cursor?: number;
+}
+export interface ContentOptions extends ListOptions {
+    kind?: 'post' | 'page';
+    collection?: string;
+}
+export interface PostOptions extends Omit<ContentOptions, 'kind'> {
+    tag?: string;
+}
+export interface EventOptions extends ListOptions {
+    from?: string;
+    to?: string;
+    calendar?: string;
+    q?: string;
+}
+export interface AvailabilityOptions extends RequestOptions {
+    resource: string;
+    link: string;
+    from?: string;
+    days?: number;
+    minutes?: number;
+}
+export type BookOptions = BookingInput & RequestOptions & {
+    idempotencyKey?: string;
+};
+export interface ApiResponse<T> {
+    version: 1;
+    data: T;
+}
+export interface OpenApiDocument {
+    openapi: string;
+    info: Record<string, unknown>;
+    paths: Record<string, unknown>;
+    components: Record<string, unknown>;
+}
+export interface CacheEntry {
+    etag: string;
+    body: unknown;
+}
+export interface ClientCache {
+    get(url: string): CacheEntry | null | undefined | Promise<CacheEntry | null | undefined>;
+    /** null invalidates a previous entry. */
+    set(url: string, entry: CacheEntry | null): void | Promise<void>;
+}
+export interface ClientOptions {
+    /** Site origin or full /api/v1 base URL (including an optional deployment prefix). */
+    baseUrl: string;
+    locale?: string;
+    fetch?: typeof globalThis.fetch;
+    headers?: HeadersInit;
+    cache?: 'memory' | false | ClientCache;
+    /** Total deadline including retries, response reading and cache access; default 30s. */
+    timeoutMs?: number;
+}
+export declare const endpoints: {
+    readonly site: {
+        readonly method: "GET";
+        readonly path: "/site";
+    };
+    readonly theme: {
+        readonly method: "GET";
+        readonly path: "/theme";
+    };
+    readonly home: {
+        readonly method: "GET";
+        readonly path: "/pages/home";
+    };
+    readonly page: {
+        readonly method: "GET";
+        readonly path: "/pages/{slug}";
+    };
+    readonly content: {
+        readonly method: "GET";
+        readonly path: "/content";
+    };
+    readonly contentById: {
+        readonly method: "GET";
+        readonly path: "/content/{id}";
+    };
+    readonly events: {
+        readonly method: "GET";
+        readonly path: "/events";
+    };
+    readonly calendars: {
+        readonly method: "GET";
+        readonly path: "/calendars";
+    };
+    readonly resources: {
+        readonly method: "GET";
+        readonly path: "/resources";
+    };
+    readonly availability: {
+        readonly method: "GET";
+        readonly path: "/availability";
+    };
+    readonly book: {
+        readonly method: "POST";
+        readonly path: "/bookings";
+    };
+    readonly openapi: {
+        readonly method: "GET";
+        readonly path: "/openapi.json";
+    };
+    readonly registerDevice: {
+        readonly method: "POST";
+        readonly path: "/devices";
+    };
+    readonly updateDevice: {
+        readonly method: "PUT";
+        readonly path: "/devices/{token}";
+    };
+    readonly unregisterDevice: {
+        readonly method: "DELETE";
+        readonly path: "/devices/{token}";
+    };
+    readonly pushTopics: {
+        readonly method: "GET";
+        readonly path: "/push/topics";
+    };
+};
+export declare function createClient(options: ClientOptions): AcmsClient;
+export interface AcmsClient {
+    site(o?: RequestOptions): Promise<Site>;
+    theme(o?: RequestOptions): Promise<Theme>;
+    home(o?: RequestOptions): Promise<Page>;
+    page(slug: string, o?: RequestOptions): Promise<Page>;
+    content(o?: ContentOptions): Promise<ContentList>;
+    contentById(id: string, o?: RequestOptions & {
+        kind?: 'post' | 'page';
+    }): Promise<Content>;
+    posts(o?: PostOptions): Promise<ContentList>;
+    post(slug: string, o?: RequestOptions & {
+        collection?: string;
+    }): Promise<Post>;
+    pages(o?: ListOptions): Promise<ContentList>;
+    events(o?: EventOptions): Promise<Events>;
+    event(slug: string, o?: EventOptions): Promise<Event>;
+    calendars(o?: RequestOptions): Promise<Calendars>;
+    resources(o?: ListOptions): Promise<Resources>;
+    resource(slug: string, o?: RequestOptions): Promise<Resource>;
+    availability(o: AvailabilityOptions): Promise<Availability>;
+    book(o: BookOptions): Promise<BookingResult>;
+    openapi(o?: RequestOptions): Promise<OpenApiDocument>;
+    /** Register or refresh this device's Expo push token. Call on every app start. Requires push on the site. */
+    registerDevice(input: DeviceInput, o?: RequestOptions): Promise<DeviceRegistration>;
+    /** Change the device's topics or language. */
+    updateDevice(token: string, input: DeviceUpdate, o?: RequestOptions): Promise<Device>;
+    /** Opt out: removes the token from the site (idempotent). */
+    unregisterDevice(token: string, o?: RequestOptions): Promise<DeviceRemoved>;
+    /** Topics the app can offer as notification toggles. */
+    pushTopics(o?: RequestOptions): Promise<PushTopics>;
+    withLocale(locale: string): AcmsClient;
+    paginate: {
+        content(o?: ContentOptions): AsyncGenerator<ContentList['items'][number]>;
+        posts(o?: PostOptions): AsyncGenerator<ContentList['items'][number]>;
+        pages(o?: ListOptions): AsyncGenerator<ContentList['items'][number]>;
+        events(o?: EventOptions): AsyncGenerator<Events['occurrences'][number]>;
+        resources(o?: ListOptions): AsyncGenerator<Resource>;
+    };
+}