@forumulate/sdk 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -1,17 +1,18 @@
 export * from './types';
-export { verifyWebhookSignature, type VerifyWebhookInput } from './webhooks';
+export { verifyWebhookSignature, constructWebhookEvent, type VerifyWebhookInput } from './webhooks';
 export * from './content';
-export type { paths } from './schema';
+export * from './translations';
+export type { paths, operations } from './schema';
 export type { HttpMethod, MethodsOf, OperationOf, TypedRequestInit, TypedResponse } from './typed';
+export { ForumulateError, SDK_VERSION, retryDelayMs, type CallOptions, type ForumulateErrorInit, } from './http';
+export { rowsOf, type PagePromise } from './pagination';
+export type { Namespace, NamespaceName, OperationArgs, OperationFn, OperationId, OperationResult, OperationRow, PagedOperationId, Resources, } from './resources';
+export { API_VERSION } from './operations.gen';
 import type { paths } from './schema';
 import type { HttpMethod, TypedRequestInit, TypedResponse } from './typed';
-import type { Organization, Space, SpaceType, SpaceVisibility, Collection, Page, BlockDoc, SearchHit, UnifiedHit, Comment, Webhook, WebhookFormat, PublicPage, Conformance, DomainSetup, DomainSummary, Item, PageInfo, EffectiveShape, ShapeOverride } from './types';
-/** Thrown for any non-2xx API response. Mirrors the API's error envelope. */
-export declare class ForumulateError extends Error {
-    readonly status: number;
-    readonly code: string;
-    constructor(status: number, code: string, message: string);
-}
+import { type Query } from './http';
+import { type PositionalHelpers } from './helpers';
+import { type Merged, type Namespace, type OperationArgs, type OptionalArgsOperationId, type OperationId, type OperationReturn, type OperationRow, type PagedOperationId, type Resources } from './resources';
 export interface ForumulateClientOptions {
     /** API base, `https://forumulate.com/api` for the hosted product (see `fromEnv`). */
     baseUrl: string;
@@ -33,25 +34,57 @@ export interface ForumulateClientOptions {
      * from the SDK that advertised it.
      */
     headers?: Record<string, string>;
+    /**
+     * The `Forumulate-Version` to state. The namespace methods and
+     * `request(operationId)` always state one — this, or {@link API_VERSION}
+     * (the version the SDK was generated against) — because auto-pagination reads
+     * the envelope only a versioned answer carries. The 0.5 positional helpers,
+     * `typed()` and `request(method, path)` send it only when you set it here,
+     * so code written against them sees exactly the answers it always saw.
+     */
+    apiVersion?: string;
+    /**
+     * Retries for 408/429/502/503/504 and network failures. Default 2. Only
+     * requests that are safe to repeat are retried: GET/PUT/DELETE, and writes
+     * carrying an `Idempotency-Key`. `Retry-After` is honoured.
+     */
+    maxRetries?: number;
+    /**
+     * Give every POST and PATCH a generated `Idempotency-Key` (the same one on
+     * each of its retries), so a write that timed out can be retried without
+     * running twice. Default true; a key you pass always wins.
+     */
+    autoIdempotencyKey?: boolean;
+    /**
+     * The `User-Agent` outside a browser. Default `forumulate-sdk-js/<version>`:
+     * the edge challenges default library agents, which reads as an outage to a
+     * first-time integration. Ignored where the runtime forbids the header.
+     */
+    userAgent?: string;
 }
-type Query = Record<string, string | number | boolean | undefined>;
+type HandWritten = keyof PositionalHelpers | 'content';
 /**
  * Typed client for the Forumulate REST API.
  *
  * ```ts
  * const forumulate = new ForumulateClient({ baseUrl: 'https://forumulate.com/api', token: pat });
- * const { orgs } = await forumulate.orgs.list();
+ *
+ * for await (const post of forumulate.blog.list({ orgId, spaceId })) console.log(post);
+ * await forumulate.webhooks.rotate({ orgId, webhookId });
+ * await forumulate.request('Space_get', { orgId, spaceId });
  *
  * // or, from FORUMULATE_TOKEN / FORUMULATE_URL:
  * const fromEnv = ForumulateClient.fromEnv();
  * ```
+ *
+ * Every operation in the API is a method: `client.<namespace>[.<sub>].<method>`,
+ * named after its operationId (`ForumTopics_list` → `forum.topics.list`).
  */
+export interface ForumulateClient extends Omit<Resources, HandWritten> {
+}
 export declare class ForumulateClient {
-    private readonly baseUrl;
-    private readonly token?;
-    private readonly credentials;
-    private readonly defaultHeaders;
-    private readonly _fetch;
+    private readonly transport;
+    private readonly apiVersion?;
     constructor(opts: ForumulateClientOptions);
     /**
      * A client configured from the environment, by the same names the CLI and
@@ -67,7 +100,18 @@ export declare class ForumulateClient {
      * anything in `opts` overrides what the environment said.
      */
     static fromEnv(env?: Record<string, string | undefined>, opts?: Partial<ForumulateClientOptions>): ForumulateClient;
-    /** Low-level request. Exposed so callers can reach endpoints the typed helpers don't cover yet. */
+    /**
+     * Call any operation by its operationId, fully typed:
+     *
+     * ```ts
+     * const { space } = await forumulate.request('Space_get', { orgId, spaceId });
+     * ```
+     *
+     * The two-string form `request(method, path, opts)` is the untyped escape
+     * hatch it has always been.
+     */
+    request<K extends OptionalArgsOperationId>(operationId: K, args?: OperationArgs<NoInfer<K>>): OperationReturn<K>;
+    request<K extends OperationId>(operationId: K, args: OperationArgs<NoInfer<K>>): OperationReturn<K>;
     request<T>(method: string, path: string, opts?: {
         body?: unknown;
         query?: Query;
@@ -75,55 +119,37 @@ export declare class ForumulateClient {
         headers?: Record<string, string>;
     }): Promise<T>;
     /**
-     * Fully-typed request against ANY endpoint in the OpenAPI spec.
+     * Every row of a paged operation, across every page — the same walk a
+     * namespace `list` gives, by operationId.
+     *
+     * ```ts
+     * for await (const space of forumulate.paginate('Space_list', { orgId })) { … }
+     * ```
+     */
+    paginate<K extends PagedOperationId & OptionalArgsOperationId>(operationId: K, args?: OperationArgs<NoInfer<K>>): AsyncIterable<OperationRow<K>>;
+    paginate<K extends PagedOperationId>(operationId: K, args: OperationArgs<NoInfer<K>>): AsyncIterable<OperationRow<K>>;
+    /**
+     * Fully-typed request against ANY endpoint in the OpenAPI spec, by path.
      *
-     * Where the ~30 hand-written helpers above cover the stable, ergonomic
-     * surface, `typed` covers the *whole* API: the generated `paths` interface
-     * (`src/schema.ts`, produced from `openapi.json`) infers the path params,
-     * query params, JSON body and success response for the `(method, path)` you
-     * pass, so every one of the 600+ routes gets types and autocomplete without a
-     * bespoke wrapper. Path templates like `/orgs/{orgId}/spaces` are filled from
-     * `init.params`.
+     * The generated `paths` interface (`src/schema.ts`, produced from
+     * `openapi.json`) infers the path params, query params, JSON body and success
+     * response for the `(method, path)` you pass. Path templates like
+     * `/orgs/{orgId}/spaces` are filled from `init.params`.
      *
      * ```ts
-     * // GET a list — path param is required and checked; response is typed.
      * const { spaces } = await forumulate.typed('get', '/orgs/{orgId}/spaces', {
-     *   params: { orgId }, query: { deleted: 'false', limit: '50', cursor: '' },
-     * });
-     *
-     * // POST with a body the spec knows the shape of.
-     * await forumulate.typed('post', '/orgs/{orgId}/spaces', {
-     *   params: { orgId },
-     *   body: { name: 'Docs', slug: 'docs', type: 'DOCS', visibility: 'PUBLIC' },
+     *   params: { orgId }, query: { limit: 50 },
      * });
      * ```
-     *
-     * Regenerate the types after an API change with
-     * `pnpm --filter @forumulate/sdk dump-spec` then
-     * `npx openapi-typescript packages/sdk/openapi.json -o src/schema.ts`.
      */
     typed<P extends keyof paths, M extends keyof paths[P] & HttpMethod>(method: M, path: P, init: TypedRequestInit<paths[P][M]>): Promise<TypedResponse<paths[P][M]>>;
-    private toError;
-    readonly auth: {
-        register: (input: {
-            email: string;
-            name: string;
-            password: string;
-        }) => Promise<{
-            user: {
-                id: string;
-                email: string;
-            };
-        }>;
-        login: (input: {
-            email: string;
-            password: string;
-        }) => Promise<{
-            user: {
-                id: string;
-                email: string;
-            };
-        }>;
+    /** The 0.5 door: no version stated unless the client pins one. */
+    private http;
+    /** The generated door: path filled from the args, version always stated, lists iterable. */
+    private readonly invoke;
+    private ns;
+    private readonly helpers;
+    readonly auth: Merged<Namespace<"auth">, {
         me: () => Promise<{
             user: {
                 id: string;
@@ -131,7 +157,6 @@ export declare class ForumulateClient {
                 name: string;
             };
         }>;
-        /** Mint a Personal Access Token (requires an authenticated session). */
         createToken: (input: {
             name: string;
             scopes?: string[];
@@ -142,8 +167,8 @@ export declare class ForumulateClient {
                 name: string;
             };
         }>;
-    };
-    readonly content: {
+    }>;
+    readonly content: Merged<Namespace<"content">, {
         libraries: {
             list: (orgId: string) => Promise<{
                 libraries: import("./content").ContentLibrary[];
@@ -310,65 +335,208 @@ export declare class ForumulateClient {
                 ok: true;
             }>;
         };
+    }>;
+    /** Translations of every kind of piece, routed by space type — see ./translations. */
+    readonly translations: {
+        locales: {
+            list: (orgId: string, target: import("./translations").LocaleTarget) => Promise<import("./translations").TranslationLocale[]>;
+            add: (orgId: string, target: import("./translations").LocaleTarget, input: {
+                code: string;
+                label: string;
+            }) => Promise<{
+                code: string;
+                label: string;
+                isSource: boolean;
+            }[]>;
+            relabel: (orgId: string, target: import("./translations").LocaleTarget, code: string, label: string) => Promise<{
+                code: string;
+                label: string;
+                isSource: boolean;
+            }[]>;
+            remove: (orgId: string, target: import("./translations").LocaleTarget, code: string) => Promise<{
+                code: string;
+                label: string;
+                isSource: boolean;
+            }[]>;
+            set: (orgId: string, target: import("./translations").LocaleTarget, want: {
+                code: string;
+                label: string;
+            }[], opts?: {
+                prune?: boolean;
+            }) => Promise<{
+                locales: import("./translations").TranslationLocale[];
+                added: string[];
+                relabeled: string[];
+                removed: string[];
+            }>;
+        };
+        status: (orgId: string, spaceId: string) => Promise<import("./translations").TranslationCoverage>;
+        list: (orgId: string, spaceId: string, pieceId: string, opts?: {
+            door?: import("./translations").TranslationDoor;
+        }) => Promise<{
+            translations: unknown[];
+        }>;
+        get: (orgId: string, spaceId: string, pieceId: string, locale: string, opts?: {
+            door?: import("./translations").TranslationDoor;
+        }) => Promise<import("./translations").PieceTranslation>;
+        put: (orgId: string, spaceId: string, pieceId: string, locale: string, input: import("./translations").PieceTranslationInput, opts?: {
+            door?: import("./translations").TranslationDoor;
+        }) => Promise<import("./translations").PieceTranslation>;
+        remove: (orgId: string, spaceId: string, pieceId: string, locale: string, opts?: {
+            door?: import("./translations").TranslationDoor;
+        }) => Promise<void>;
+        auto: (orgId: string, spaceId: string, pieceId: string, locale: string, opts?: import("./translations").AutoTranslateOptions & {
+            door?: import("./translations").TranslationDoor;
+        }) => Promise<{
+            translation: unknown;
+        }>;
+        autoEntry: (orgId: string, libraryId: string, entryId: string, locale: string, opts?: {
+            force?: boolean;
+        }) => Promise<{
+            locale: string;
+            results: {
+                entryId: string;
+                ok: boolean;
+                translationEntryId: string | null;
+                error: string | null;
+            }[];
+        }>;
+        setItemLocale: (orgId: string, spaceId: string, itemId: string, locale: string | null) => Promise<{
+            item: {
+                id: string;
+                locale?: string | null;
+            };
+        }>;
+        names: {
+            get: (orgId: string, spaceId: string, opts?: {
+                collectionId?: string;
+            }) => Promise<import("./translations").NamedTranslations>;
+            set: (orgId: string, spaceId: string, locale: string, words: {
+                name?: string;
+                description?: string;
+            } | null, opts?: {
+                collectionId?: string;
+            }) => Promise<import("./translations").NamedTranslations>;
+        };
+        entryLocale: {
+            get: (orgId: string, libraryId: string, entryId: string, locale: string) => Promise<{
+                entryId: string;
+                locale: string;
+                fields: Record<string, unknown>;
+            }>;
+            put: (orgId: string, libraryId: string, entryId: string, locale: string, fields: Record<string, unknown>) => Promise<{
+                locale: string;
+                sourceEntryId: string;
+                entryId: string;
+                created: boolean;
+            }>;
+        };
+        labels: {
+            strings: (orgId: string, scope: import("./translations").LabelScope) => Promise<{
+                languages: string[];
+                labels: import("./translations").LabelDictionary;
+                strings: unknown[];
+                coverage: Record<string, {
+                    translated: number;
+                    total: number;
+                }>;
+            }>;
+            replace: (orgId: string, scope: import("./translations").LabelScope, labels: import("./translations").LabelDictionary) => Promise<{
+                labels: import("./translations").LabelDictionary;
+            }>;
+            merge: (orgId: string, scope: import("./translations").LabelScope, labels: Record<string, Record<string, unknown> | null>) => Promise<{
+                labels: import("./translations").LabelDictionary;
+            }>;
+        };
+        overrides: {
+            list: (orgId: string, locale?: string) => Promise<{
+                overrides: import("./translations").TranslationOverride[];
+            }>;
+            set: (orgId: string, input: {
+                locale: string;
+                key: string;
+                value: string;
+            }) => Promise<{
+                override: import("./translations").TranslationOverride;
+            }>;
+            remove: (orgId: string, input: {
+                locale: string;
+                key: string;
+            }) => Promise<{
+                ok: true;
+            }>;
+            catalog: (orgId: string) => Promise<{
+                catalog: Record<string, string>;
+            }>;
+            forLocale: (orgId: string, locale: string) => Promise<{
+                overrides: Record<string, string>;
+            }>;
+        };
+        switcher: {
+            get: (orgId: string) => Promise<Record<string, unknown>>;
+            set: (orgId: string, config: Record<string, unknown>) => Promise<Record<string, unknown>>;
+        };
+        deepl: {
+            status: (orgId: string) => Promise<{
+                configured: boolean;
+            }>;
+            connect: (orgId: string, apiKey: string) => Promise<{
+                ok: true;
+            }>;
+            disconnect: (orgId: string) => Promise<{
+                ok: true;
+            }>;
+        };
     };
-    readonly orgs: {
+    readonly orgs: Merged<Namespace<"orgs">, {
         list: () => Promise<{
-            orgs: Organization[];
+            orgs: import("./types").Organization[];
         }>;
         create: (input: {
             name: string;
             slug: string;
         }) => Promise<{
-            organization: Organization;
+            organization: import("./types").Organization;
         }>;
-    };
-    readonly spaces: {
+    }>;
+    readonly spaces: Merged<Namespace<"spaces">, {
         list: (orgId: string) => Promise<{
-            spaces: Space[];
+            spaces: import("./types").Space[];
         }>;
         create: (orgId: string, input: {
             name: string;
             slug: string;
-            type: SpaceType;
-            visibility: SpaceVisibility;
+            type: import("./types").SpaceType;
+            visibility: import("./types").SpaceVisibility;
         }) => Promise<{
-            space: Space;
+            space: import("./types").Space;
         }>;
         createCollection: (orgId: string, spaceId: string, input: {
             name: string;
             slug: string;
         }) => Promise<{
-            collection: Collection;
+            collection: import("./types").Collection;
         }>;
         createPage: (orgId: string, spaceId: string, collectionId: string, input: {
             title: string;
             slug: string;
         }) => Promise<{
-            page: Page;
+            page: import("./types").Page;
         }>;
         setPageContent: (orgId: string, spaceId: string, pageId: string, input: {
             title: string;
-            content: BlockDoc;
+            content: import("./types").BlockDoc;
         }) => Promise<{
-            page: Page;
+            page: import("./types").Page;
         }>;
         publishPage: (orgId: string, spaceId: string, pageId: string) => Promise<{
-            page: Page;
+            page: import("./types").Page;
         }>;
-    };
-    /**
-     * Shapes and pieces — the surface an agent works through.
-     *
-     * `shape` says what one piece of a space is made of and hands back JSON
-     * Schema; `items` writes one, whatever a piece happens to be in that space:
-     * a documentation page, a blog post, a release, an incident. The reply says
-     * which required sections are still empty, so an agent can create a piece,
-     * ask what it forgot, and close the gap.
-     */
-    readonly shapes: {
+    }>;
+    readonly shapes: Merged<Namespace<"shapes">, {
         get: (orgId: string, spaceId: string) => Promise<{
-            shape: EffectiveShape;
-            base: EffectiveShape;
+            shape: import("./types").EffectiveShape;
+            base: import("./types").EffectiveShape;
             presets: {
                 name: string;
                 label: string;
@@ -376,133 +544,91 @@ export declare class ForumulateClient {
             }[];
             jsonSchema: Record<string, unknown>;
         }>;
-        set: (orgId: string, spaceId: string, patch: ShapeOverride) => Promise<{
-            shape: EffectiveShape;
+        set: (orgId: string, spaceId: string, patch: import("./types").ShapeOverride) => Promise<{
+            shape: import("./types").EffectiveShape;
         }>;
         applyPreset: (orgId: string, spaceId: string, name: string) => Promise<{
-            shape: EffectiveShape;
+            shape: import("./types").EffectiveShape;
         }>;
-    };
-    readonly items: {
+    }>;
+    readonly items: Merged<Namespace<"items">, {
         create: (orgId: string, spaceId: string, input: {
             title: string;
             slug?: string;
-            /** Which kind of piece, where the space holds more than one. */
             preset?: string | null;
             sections?: Record<string, string>;
             body?: string;
             params?: Record<string, unknown>;
         }) => Promise<{
-            item: Item;
-        }>;
-        /**
-         * What is in a space: how something finds a piece it has no words for.
-         *
-         * Pass `include: ['body']` to get content. Asking for `sections` ALONE is
-         * the trap: it is populated only for pieces written against a shape, so a
-         * space of free-form pages answers with empty objects and a sync carries
-         * nothing while reporting success. Every row says which field holds its
-         * content in `contentIn`.
-         *
-         * Any option here puts the response in its paged form, so `page` and
-         * `sync` come back — `page.total` is what a walk should check its own
-         * count against, and `sync.checkpoint` is what an incremental sync stores.
-         */
+            item: import("./types").Item;
+        }>;
         list: (orgId: string, spaceId: string, opts?: number | {
             limit?: number;
             include?: ("sections" | "body")[];
             cursor?: string;
-            /** A `sync.checkpoint` from a previous walk, not a timestamp you made. */
             updatedSince?: string;
             includeDeleted?: boolean;
             fields?: string[];
         }) => Promise<{
-            items: Item[];
-            page?: PageInfo;
+            items: import("./types").Item[];
+            page?: import("./types").PageInfo;
             sync?: {
                 checkpoint: string;
             };
         }>;
         get: (orgId: string, spaceId: string, itemId: string) => Promise<{
-            item: Item & {
+            item: import("./types").Item & {
                 sections: Record<string, string>;
             };
         }>;
-        /**
-         * Make it readable. Kinds that are live on creation say so and change nothing.
-         *
-         * `conformance` describes the piece AFTER publishing — which declared slots
-         * are filled and which are still missing — so an agent that has just made
-         * its work readable can tell a complete piece from one with holes in it
-         * without fetching it again. The server has always sent it and this type
-         * omitted it, so a TypeScript caller could not see the field the docs
-         * promise (E-11).
-         */
         publish: (orgId: string, spaceId: string, itemId: string) => Promise<{
             published: boolean;
             note?: string;
-            conformance: Conformance;
-        }>;
-        /**
-         * Replace a piece's whole body — as markdown, or as blocks.
-         *
-         * The create door has always taken markdown and this one took blocks only,
-         * so "make it from this file" worked and "update it from the same file" did
-         * not. Both now; blocks win if a caller sends both.
-         */
+            conformance: import("./types").Conformance;
+        }>;
         setContent: (orgId: string, spaceId: string, itemId: string, input: {
             body?: string;
-            content?: BlockDoc;
+            content?: import("./types").BlockDoc;
         }) => Promise<{
-            conformance: Conformance;
+            conformance: import("./types").Conformance;
         }>;
-        /** Replace one named section. Idempotent — sending it twice writes it once. */
         setSection: (orgId: string, spaceId: string, itemId: string, key: string, markdown: string) => Promise<{
-            conformance: Conformance;
+            conformance: import("./types").Conformance;
         }>;
-    };
-    /**
-     * The addresses a space answers at.
-     *
-     * Published because the question a customer asks about a custom domain —
-     * "why is it not live yet" — is answerable only from `verified`, `active` and
-     * the setup records, and the SDK could not reach any of them (DX-2). A failed
-     * verification is a 200 with `verified: false`: read the body, not the status.
-     */
-    readonly domains: {
+    }>;
+    readonly domains: Merged<Namespace<"domains">, {
         list: (orgId: string, spaceId: string) => Promise<{
-            domains: DomainSummary[];
+            domains: import("./types").DomainSummary[];
         }>;
         add: (orgId: string, spaceId: string, input: {
             hostname: string;
             basePath?: string;
         }) => Promise<{
-            domain: DomainSummary;
+            domain: import("./types").DomainSummary;
         }>;
-        /** Re-run the ownership check. `activate: false` proves it without switching traffic. */
         verify: (orgId: string, spaceId: string, domainId: string, activate?: boolean) => Promise<{
-            domain: DomainSummary;
+            domain: import("./types").DomainSummary;
         }>;
-        /** Switch traffic to an address whose ownership is already proven. */
         activate: (orgId: string, spaceId: string, domainId: string) => Promise<{
-            domain: DomainSummary;
+            domain: import("./types").DomainSummary;
         }>;
-        /** What to configure, and what is still missing. */
-        setup: (orgId: string, spaceId: string, domainId: string) => Promise<DomainSetup>;
-    };
-    readonly webhooks: {
+        setup: (orgId: string, spaceId: string, domainId: string) => Promise<import("./types").DomainSetup>;
+    }>;
+    readonly webhooks: Merged<Namespace<"webhooks">, {
         list: (orgId: string) => Promise<{
-            webhooks: Webhook[];
+            webhooks: import("./types").Webhook[];
         }>;
         create: (orgId: string, input: {
             url: string;
             events: string[];
-            format?: WebhookFormat;
+            format?: import("./types").WebhookFormat;
         }) => Promise<{
-            webhook: Webhook;
+            webhook: import("./types").Webhook;
         }>;
-    };
-    readonly snapshots: {
+        verifySignature: typeof import("./webhooks").verifyWebhookSignature;
+        constructEvent: typeof import("./webhooks").constructWebhookEvent;
+    }>;
+    readonly snapshots: Merged<Namespace<"snapshots">, {
         list: (orgId: string, spaceId: string) => Promise<{
             snapshots: unknown[];
         }>;
@@ -513,8 +639,8 @@ export declare class ForumulateClient {
             restored: number;
             skipped: number;
         }>;
-    };
-    readonly forum: {
+    }>;
+    readonly forum: Merged<Namespace<"forum">, {
         listTopics: (orgId: string, spaceId: string, query?: {
             sort?: string;
             category?: string;
@@ -525,48 +651,47 @@ export declare class ForumulateClient {
         }>;
         createTopic: (orgId: string, spaceId: string, input: {
             title: string;
-            content: BlockDoc;
+            content: import("./types").BlockDoc;
             kind?: string;
             tags?: string[];
             categoryId?: string | null;
         }) => Promise<{
             topic: unknown;
         }>;
-        reply: (orgId: string, spaceId: string, topicId: string, content: BlockDoc) => Promise<{
+        reply: (orgId: string, spaceId: string, topicId: string, content: import("./types").BlockDoc) => Promise<{
             post: unknown;
         }>;
-    };
-    readonly search: {
+    }>;
+    readonly search: Merged<Namespace<"search">, {
         unified: (orgId: string, q: string, opts?: {
             type?: string;
             limit?: number;
         }) => Promise<{
-            hits: UnifiedHit[];
+            hits: import("./types").UnifiedHit[];
         }>;
-    };
-    readonly analytics: {
+    }>;
+    readonly analytics: Merged<Namespace<"analytics">, {
         orgEvents: (orgId: string, days?: number) => Promise<unknown>;
-    };
-    readonly public: {
-        getPage: (orgId: string, spaceId: string, pageId: string) => Promise<PublicPage>;
+    }>;
+    readonly public: Merged<Namespace<"public">, {
+        getPage: (orgId: string, spaceId: string, pageId: string) => Promise<import("./types").PublicPage>;
         search: (orgId: string, spaceId: string, query: string) => Promise<{
-            hits: SearchHit[];
+            hits: import("./types").SearchHit[];
         }>;
         listComments: (orgId: string, spaceId: string, pageId: string) => Promise<{
-            comments: Comment[];
+            comments: import("./types").Comment[];
         }>;
         postComment: (orgId: string, spaceId: string, pageId: string, input: {
             authorName: string;
             body: string;
             parentId?: string | null;
         }) => Promise<{
-            comment: Comment;
+            comment: import("./types").Comment;
         }>;
         reactToComment: (orgId: string, spaceId: string, commentId: string, emoji: string) => Promise<{
-            comment: Comment;
+            comment: import("./types").Comment;
         }>;
-        /** Download the whole space as a PDF. Returns the raw `Response` (read `.blob()` / `.arrayBuffer()`). */
         pdf: (orgId: string, spaceId: string) => Promise<Response>;
-    };
+    }>;
 }
 //# sourceMappingURL=index.d.ts.map