@b10cks/client 1.2.2 → 1.4.0

package/README.md

@@ -16,68 +16,256 @@ import { ApiClient, createB10cksDataApi } from '@b10cks/client'
 const client = new ApiClient({
   baseUrl: 'https://api.b10cks.com/api',
   token: 'your-access-token',
-  fetchClient: fetch,
+  version: 'published', // 'published' (default) or 'draft'
+  rv: 0,               // revision token — pass Date.now() to bypass CDN cache
 })
 
+// Factory function — equivalent to new B10cksDataApi(client)
 const dataApi = createB10cksDataApi(client)
+// or: import { B10cksDataApi } from '@b10cks/client'; const dataApi = new B10cksDataApi(client)
 
-// Fetch blocks
-const blocks = await dataApi.getBlocks()
-
-// Fetch the first page of contents
+// Fetch a page of contents
 const contents = await dataApi.getContents({ vid: 'published', page: 1, per_page: 20 })
 
 // Fetch all contents across all pages
-const allContents = await dataApi.getContents(
-  { vid: 'published', per_page: 100 },
-  { allPages: true }
-)
+const allContents = await dataApi.getContents({ vid: 'published' }, { allPages: true })
 
-// Fetch a specific content entry
+// Fetch a single content entry by slug
 const content = await dataApi.getContent('home', { vid: 'draft' })
 
-// Fetch specific datasource entries
-const entries = await dataApi.getDataEntries('my-datasource')
+// Fetch a single block by ID
+const block = await dataApi.getBlock('block-id')
+
+// Full-text search
+const results = await dataApi.search({ q: 'hello world', language: 'en' })
 
-// Fetch sitemap entries
-const sitemap = await dataApi.getSitemap({ vid: 'published' })
+// Redirect lookup (POST)
+const redirect = await dataApi.lookupRedirect('/old-path')
+if (redirect) {
+  console.log(redirect.target, redirect.status_code)
+}
 ```
 
-## Features
+## Typed Filters
 
-- **Simple HTTP Client**: Type-safe API client for b10cks endpoints
-- **Framework-Agnostic Data API**: Shared `B10cksDataApi` used by all framework SDKs
-- **Pagination Support**: Fetch a specific page by default, or opt into fetching all pages
-- **Revision Tracking**: Built-in support for revision (RV), with VID passed explicitly in request params
-- **Flexible Fetch**: Use browser fetch, Node fetch, or a custom fetch implementation
+`getContents`, `getBlocks`, and `getRedirects` accept a `filter` object whose fields map directly to the Laravel AdvancedFilter query-param scheme. Filter values can be plain values, operator objects, or date ranges — they are serialized to the wire format (`op:value`) automatically.
+
+```typescript
+import { serializeFilter } from '@b10cks/client'
 
-## API Methods
+// Typed filter on getContents
+const contents = await dataApi.getContents({
+  filter: {
+    language: 'en',
+    content_type: 'article',
+    published_at: { gte: '2024-01-01T00:00:00Z' },
+    parent_id: { in: ['id-1', 'id-2'] },
+    include_fallback: true,
+  },
+  sort: ['-published_at', 'content.title'],
+})
 
-- `get<T>(endpoint, params)` - Fetch single page of data
-- `getAll<T>(endpoint, params)` - Fetch all data across pages
+// Typed filter on getBlocks
+const blocks = await dataApi.getBlocks({
+  filter: {
+    is_nestable: true,
+    tags: ['hero', 'banner'],
+    updated_at: { between: ['2024-01-01T00:00:00Z', '2024-12-31T23:59:59Z'] },
+  },
+})
+
+// Typed filter on getRedirects
+const redirectMap = await dataApi.getRedirects({
+  filter: { source: { '^like': '/blog' } },
+})
+```
+
+### Filter operators
+
+| Operator object | Wire format | Meaning |
+|---|---|---|
+| `'value'` | `value` | Exact match |
+| `{ eq: 'v' }` | `eq:v` | Exact match |
+| `{ neq: 'v' }` | `neq:v` | Not equal |
+| `{ in: ['a','b'] }` | `in:a,b` | One of |
+| `{ '!in': ['a','b'] }` | `!in:a,b` | None of |
+| `{ like: 'v' }` | `like:v` | Contains |
+| `{ '!like': 'v' }` | `!like:v` | Does not contain |
+| `{ '^like': 'v' }` | `^like:v` | Starts with |
+| `{ 'like$': 'v' }` | `like$:v` | Ends with |
+| `{ gte: 'v' }` | `gte:v` | Greater than or equal |
+| `{ gt: 'v' }` | `gt:v` | Greater than |
+| `{ lte: 'v' }` | `lte:v` | Less than or equal |
+| `{ lt: 'v' }` | `lt:v` | Less than |
+| `{ between: ['a','b'] }` | `a...b` | Range (dates) |
+| `{ null: true }` | `null:` | Is null |
+| `{ '!null': true }` | `!null:` | Is not null |
+
+### Content sort
+
+`sort` accepts a string or a typed array of `ContentSortItem` values. Prefix with `-` for descending order. JSON content fields are supported via `content.{field}`.
+
+```typescript
+sort: '-published_at'          // single field, descending
+sort: ['updated_at', '-created_at']
+sort: ['content.title', '-published_at']
+```
+
+### `serializeFilter` utility
+
+If you need the flat query params for your own requests, `serializeFilter` is exported:
+
+```typescript
+import { serializeFilter } from '@b10cks/client'
+
+const params = serializeFilter({
+  language: 'en',
+  published_at: { gte: '2024-01-01T00:00:00Z' },
+  id: { in: ['a', 'b'] },
+})
+// → { language: 'en', published_at: 'gte:2024-01-01T00:00:00Z', id: 'in:a,b' }
+```
 
 ## Data API Methods
 
-- `getContent(fullSlug, params)` - pass `vid` in `params` when needed
-- `getContents(params, options)` - `params` supports `page` and `per_page`; set `options.allPages` to `true` to fetch every page
-- `getBlocks(params, options)` - `params` supports `page` and `per_page`
-- `getDataEntries(source, params, options)` - `params` supports `page` and `per_page`
-- `getDataSources(params, options)` - `params` supports `page` and `per_page`
-- `getSitemap(params, options)` - pass `vid` in `params`; `params` also supports `page` and `per_page`
-- `getSpace(params)`
-- `getRedirects(params, forceRefresh | { forceRefresh?, allPages? })` - `params` supports `page` and `per_page`
-- `getConfig(options)`
-- `syncRevision(fallbackRv)`
+| Method | Description |
+|---|---|
+| `getContent(slug, params)` | Single content entry by full slug |
+| `getContents(params, options)` | List of content entries |
+| `getBlock(blockId, params)` | Single block by ID |
+| `getBlocks(params, options)` | List of blocks |
+| `search(params)` | Full-text content search (`q`, `limit`, `offset`, `language`) |
+| `lookupRedirect(source)` | POST redirect lookup for a given source path |
+| `getRedirects(params, options)` | Redirect map (cached when `allPages: true`) |
+| `getDataEntries(source, params, options)` | Entries for a data source slug |
+| `getDataSources(params, options)` | List of data sources |
+| `getSitemap(params, options)` | Sitemap entries |
+| `getSpace(params)` | Current space info |
+| `getConfig(options)` | Config content entry (cached) |
+| `syncRevision(fallbackRv)` | Sync local RV from the space |
+| `clearCache()` | Clear redirect and config caches |
+
+Pass `{ allPages: true }` as the second argument to any collection method to fetch every page automatically.
+
+## `ApiClient` configuration
+
+```typescript
+interface B10cksApiClientOptions {
+  baseUrl: string                    // Base URL of the b10cks data API (include `/api`)
+  token: string                      // Space access token
+  version?: 'published' | 'draft'   // Content version to fetch (default: 'published')
+  rv?: string | number               // Revision token; use Date.now() to bypass CDN cache
+  fetchClient?: FetchClient          // Custom fetch implementation (required in environments without globalThis.fetch)
+  getRv?: () => string | number      // Custom getter for the shared revision token
+  setRv?: (value: string | number) => void  // Custom setter for the shared revision token
+}
+```
+
+## Low-level `ApiClient`
+
+`ApiClient` implements the `DataApiClient` interface and can be used directly for one-off requests:
+
+```typescript
+const client = new ApiClient({ baseUrl, token })
+
+// GET with custom params — all extra keys are forwarded as query params as-is
+const data = await client.get('contents', { page: 1, language_iso: 'de', vid: 'published' })
+
+// Per-request rv override — pass rv in params to override the instance-level revision token
+// (useful to bypass CDN cache for a single request without affecting other calls)
+const fresh = await client.get('contents', { rv: Date.now() })
+
+// GET all pages
+const all = await client.getAll('blocks')
+
+// POST (e.g. redirects/lookup)
+const result = await client.post('redirects/lookup', { source: '/old' })
+```
 
 ## Supported Endpoints
 
-- `blocks` - Content blocks
-- `contents` - Content items
-- `contents/{id}` - Specific content
-- `datasources` - Data sources
-- `datasources/{id}/entries` - Datasource entries
-- `sitemap` - Sitemap entries
-- `spaces/me` - Current space info
+| Endpoint | Methods |
+|---|---|
+| `blocks` | GET (list) |
+| `blocks/{id}` | GET (single) |
+| `contents` | GET (list) |
+| `contents/{slug}` | GET (single) |
+| `datasources` | GET (list) |
+| `datasources/{slug}/entries` | GET (list) |
+| `redirects` | GET (list) |
+| `redirects/lookup` | POST |
+| `search` | GET |
+| `sitemap` | GET (list) |
+| `spaces/me` | GET |
+
+## Link resolution
+
+`resolveB10cksLink` converts a `B10cksLink` value (the union type emitted by the type generator for `link`-type fields) into a plain `{ href, target }` object. Locale prefixing and router integration are left to the caller.
+
+```typescript
+import { resolveB10cksLink } from '@b10cks/client'
+
+const resolved = resolveB10cksLink(block.ctaLink)
+// resolved: { href: 'https://example.com', target: '_blank' }
+// or:       { href: 'mailto:hi@example.com', target: '_self' }
+// or:       undefined  (when link is nullish or type === 'asset')
+```
+
+## Sitemap utilities
+
+Framework-agnostic helpers for building multilingual sitemaps from `IBSitemapEntry[]`.
+
+```typescript
+import {
+  buildLocalizedPath,
+  filterSitemapEntries,
+  renderSitemapXml,
+  renderSitemapIndex,
+} from '@b10cks/client'
+
+// Build a rooted locale-prefixed path from a content entry
+buildLocalizedPath('about', 'en')   // → '/en/about'
+buildLocalizedPath('home', 'en')    // → '/en'
+buildLocalizedPath('de/uber-uns', 'de')  // → '/de/uber-uns'  (no double prefix)
+
+// Filter: deduplicate, drop noindex, optionally restrict to one locale
+const filtered = filterSitemapEntries(entries, {
+  siteUrl: 'https://example.com',
+  locale: 'en',
+})
+
+// Render <urlset> XML
+const xml = renderSitemapXml(filtered, 'https://example.com')
+
+// Render <sitemapindex> XML for multi-sitemap setups
+const index = renderSitemapIndex(['/sitemap-en.xml', '/sitemap-de.xml'], 'https://example.com')
+```
+
+## TypeScript
+
+Common types exported from the package root:
+
+```typescript
+import type {
+  B10cksLink,          // Union type for link fields (url | email | internal | asset)
+  B10cksLinkResolved,  // Return type of resolveB10cksLink
+  IBContent,           // A content entry (generic: IBContent<YourContentShape>)
+  IBContentBlock,      // Base block shape with id and block fields
+  IBBlock,             // A block schema
+  IBDataEntry,         // A data source entry (key/value)
+  IBDataSource,        // A data source definition
+  IBSitemapEntry,      // Sitemap entry with full_slug, language_iso, meta, published_at
+  IBSeoMeta,           // robots and canonical fields
+  IBSpace,             // Space info
+  IBRedirect,          // Redirect rule (source, target, status_code)
+  IBSearchResult,      // Search result extending IBContent with relevance_score
+  IBSearchResponse,    // Wrapper around IBSearchResult[]
+  IBCollectionResponse,// Paginated list envelope
+  IBMeta,              // Pagination metadata (total, last_page, per_page, …)
+  IBResponse,          // Single-item envelope { data, rv }
+  B10cksApiClientOptions,
+} from '@b10cks/client'
+```
 
 ## License
 

package/dist/index.d.ts

@@ -6,8 +6,9 @@ export declare class ApiClient {
     private readonly getRvFn?;
     private readonly setRvFn?;
     constructor(options: B10cksApiClientOptions, requestUrl?: URL | string);
-    get<T>(endpoint: Endpoint, params?: Omit<IBBaseQueryParams, 'token'>): Promise<ApiResourceResponse<T>>;
-    getAll<T>(endpoint: Endpoint, params?: Omit<IBBaseQueryParams, 'token'>): Promise<T[]>;
+    get<T>(endpoint: Endpoint, params?: Omit<IBBaseQueryParams, 'token'> & Record<string, unknown>): Promise<ApiResourceResponse<T>>;
+    post<T>(endpoint: string, body?: unknown, params?: Omit<IBBaseQueryParams, 'token'> & Record<string, unknown>): Promise<T>;
+    getAll<T>(endpoint: Endpoint, params?: Omit<IBBaseQueryParams, 'token'> & Record<string, unknown>): Promise<T[]>;
     setRv(value: string | number): void;
     getRv(): string | number;
     private parseResponse;
@@ -19,7 +20,7 @@ export declare class ApiClient {
     private isCollectionResponseEnvelope;
 }
 
-declare type ApiQueryParams = Omit<IBBaseQueryParams, 'token'>;
+declare type ApiQueryParams = Omit<IBBaseQueryParams, 'token'> & Record<string, unknown>;
 
 declare type ApiResourceResponse<T> = IBResponse<T> | T;
 
@@ -46,14 +47,17 @@ export declare class B10cksDataApi {
     getResource<T>(endpoint: Endpoint, params?: ApiQueryParams): Promise<T>;
     getCollection<T>(endpoint: Endpoint, params?: ApiQueryParams, options?: CollectionFetchOptions): Promise<T[]>;
     getContent<T = Record<string, unknown>>(fullSlug: string, params?: Omit<IBContentQueryParams, 'token' | 'full_slug'>): Promise<IBContent<T>>;
-    getContents<T = Record<string, unknown>>(params?: Omit<IBContentQueryParams, 'token'>, options?: CollectionFetchOptions): Promise<IBContent<T>[]>;
-    getBlocks(params?: ApiQueryParams, options?: CollectionFetchOptions): Promise<IBBlock[]>;
+    getContents<T = Record<string, unknown>>(params?: IBGetContentsParams, options?: CollectionFetchOptions): Promise<IBContent<T>[]>;
+    getBlock(blockId: string, params?: ApiQueryParams): Promise<IBBlock>;
+    getBlocks(params?: IBGetBlocksParams, options?: CollectionFetchOptions): Promise<IBBlock[]>;
+    search<T = Record<string, unknown>>(params: IBSearchParams): Promise<IBSearchResponse<T>>;
     getSitemap(params?: Omit<IBContentQueryParams, 'token'>, options?: CollectionFetchOptions): Promise<IBSitemapEntry[]>;
     getDataEntries(source: string, params?: ApiQueryParams, options?: CollectionFetchOptions): Promise<IBDataEntry[]>;
     getDataSources(params?: ApiQueryParams, options?: CollectionFetchOptions): Promise<IBDataSource[]>;
     getSpace(params?: ApiQueryParams): Promise<IBSpace>;
-    getRedirects(params?: ApiQueryParams, forceRefresh?: boolean): Promise<RedirectMap>;
-    getRedirects(params?: ApiQueryParams, options?: RedirectFetchOptions): Promise<RedirectMap>;
+    lookupRedirect(source: string): Promise<IBRedirectLookupResult | false>;
+    getRedirects(params?: IBGetRedirectsParams, forceRefresh?: boolean): Promise<RedirectMap>;
+    getRedirects(params?: IBGetRedirectsParams, options?: RedirectFetchOptions): Promise<RedirectMap>;
     getConfig<T = Record<string, unknown>>({ slug, language_iso, language, bypassCache, ...params }?: GetConfigOptions): Promise<T>;
     syncRevision(fallbackRv?: number): Promise<string | number>;
     clearCache(): void;
@@ -61,16 +65,59 @@ export declare class B10cksDataApi {
     private unwrapCollection;
 }
 
+export declare type B10cksLink = {
+    type: 'url';
+    url: string;
+    anchor?: string;
+    target?: '_self' | '_blank' | '_parent' | '_top';
+    rel?: string;
+} | {
+    type: 'email';
+    email: string;
+    subject?: string;
+    body?: string;
+    cc?: string;
+    bcc?: string;
+} | {
+    type: 'internal';
+    url: string;
+    title: string;
+    content: string;
+    params?: string;
+    anchor?: string;
+    target?: '_self' | '_blank' | '_parent' | '_top';
+} | {
+    type: 'asset';
+    id: string;
+};
+
+export declare interface B10cksLinkResolved {
+    href: string;
+    target: string;
+}
+
 export declare type BridgeEvent = {
     type: EventType;
     payload: EventPayloadMap[EventType];
     b10cksId?: string;
 };
 
+/**
+ * Combines a b10cks `full_slug` and `language_iso` into a rooted, locale-prefixed path.
+ *
+ * - The slug `home` is treated as the root (`/` or `/<locale>`).
+ * - Slugs that already start with the locale prefix are not double-prefixed.
+ */
+export declare function buildLocalizedPath(fullSlug: string | null | undefined, languageIso: string | null | undefined): string;
+
 export declare interface CollectionFetchOptions {
     allPages?: boolean;
 }
 
+export declare type ContentSortField = 'published_at' | 'updated_at' | 'created_at' | `content.${string}`;
+
+export declare type ContentSortItem = ContentSortField | `-${ContentSortField}`;
+
 export declare type ContentUpdateEvent = {
     content: Record<string, unknown>;
 };
@@ -83,10 +130,31 @@ export declare interface DataApiClient {
         rv?: string | number;
     }>;
     getAll<T>(endpoint: Endpoint, params?: ApiQueryParams): Promise<T[]>;
+    post?<T>(endpoint: string, body?: unknown, params?: ApiQueryParams): Promise<T>;
     setRv(value: string | number): void;
 }
 
-export declare type Endpoint = 'blocks' | 'contents' | `contents/${string}` | `datasources/${string}/entries` | 'datasources' | 'redirects' | 'sitemap' | 'spaces/me';
+export declare type DateFilter = string | {
+    eq: string;
+} | {
+    neq: string;
+} | {
+    gte: string;
+} | {
+    gt: string;
+} | {
+    lte: string;
+} | {
+    lt: string;
+} | {
+    between: [string, string];
+} | {
+    null: true;
+} | {
+    '!null': true;
+};
+
+export declare type Endpoint = 'blocks' | `blocks/${string}` | 'contents' | `contents/${string}` | `datasources/${string}/entries` | 'datasources' | 'redirects' | 'search' | 'sitemap' | 'spaces/me';
 
 declare type EventCallback<T> = (payload: T) => void;
 
@@ -107,6 +175,11 @@ export declare type FieldUpdateEvent = {
     value: string;
 };
 
+/**
+ * Filters sitemap entries by locale, deduplicates by resolved URL, and drops `noindex` entries.
+ */
+export declare function filterSitemapEntries(entries: IBSitemapEntry[], options?: SitemapFilterOptions): IBSitemapEntry[];
+
 export declare interface GetConfigOptions extends Omit<IBContentQueryParams, 'token' | 'full_slug'> {
     slug?: string;
     language?: string;
@@ -129,6 +202,17 @@ export declare interface IBBlock {
     updated_at: string;
 }
 
+export declare interface IBBlockFilter {
+    name?: string;
+    slug?: string;
+    folder_id?: string;
+    is_nestable?: boolean;
+    is_root?: boolean;
+    tags?: string | string[];
+    created_at?: DateFilter;
+    updated_at?: DateFilter;
+}
+
 export declare interface IBCollectionResponse<T> {
     data: T[];
     rv?: string | number;
@@ -163,6 +247,20 @@ export declare interface IBContentBlock<T extends string> {
     block?: T;
 }
 
+export declare interface IBContentFilter {
+    language?: string;
+    language_iso?: string;
+    content_type?: string;
+    parent_id?: IdFilter;
+    id?: IdFilter;
+    canonical_id?: IdFilter;
+    canonical_parent_id?: IdFilter;
+    include_fallback?: boolean;
+    published_at?: DateFilter;
+    updated_at?: DateFilter;
+    created_at?: DateFilter;
+}
+
 export declare interface IBContentQueryParams extends IBBaseQueryParams {
     slug?: string;
     full_slug?: string;
@@ -198,6 +296,19 @@ export declare interface IBDataSource {
     updated_at: string;
 }
 
+export declare interface IBGetBlocksParams extends Omit<IBBaseQueryParams, 'token'> {
+    filter?: IBBlockFilter;
+}
+
+export declare interface IBGetContentsParams extends Omit<IBContentQueryParams, 'token' | 'sort'> {
+    filter?: IBContentFilter;
+    sort?: string | ContentSortItem[];
+}
+
+export declare interface IBGetRedirectsParams extends Omit<IBBaseQueryParams, 'token'> {
+    filter?: IBRedirectFilter;
+}
+
 export declare interface IBMeta {
     current_page: number;
     from: number;
@@ -226,11 +337,48 @@ export declare interface IBRedirect {
     status_code: number;
 }
 
+export declare interface IBRedirectFilter {
+    source?: StringFilter;
+    target?: StringFilter;
+    status_code?: string | number;
+    q?: string;
+}
+
+export declare interface IBRedirectLookupResult {
+    target: string;
+    status_code: number;
+}
+
 export declare interface IBResponse<T> {
     data: T;
     rv?: string | number;
 }
 
+export declare interface IBSearchParams {
+    q: string;
+    limit?: number;
+    offset?: number;
+    language?: string;
+}
+
+export declare interface IBSearchResponse<Content = IBContentBlock<string> & {
+    [index: string]: unknown;
+}> {
+    meta: {
+        query: string;
+        total: number;
+        limit: number;
+        offset: number;
+    };
+    data: IBSearchResult<Content>[];
+}
+
+export declare interface IBSearchResult<Content = IBContentBlock<string> & {
+    [index: string]: unknown;
+}> extends IBContent<Content> {
+    relevance_score: number;
+}
+
 export declare interface IBSeoMeta {
     robots: string | null;
     canonical: string | null;
@@ -256,6 +404,22 @@ export declare interface IBSpace {
     updated_at: string;
 }
 
+export declare type IdFilter = string | {
+    eq: string;
+} | {
+    neq: string;
+} | {
+    in: string[];
+} | {
+    '!in': string[];
+} | {
+    null: true;
+} | {
+    '!null': true;
+};
+
+export declare function normalizePathSegment(value: string | null | undefined): string;
+
 export declare class PreviewBridge {
     private static instance;
     private readonly listeners;
@@ -283,10 +447,63 @@ export declare type RedirectMap = Record<string, {
     status_code: number;
 }>;
 
+/**
+ * Renders a list of sitemap paths as a `<sitemapindex>` XML string.
+ */
+export declare function renderSitemapIndex(paths: string[], siteUrl?: string): string;
+
+/**
+ * Renders `IBSitemapEntry[]` as a `<urlset>` XML string.
+ * Pass `siteUrl` to emit absolute `<loc>` values; without it, relative paths are used.
+ */
+export declare function renderSitemapXml(entries: IBSitemapEntry[], siteUrl?: string): string;
+
+/**
+ * Resolves a B10cksLink value to a plain { href, target } object.
+ *
+ * - `'email'` links produce a `mailto:` href with optional subject/body/cc/bcc query params.
+ * - `'url'` and `'internal'` links use the stored `url` field; an `anchor` is appended as a
+ *   hash fragment when present.
+ * - `'asset'` links cannot be resolved to a URL without the asset record — returns `undefined`.
+ * - Locale prefixing and router integration are intentionally left to the caller.
+ */
+export declare function resolveB10cksLink(link: B10cksLink | undefined | null): B10cksLinkResolved | undefined;
+
 export declare type SelectUpdateEvent = {
     selectedItem: string;
 };
 
+export declare function serializeFilter(filter: Record<string, unknown>): Record<string, string>;
+
+export declare interface SitemapFilterOptions {
+    /** Absolute base URL used for deduplication. Without it, paths are compared as strings. */
+    siteUrl?: string;
+    /** Only include entries for this locale (ISO code). */
+    locale?: string;
+}
+
+export declare type StringFilter = string | {
+    eq: string;
+} | {
+    neq: string;
+} | {
+    in: string[];
+} | {
+    '!in': string[];
+} | {
+    like: string;
+} | {
+    '!like': string;
+} | {
+    '^like': string;
+} | {
+    'like$': string;
+} | {
+    null: true;
+} | {
+    '!null': true;
+};
+
 export declare namespace types {
     export {
         FetchClient,
@@ -309,7 +526,23 @@ export declare namespace types {
         IBSpace,
         IBRedirect,
         IBContentQueryParams,
-        B10cksApiClientOptions
+        B10cksLink,
+        B10cksApiClientOptions,
+        StringFilter,
+        IdFilter,
+        DateFilter,
+        IBContentFilter,
+        ContentSortField,
+        ContentSortItem,
+        IBGetContentsParams,
+        IBBlockFilter,
+        IBGetBlocksParams,
+        IBRedirectFilter,
+        IBGetRedirectsParams,
+        IBSearchResult,
+        IBSearchParams,
+        IBSearchResponse,
+        IBRedirectLookupResult
     }
 }