@ryusenkei/maezae 0.12.0 → 0.14.0

package/README.md

@@ -31,6 +31,100 @@ const client = createDeliveryClient((path, init) =>
 );
 ```
 
+## 読み取りの文法（0.14.0 から）
+
+型の一覧 `GET /content/v1/<型>` のクエリの契約。仕様は先に一度に決め、CMS は索引の効く範囲から実装する。仕様にあって未実装の書き方は400（`code: "invalid_input"`、`issues` の `message` に未実装の理由）を返す
+
+```
+filter[title][contains]=GPU
+filter[published_at][gte]=2026-01-01
+filter[sources.url][begins]=https://example.com        # まとまりの中の項目
+filter[or][0][kind][eq]=interview&filter[or][1][topics][in]=sns,culture
+ids=a,b,c
+fields=id,title,writers.name                             # 参照の先の項目を書くと、その参照を展開
+fields=*,writers.*
+order=-published_at,title
+limit=20&cursor=…
+limit=20&offset=40                                       # 応答に total
+```
+
+| 書き方 | 意味 | 実装 |
+| --- | --- | --- |
+| `filter[key]=v`、`filter[key][eq]=v` | 一致。複数の値の項目は値を含む行 | 済み |
+| `filter[key][ne]=v` | 不一致。値なしの行を含む | 済み（単数の項目） |
+| `filter[key][in]=a,b` | いずれかに一致 | 済み |
+| `filter[key][nin]=a,b` | どれにも一致しない | 未実装 |
+| `filter[key][gte]=v`、`filter[key][lte]=v` | 範囲（両端を含む） | 済み |
+| `filter[key][gt]=v`、`filter[key][lt]=v` | 範囲（両端を含まない） | 未実装 |
+| `filter[key][begins]=v` | 前方一致（大文字と小文字を区別） | 済み（単数の文字） |
+| `filter[key][contains]=v` | 部分一致 | 未実装 |
+| `filter[key][exists]=true` | 値あり（`false` は値なし、空の文字は値なし） | 済み（単数の項目） |
+| `filter[or][i][…]`、`filter[and][i][…]`、`filter[not][i][…]` | 条件の入れ子 | 未実装 |
+| `filter[group.key][…]` | まとまりの中の項目 | 未実装 |
+| `ids=a,b` | 行の id のいずれか（100個まで）。順は `order` の順 | 済み |
+| `fields=…` | 返す項目の選択と参照の展開（下記） | 済み（展開は深さ1） |
+| `order=-a,b` | 並べ替え（3個まで、先頭の `-` で降順、最後に `id` を自動で追加） | 済み |
+| `limit`・`cursor` | ページ送り。応答は `{ items, next }` | 済み |
+| `offset` | 番号のページ送り。応答に `total` | 未実装 |
+
+項目の種類ごとに実装済みの演算は次のとおり。非公開の項目は使えない
+
+| 項目の種類 | 演算 |
+| --- | --- |
+| 文字（単数） | `eq`・`ne`・`in`・`begins`・`exists` |
+| 選択肢・参照（単数） | `eq`・`ne`・`in`・`exists` |
+| 選択肢・参照（複数） | `eq`・`in` |
+| チェックボックス | `eq`（`true`・`false`） |
+| 数値・日付 | `eq`・`ne`・`gte`・`lte`・`exists` |
+| 日時 | `gte`・`lte`・`exists` |
+| `published_at`・`created_at`・`updated_at` | `gte`・`lte` |
+
+- 予約の語: `or`・`and`・`not` は最上位の項目の key に使えない（スキーマの保存で拒否する）
+- 選択と展開: `fields` の中の点で参照を展開する。深さの上限は3で、CMS の実装は深さ1。展開した参照は `{ id, …項目 }` で、参照の先が非公開か削除済みなら、単数は `null`、複数は要素を除く
+  - `id` は常に返す。`*` はすべての項目と `_meta`、`_meta` は指定したときだけ返す
+  - 展開した参照に本文の種類の項目と `_meta` は含めない。一覧で本文の種類の項目を選ぶと400
+- CMS が実装しない範囲: 部分一致・まとまりと複数の値の項目の条件・`total`・`or` の入れ子・深い展開は、DB で重く、クエリの多様さでキャッシュも効かない。重い検索や集計は、導入先が変更の一覧で自分の側に写して行う
+
+SDK の `ListQuery` は、スキーマを `as const` の定数で持つときに、項目の key と演算と値の型を絞り込む。`Selected` は `fields` の選択から1件の型を導く（参照先の型はコンテンツスキーマから引く）
+
+```ts
+import { createDeliveryClient, listParams, type Selected } from '@ryusenkei/maezae/delivery';
+
+const part = await client.page('/parts', { limit: 1, filter: { gtin: '4901234567894' } });
+const fields = ['title', 'writers.name', 'series.*'] as const;
+type Card = Selected<typeof POST, (typeof fields)[number], typeof MODEL>;
+const cards = await client.page<Card>('/post', { limit: 20, fields, filter: { title: { begins: 'GPU' } } });
+const one = await client.find<Card>('/post/p1', listParams({ fields }));
+```
+
+## 回数の制限
+
+- 対象は公開のエンドポイント（`https://api.maezae.app/<媒体>/content/v1/…`）だけ。上限は媒体と API の鍵ごとに1分で600回で、データセンターごとの近似で数える
+- 数えるのは、CMS がキャッシュから返せずに DB で計算する要求だけ。キャッシュから返す応答と、`If-None-Match` に対する304は数えない
+- 上限を超えると429（`code: "rate_limited"`）を返す。`Retry-After` の秒数だけ待ってから再試行する
+- 呼び出しを減らす方法: 1ページの取得を `prefetch`（`/bundle`）で1回にまとめ、接続を `cachedDelivery` で包む
+
+## 接続のキャッシュ（0.13.0 から）
+
+`cachedDelivery` は同じパスとクエリの取得を保持し、配信 API への呼び出しを減らす
+
+- 保持から `freshSec` 秒（既定は30）は呼び出さずに返す。過ぎたら前回の ETag で再検証し、304は回数の制限に数えない
+- 429・5xx・接続の失敗のときは、保持した値を `x-stale: 1` つきで返す
+- 下書き（`drafts`）・GET 以外・`prefetch` の `ifNoneMatch` を付けた取得は保持しない
+- 保持の場所: Workers は `caches.default`（データセンターごとに共有）、ほかの実行環境は `memoryDeliveryCache()`
+- `origin` はキーの前半で、媒体ごとに別の値にする
+
+```ts
+import { cachedDelivery, createDeliveryClient } from '@ryusenkei/maezae/delivery';
+
+const origin = 'https://<媒体>.maezae.app';
+const delivery = (path: string, init?: RequestInit) =>
+  fetch(`https://api.maezae.app/<媒体>${path}`, { ...init, headers: { ...init?.headers, authorization: `Bearer ${env.CMS_API_KEY}` } });
+const client = createDeliveryClient(cachedDelivery(delivery, { cache: caches.default, origin }));
+```
+
+公開の操作の反映は、CMS の側の遅れに加えて最大で `freshSec` 秒遅れる
+
 ## プレビュー
 
 - CMS は媒体のサイトのオリジンへ、公開のページと同じパスで署名つきのリクエストを送信

package/dist/delivery.js

@@ -1,14 +1,115 @@
 import { a as optionsOf, l as cropRect, o as typeOf, p as createClock, t as pagePathOf, u as croppedHotspot } from "./page-BnwHL-LC.js";
+// src/delivery/cache.ts
+/** 保持した日時（ミリ秒）を置く内部のヘッダー */
+const CACHED_AT = "x-maezae-cached-at";
+/** 失敗のときに返せるように保持する期間（秒） */
+const KEEP_SEC = 86400;
+const withHeaders = (res, body, set, drop = []) => {
+	const headers = new Headers(res.headers);
+	for (const k of drop) headers.delete(k);
+	for (const [k, v] of Object.entries(set)) headers.set(k, v);
+	return new Response(body, {
+		status: res.status,
+		statusText: res.statusText,
+		headers
+	});
+};
+/**
+* 保持つきの配信 API の接続（createDeliveryClient に渡す）
+* - origin: キーの前半（媒体ごとに別の値、例: https://<媒体>.maezae.app）。同じ保持の場所を複数の媒体で使っても混ざらない
+* - freshSec: 呼び出さずに返す秒数（既定は30、CMS のキャッシュの区切りと同じ）
+*/
+function cachedDelivery(delivery, { cache, origin, freshSec = 30 }) {
+	const store = async (key, res, body) => {
+		try {
+			await cache.put(key, withHeaders(res, body, {
+				[CACHED_AT]: String(Date.now()),
+				"cache-control": `max-age=${KEEP_SEC}`
+			}));
+		} catch {}
+	};
+	const fromCache = (res, body, extra = {}) => withHeaders(res, body, extra, [CACHED_AT, "cache-control"]);
+	return async (path, init = {}) => {
+		const headers = new Headers(init.headers);
+		const key = `${origin}${path}`;
+		if ((init.method ?? "GET").toUpperCase() !== "GET" || headers.has("if-none-match") || new URL(key).searchParams.get("drafts") === "1") return delivery(path, init);
+		const cached = await cache.match(key).catch(() => null) ?? null;
+		if (cached && Date.now() - Number(cached.headers.get(CACHED_AT)) < freshSec * 1e3) return fromCache(cached, cached.body);
+		const etag = cached?.headers.get("etag");
+		if (etag) headers.set("if-none-match", etag);
+		let res;
+		try {
+			res = await delivery(path, {
+				...init,
+				headers
+			});
+		} catch (e) {
+			if (cached) return fromCache(cached, cached.body, { "x-stale": "1" });
+			throw e;
+		}
+		if (res.status === 304 && cached) {
+			const body = await cached.text();
+			await store(key, cached, body);
+			return fromCache(cached, body);
+		}
+		if (res.status === 200 && !res.headers.has("x-partial") && !res.headers.has("x-stale")) {
+			const body = await res.text();
+			await store(key, res, body);
+			return fromCache(res, body);
+		}
+		if (cached && (res.status === 429 || res.status >= 500)) {
+			await res.body?.cancel();
+			return fromCache(cached, cached.body, { "x-stale": "1" });
+		}
+		return res;
+	};
+}
+/** メモリの保持の場所（Workers 以外の実行環境向け、maxEntries を超えたら最も古く使用したものから破棄） */
+function memoryDeliveryCache(maxEntries = 500) {
+	const entries = /* @__PURE__ */ new Map();
+	return {
+		match: async (key) => {
+			const v = entries.get(key);
+			if (!v) return null;
+			entries.delete(key);
+			entries.set(key, v);
+			return new Response(v.body, {
+				status: v.status,
+				headers: v.headers
+			});
+		},
+		put: async (key, res) => {
+			entries.delete(key);
+			const headers = [];
+			res.headers.forEach((v, k) => headers.push([k, v]));
+			entries.set(key, {
+				status: res.status,
+				headers,
+				body: await res.text()
+			});
+			if (entries.size > maxEntries) entries.delete(entries.keys().next().value);
+		}
+	};
+}
 // src/delivery/query.ts
 const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-/** in の値の検査（コンマを含む値はクエリで区切れない） */
+const OPS = [
+	"eq",
+	"ne",
+	"in",
+	"gte",
+	"lte",
+	"begins",
+	"exists"
+];
+/** in・ids の値の検査（コンマを含む値はクエリで区切れない） */
 const joined = (values) => {
 	const parts = values.map(String);
 	const bad = parts.find((p) => p.includes(","));
-	if (bad !== void 0) throw new Error(`in の値にコンマは不可: ${bad}`);
+	if (bad !== void 0) throw new Error(`in・ids の値にコンマは不可: ${bad}`);
 	return parts.join(",");
 };
-/** 一覧の指定をクエリの組に（find・get・subPath の params、一式の path に使用） */
+/** 一覧の指定をクエリの組に（find・get・subPath の params、一式の path に使用、1件の取得の fields にも使用） */
 function listParams(query) {
 	const params = {};
 	for (const [key, value] of Object.entries(query.filter ?? {})) {
@@ -17,9 +118,10 @@ function listParams(query) {
 			params[`filter[${key}]`] = String(value);
 			continue;
 		}
-		if ("in" in value) params[`filter[${key}][in]`] = joined(value.in);
-		for (const op of ["gte", "lte"]) if (value[op] !== void 0) params[`filter[${key}][${op}]`] = String(value[op]);
+		for (const op of OPS) if (value[op] !== void 0) params[`filter[${key}][${op}]`] = op === "in" ? joined(value[op]) : String(value[op]);
 	}
+	if (query.ids) params.ids = joined(query.ids);
+	if (query.fields?.length) params.fields = joined(query.fields);
 	if (query.order?.length) params.order = query.order.join(",");
 	if (query.limit !== void 0) params.limit = String(query.limit);
 	if (query.cursor) params.cursor = query.cursor;
@@ -306,4 +408,4 @@ function createDeliveryClock(timeZone) {
 		})
 	};
 }
-export { DELIVERY_PATH, DeliveryError, createDeliveryClient, createDeliveryClock, deliveredImageUrl, fieldOf, imageParamsOf, limitOf, listParams, mediaOf, optionLabels, pagePath, parseMediaPath, subPath, withImageParams };
+export { DELIVERY_PATH, DeliveryError, cachedDelivery, createDeliveryClient, createDeliveryClock, deliveredImageUrl, fieldOf, imageParamsOf, limitOf, listParams, mediaOf, memoryDeliveryCache, optionLabels, pagePath, parseMediaPath, subPath, withImageParams };

package/dist/model.js

@@ -393,6 +393,12 @@ const RESERVED_EDITORIAL = [
 	"review_note",
 	"assignee"
 ];
+/** 配信 API の絞り込みの論理の演算（filter[or][0][key] など） */
+const RESERVED_QUERY = [
+	"or",
+	"and",
+	"not"
+];
 /** 予約の名前と同じ最上位の key */
 function reservedKeysOf(t) {
 	const reserved = [...RESERVED, ...(t.publishing ?? "none") !== "none" ? RESERVED_EDITORIAL : []];
@@ -451,6 +457,10 @@ const contentType = z.object({
 		code: "custom",
 		message: `型 ${t.id} の key ${k} はシステムの値と同じ名前（別の key に）`
 	});
+	for (const f of t.fields) if (RESERVED_QUERY.includes(f.key)) ctx.addIssue({
+		code: "custom",
+		message: `型 ${t.id} の key ${f.key} は配信 API の絞り込みの予約の語（別の key に）`
+	});
 	for (const k of nestedRules(t.fields)) ctx.addIssue({
 		code: "custom",
 		message: `型 ${t.id} の項目 ${k}: まとまりの中の項目は決まる値 derive・参照先で固定 fixedBy なし`

package/dist/types/sdk/src/delivery/cache.d.ts

@@ -0,0 +1,18 @@
+import type { Delivery } from './client.js';
+/** Cache API と同じ形の保持の場所（key は URL） */
+export type DeliveryCache = Readonly<{
+    match(key: string): Promise<Response | null | undefined>;
+    put(key: string, response: Response): Promise<void>;
+}>;
+/**
+ * 保持つきの配信 API の接続（createDeliveryClient に渡す）
+ * - origin: キーの前半（媒体ごとに別の値、例: https://<媒体>.maezae.app）。同じ保持の場所を複数の媒体で使っても混ざらない
+ * - freshSec: 呼び出さずに返す秒数（既定は30、CMS のキャッシュの区切りと同じ）
+ */
+export declare function cachedDelivery(delivery: Delivery, { cache, origin, freshSec }: {
+    cache: DeliveryCache;
+    origin: string;
+    freshSec?: number;
+}): Delivery;
+/** メモリの保持の場所（Workers 以外の実行環境向け、maxEntries を超えたら最も古く使用したものから破棄） */
+export declare function memoryDeliveryCache(maxEntries?: number): DeliveryCache;

package/dist/types/sdk/src/delivery/fields.d.ts

@@ -0,0 +1,45 @@
+import type { ContentModel, ContentType, FieldDef } from '../../../model/src/index.js';
+import type { FieldsOf, FieldValue, ItemMeta, ItemOf } from './values.js';
+type PublicField<T extends ContentType> = Exclude<FieldsOf<T>, {
+    private: true;
+}>;
+type KeyOf<T extends ContentType> = PublicField<T>['key'];
+type RefField<T extends ContentType> = Extract<PublicField<T>, {
+    type: 'reference';
+}>;
+/** fields に書ける1つの指定（項目の key・id・_meta・*、参照の項目は `key.sub` か `key.*`） */
+export type FieldPath<T extends ContentType = ContentType> = 'id' | '_meta' | '*' | KeyOf<T> | `${RefField<T>['key']}.${string}`;
+/** 選択に含む最上位の key（`key.sub` は key） */
+type Head<P> = P extends `${infer K}.${string}` ? K : P;
+/** 参照の項目 K の展開の指定（`K.sub` の sub） */
+type SubOf<P, K extends string> = P extends `${K}.${infer S}` ? S : never;
+/** 参照先の型（M がなければ汎用の型） */
+type TargetOf<F extends FieldDef, M> = M extends ContentModel ? (F extends {
+    to: infer To;
+} ? Extract<M['types'][number], {
+    id: To;
+}> : never) : never;
+/** 展開した参照先の1件（id と選択した項目、* はすべて） */
+type Expanded<To, S> = [To] extends [never] ? Readonly<{
+    id: string;
+} & Record<string, unknown>> : To extends ContentType ? Readonly<{
+    id: string;
+} & ('*' extends S ? Omit<ItemOf<To>, '_meta' | 'id'> : Pick<ItemOf<To>, Extract<S, keyof ItemOf<To>>>)> : never;
+/** 選択した1つの項目の値（展開する参照は参照先の1件、単数は null を含み、複数は配列） */
+type SelectedValue<F extends FieldDef, P, M> = [SubOf<P, F['key']>] extends [never] ? FieldValue<F> : F extends {
+    multiple: true;
+} ? readonly Expanded<TargetOf<F, M>, SubOf<P, F['key']>>[] : Expanded<TargetOf<F, M>, SubOf<P, F['key']>> | null;
+/**
+ * fields の選択から導く1件の型
+ * - T: 型の宣言、P: fields の配列の要素（`as const` の配列の `[number]`）、M: 参照先の型を引くコンテンツスキーマ
+ */
+export type Selected<T extends ContentType, P extends string, M = never> = Readonly<{
+    id: string;
+} & ('_meta' extends P ? {
+    _meta: ItemMeta;
+} : '*' extends P ? {
+    _meta: ItemMeta;
+} : unknown) & {
+    [F in PublicField<T> as F['key'] extends Head<P> ? F['key'] : '*' extends P ? F['key'] : never]: SelectedValue<F, P, M>;
+}>;
+export {};

package/dist/types/sdk/src/delivery/index.d.ts

@@ -1,6 +1,8 @@
+export { cachedDelivery, memoryDeliveryCache, type DeliveryCache } from './cache.js';
 export { createDeliveryClient, DELIVERY_PATH, DeliveryError, subPath, type BundleResult, type Delivery, type DeliveryClient, type Prefetched } from './client.js';
 export { deliveredImageUrl, mediaOf, type ImageUrl, type MediaOf } from './media.js';
 export { imageParamsOf, parseMediaPath, withImageParams, type ImageParams, type MediaPath } from '../../../model/src/index.js';
+export type { FieldPath, Selected } from './fields.js';
 export { listParams, type ListFilter, type ListQuery, type Page } from './query.js';
 export { createDeliveryClock, fieldOf, limitOf, optionLabels, pagePath, type DeliveryClock } from './schema.js';
 export type { DeliveredAsset, FieldValue, Item, ItemMeta, ItemOf } from './values.js';

package/dist/types/sdk/src/delivery/query.d.ts

@@ -1,4 +1,5 @@
 import type { ContentType, FieldDef } from '../../../model/src/index.js';
+import type { FieldPath } from './fields.js';
 import type { FieldsOf, Item, SingleValue } from './values.js';
 /** 範囲の指定（両端を含む） */
 type Range<V> = Readonly<{
@@ -6,20 +7,31 @@ type Range<V> = Readonly<{
     lte?: V;
 }>;
 type Scalar<F extends FieldDef> = NonNullable<SingleValue<F>>;
-/** 項目の種類ごとの絞り込みの値（選択肢・参照は一致か in、チェックボックスは一致、数値・日付は一致か範囲、日時は範囲） */
+/** 演算ごとの値（in は値の配列、exists は値あり・なしの真偽） */
+type Ops<V, O extends FilterOp> = Readonly<{
+    [K in O]?: K extends 'in' ? readonly V[] : K extends 'exists' ? boolean : V;
+}>;
+/** 絞り込みの演算（サーバーが実装する範囲） */
+type FilterOp = 'eq' | 'ne' | 'in' | 'gte' | 'lte' | 'begins' | 'exists';
+/** 項目の種類ごとの絞り込みの値（値だけの指定は一致） */
 type FilterValue<F extends FieldDef> = F extends {
     private: true;
 } ? never : F extends {
     type: 'select' | 'reference';
-} ? Scalar<F> | Readonly<{
-    in: readonly Scalar<F>[];
-}> : F extends {
+    multiple: true;
+} ? Scalar<F> | Ops<Scalar<F>, 'eq' | 'in'> : F extends {
+    multiple: true;
+} ? never : F extends {
+    type: 'text';
+} ? string | Ops<string, 'eq' | 'ne' | 'in' | 'begins' | 'exists'> : F extends {
+    type: 'select' | 'reference';
+} ? Scalar<F> | Ops<Scalar<F>, 'eq' | 'ne' | 'in' | 'exists'> : F extends {
     type: 'checkbox';
 } ? boolean : F extends {
     type: 'number' | 'date';
-} ? Scalar<F> | Range<Scalar<F>> : F extends {
+} ? Scalar<F> | Ops<Scalar<F>, 'eq' | 'ne' | 'gte' | 'lte' | 'exists'> : F extends {
     type: 'datetime';
-} ? Range<string> : never;
+} ? Ops<string, 'gte' | 'lte' | 'exists'> : never;
 /** 並べ替えできる項目の key（単数の文字・数値・日付・日時・選択肢・チェックボックス） */
 type SortableKey<T extends ContentType> = FieldsOf<T> extends infer F ? (F extends {
     private: true;
@@ -44,12 +56,16 @@ export type ListFilter<T extends ContentType = ContentType> = Readonly<{
  * - limit: 1ページの件数（サーバーの上限は100）
  * - cursor: 前のページの next
  * - order: 並べ替えの key の配列（`-` の接頭辞で降順、最後に id を自動で追加）
- * - filter: 項目の key ごとの絞り込み（複数の値の項目は値を含む行）
+ * - ids: 行の id のいずれか（100個まで、順は order の順）
+ * - fields: 返す項目と展開する参照（id は常に返す、展開は深さ1）
+ * - filter: 項目の key ごとの絞り込み（複数の値の項目は値を含む行、ne は値なしの行を含む）
  */
 export type ListQuery<T extends ContentType = ContentType> = Readonly<{
     limit?: number;
     cursor?: string | null;
     order?: readonly (OrderKey<T> | `-${OrderKey<T>}`)[];
+    ids?: readonly string[];
+    fields?: readonly FieldPath<T>[];
     filter?: ListFilter<T>;
 }>;
 /** ページ送りの応答（next は次のページの cursor、最後のページは null） */
@@ -62,8 +78,10 @@ type QueryShape = Readonly<{
     limit?: number;
     cursor?: string | null;
     order?: readonly string[];
+    ids?: readonly string[];
+    fields?: readonly string[];
     filter?: Readonly<Record<string, unknown>>;
 }>;
-/** 一覧の指定をクエリの組に（find・get・subPath の params、一式の path に使用） */
+/** 一覧の指定をクエリの組に（find・get・subPath の params、一式の path に使用、1件の取得の fields にも使用） */
 export declare function listParams(query: QueryShape): Record<string, string>;
 export {};

package/dist/types/sdk/src/delivery.d.ts

@@ -1,2 +1,2 @@
-export { createDeliveryClient, createDeliveryClock, deliveredImageUrl, DELIVERY_PATH, DeliveryError, fieldOf, imageParamsOf, limitOf, listParams, mediaOf, optionLabels, pagePath, parseMediaPath, subPath, withImageParams } from './delivery/index.js';
-export type { BundleResult, DeliveredAsset, Delivery, DeliveryClient, DeliveryClock, FieldValue, ImageParams, ImageUrl, Item, ItemMeta, ItemOf, ListFilter, ListQuery, MediaOf, MediaPath, Page, Prefetched } from './delivery/index.js';
+export { cachedDelivery, createDeliveryClient, createDeliveryClock, deliveredImageUrl, DELIVERY_PATH, DeliveryError, fieldOf, imageParamsOf, limitOf, listParams, mediaOf, memoryDeliveryCache, optionLabels, pagePath, parseMediaPath, subPath, withImageParams } from './delivery/index.js';
+export type { BundleResult, DeliveredAsset, Delivery, DeliveryCache, DeliveryClient, DeliveryClock, FieldValue, ImageParams, ImageUrl, Item, ItemMeta, ItemOf, FieldPath, ListFilter, ListQuery, MediaOf, MediaPath, Page, Prefetched, Selected } from './delivery/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryusenkei/maezae",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "maezae の導入先のサイト向けの SDK（配信 API の取得・本文の型・プレビューの署名・手元の開発の配信 API）",
   "license": "UNLICENSED",
   "author": "RYUSENKEI",