@getquick/content 0.1.0 → 0.3.0

package/dist/wordpress-D_HG2rEt.d.ts

@@ -0,0 +1,606 @@
+import { r as ConsentConfiguration, t as AnalyticsSettings } from "./configuration-C_JGygQI.js";
+import { r as LegalLanguage } from "./legal-C5Xiq59W.js";
+declare namespace content_types_d_exports {
+  export { Archives, CmsFailure, CmsFailureReason, CollectionMembership, CollectionTerm, Delivery, DesignPresets, EntryContent, Extended, Found, HomeContent, Missing, PublishedEntry, SiteChrome, Translation, Unavailable, WordPressImage, WordPressMenuItem, WordPressPost, WordPressSettings };
+}
+interface WordPressImage {
+  sourceUrl: string;
+  altText: string;
+}
+interface WordPressPost {
+  id: string;
+  title: string;
+  excerpt: string;
+  content: string;
+  uri: string;
+  date: string;
+  featuredImage: WordPressImage | null;
+  hasVideoHero: boolean;
+}
+interface WordPressMenuItem {
+  id: string;
+  label: string;
+  href: string;
+  target: string | null;
+  children: WordPressMenuItem[];
+}
+interface WordPressSettings {
+  title: string;
+  description: string;
+}
+interface DesignPresets {
+  spacingSizes: Array<{
+    slug: string;
+    size: string;
+  }>;
+  colors: Array<{
+    slug: string;
+    color: string;
+  }>;
+}
+/**
+ * A page or post's own content as the Site's extension read it
+ * (ContentConfig's `extension`): present only when the Site declares one and
+ * its read returned a value for that page or post.
+ */
+interface Extended<X = unknown> {
+  extension?: X;
+}
+interface HomeContent<X = unknown> extends DesignPresets {
+  /** The front page's WordPress entry (WPGraphQL's global id), if WordPress gave it. */
+  nodeId: string | null;
+  settings: WordPressSettings;
+  page: {
+    title: string;
+    content: string;
+    hasVideoHero: boolean;
+  } & Extended<X>;
+  /** WordPress failed on the blocks, so this is the page without them. */
+  blocksOmitted: boolean;
+}
+/** A term of one of a collection's taxonomies, as an item carries it. */
+interface CollectionTerm {
+  slug: string;
+  name: string;
+}
+/**
+ * The collection an entry is an item of (ContentConfig's `collections`): its
+ * name, and its terms in each of the collection's taxonomies.
+ */
+interface CollectionMembership {
+  name: string;
+  terms: Record<string, CollectionTerm[]>;
+}
+/** A published translation of an entry: its URI and its language's slug. */
+interface Translation {
+  uri: string;
+  language: string;
+}
+interface EntryContent<X = unknown> extends WordPressPost, DesignPresets, Extended<X> {
+  /** Its language's slug, on a multilingual Site. */
+  language?: string;
+  /** Its published translations into the site's other languages, on a multilingual Site. */
+  translations?: Translation[];
+  /** WordPress failed on the blocks, so this is the entry without them. */
+  blocksOmitted: boolean;
+  /** When WordPress last modified it (ms, the CMS's clock), if it said. */
+  modifiedAt: number | null;
+  /** The collection it is an item of, when it is one (not a page or post). */
+  collection?: CollectionMembership;
+}
+/** A published page or post as WordPress lists it: its id, URI and last modification. */
+interface PublishedEntry {
+  /** WPGraphQL's global id, when WordPress gives it. */
+  id: string | null;
+  uri: string;
+  /** When WordPress last modified it (ms, the CMS's clock), if it said. */
+  modifiedAt: number | null;
+}
+/** Where each collection's archive is (a path), by its post type. */
+type Archives = Record<string, string>;
+interface SiteChrome {
+  menuItems: WordPressMenuItem[];
+  siteIcon: WordPressImage | null;
+  siteLogo: WordPressImage | null;
+  /**
+   * The patterns GQ Design's Header & Footer selects for the Site's header and
+   * footer (render them with `renderDesignPattern`). Null when the region uses
+   * an ordinary template part, or nothing published is selected: the Site
+   * keeps its own header or footer then.
+   */
+  header: DesignPattern | null;
+  footer: DesignPattern | null;
+  /**
+   * This language's LEGAL-1 Contract from gq-config, on a Site with consent
+   * CMS settings enabled (null when gq-config has none for it).
+   */
+  legal?: LegalLanguage | null;
+  /** gq-config's GA4 settings, on a Site with consent CMS settings enabled. */
+  analytics?: AnalyticsSettings;
+}
+/**
+ * Why WordPress couldn't deliver: it didn't answer in time (`timeout`), couldn't
+ * be reached (`network`), answered with an HTTP error (`http`) or GraphQL errors
+ * (`graphql`), or answered with data missing the fields the Frontend requires
+ * (`schema`).
+ */
+type CmsFailureReason = "timeout" | "network" | "http" | "graphql" | "schema";
+interface CmsFailure {
+  reason: CmsFailureReason;
+  message: string;
+  httpStatus?: number;
+}
+interface Found<T> {
+  kind: "found";
+  content: T;
+}
+/** WordPress answered with valid data, and has nothing published there. */
+interface Missing {
+  kind: "missing";
+}
+/** The content couldn't be read. This says nothing about whether it exists. */
+interface Unavailable {
+  kind: "unavailable";
+  failure: CmsFailure;
+}
+type Delivery<T> = Found<T> | Missing | Unavailable;
+//#endregion
+//#region frontend/src/design-patterns.d.ts
+/**
+ * A block of a GQ Design pattern, as its layout API shapes it (`blocksJson`):
+ * its name, its public attributes (including those a Site's serializer adds,
+ * such as `getquick/header-navigation`'s `menuItems`), the HTML WordPress saved
+ * for it (null for a dynamic block, such as `core/site-logo`), and its inner
+ * blocks, with synced patterns already inlined.
+ */
+interface DesignBlock {
+  name: string;
+  attributes: Record<string, unknown>;
+  content: string | null;
+  children: DesignBlock[];
+}
+/**
+ * The published synced pattern GQ Design's Header & Footer selects for a
+ * region of the Site chrome (`designPattern`), as its block tree.
+ */
+interface DesignPattern {
+  title: string;
+  blocks: DesignBlock[];
+}
+/**
+ * A complete pattern tree from JSON text or a parsed list. Malformed nodes
+ * fail the whole read: dropping one could promote a partial header or footer.
+ * PHP's empty attributes (`[]`) normalize to an object.
+ */
+declare function parseDesignBlocks(value: unknown): DesignBlock[] | undefined;
+declare function escapeHtml(value: string): string;
+/** What a block renderer is given besides its block. */
+interface DesignRenderContext {
+  /** The block's children, rendered in order by the same renderers (when read). */
+  children: string;
+  /** The blocks it is inside, outermost first. */
+  ancestors: DesignBlock[];
+  /** Renders other blocks (a subset of the children, say) by the same renderers. */
+  render(this: void, blocks: DesignBlock[]): string;
+  /**
+   * A link from CMS data as the Frontend serves it: one into this Site (the
+   * CMS or the Site origin) becomes its path, another http(s) link stays
+   * absolute, and anything else (`javascript:`, say) becomes "#".
+   */
+  href(this: void, url: unknown): string;
+  /** The home page of the language being served ("/" unless the options say). */
+  home: string;
+}
+/**
+ * Renders one block as HTML. Its output is not escaped again: escape what the
+ * CMS supplied (`escapeHtml`) and pass links through `context.href`.
+ */
+type DesignBlockRenderer = (block: DesignBlock, context: DesignRenderContext) => string;
+interface DesignRenderOptions {
+  /**
+   * The Site's renderers, by block name: its own blocks (such as
+   * `getquick/header-navigation`), and any core block it renders itself.
+   * They take precedence over the built-in ones.
+   */
+  blocks?: Record<string, DesignBlockRenderer>;
+  /** The origins whose links are this Site's: the CMS's and the Site's. */
+  internalOrigins?: string[];
+  /**
+   * Told about each block without children that has neither a renderer nor
+   * saved HTML (a dynamic block): it renders nothing.
+   */
+  onUnrendered?: (block: DesignBlock) => void;
+  /** The home page of the language being served, for home links: "/" by default. */
+  home?: string;
+}
+/**
+ * A pattern (or blocks of one) as HTML. Each block is rendered by the Site's
+ * renderer for its name, else a built-in one, else as the HTML WordPress saved
+ * for it, else, with children, as a WordPress container wrapping them. A block
+ * with none of those (a dynamic block, such as a Site's own) renders nothing
+ * and is reported to `onUnrendered`. Null renders nothing, so the Site keeps
+ * its own header or footer.
+ */
+declare function renderDesignPattern(pattern: DesignPattern | DesignBlock[] | null | undefined, options?: DesignRenderOptions): string;
+/**
+ * A menu a Site block carries in its attributes (a flat list of `{ id,
+ * parentId, label, url, target }`, as GQ Design's serializer filter documents
+ * for `getquick/header-navigation`) as a tree, with each link as the
+ * Frontend serves it. Items that aren't menu items are left out; one whose
+ * parent isn't listed, or that is in a cycle of parents, is a top-level item.
+ */
+declare function designMenuItems(value: unknown, href?: (url: unknown) => string): WordPressMenuItem[];
+//#endregion
+//#region frontend/src/site-language.d.ts
+/**
+ * The `<html lang>` for a WordPress locale: its language and region as a
+ * BCP 47 tag (pt_PT_ao90 → pt-PT). WordPress's variants (ao90, formal) aren't
+ * BCP 47 subtags, so they are left out; no locale means English.
+ */
+declare function htmlLang(locale: string | undefined): string;
+/** A language the site serves. */
+interface SiteLanguage {
+  /** Its WordPress locale (pt_PT_ao90); empty when configuration names none. */
+  locale: string;
+  /** Polylang's slug, its URL directory: the default language's is its language code. */
+  slug: string;
+  /** Its GraphQL LanguageCodeEnum value: the slug in upper case (pt-br → PT_BR). */
+  code: string;
+  /** Its `<html lang>`. */
+  lang: string;
+  isDefault: boolean;
+  /** Its home route: / for the default language, /<slug>/ for the others. */
+  home: string;
+}
+interface WordPressLanguages {
+  locale?: string;
+  languages?: readonly {
+    locale: string;
+    slug: string;
+  }[];
+}
+/**
+ * configuration's languages: wordpress.locale, the default, served at /, then
+ * each of wordpress.languages under its slug. A monolingual Site has one.
+ */
+declare function siteLanguages(wordpress: WordPressLanguages | undefined): SiteLanguage[];
+/**
+ * A route's language: the one whose slug is its first segment, else the
+ * default language, which has no directory.
+ */
+declare function routeLanguage(route: string, among: readonly SiteLanguage[]): SiteLanguage;
+/**
+ * How logs and reports name something a language has: "the front page" for
+ * the default language's, "the en front page" for another's.
+ */
+declare function languageSubject(language: SiteLanguage, what: string): string;
+/** Whether a route is a language's home (/, /en/): served as a home, never as an entry. */
+declare function isLanguageHome(route: string, among: readonly SiteLanguage[]): boolean;
+//#endregion
+//#region frontend/src/bindings.d.ts
+interface SqlStatement {
+  bind(...values: unknown[]): SqlStatement;
+  first<T = Record<string, unknown>>(): Promise<T | null>;
+  all<T = Record<string, unknown>>(): Promise<{
+    results: T[];
+  }>;
+  run(): Promise<{
+    meta: {
+      changes: number;
+    };
+  }>;
+}
+interface SqlDatabase {
+  prepare(query: string): SqlStatement;
+  /** Runs the statements in order as one transaction: all of them apply, or none. */
+  batch<T = Record<string, unknown>>(statements: SqlStatement[]): Promise<Array<{
+    results: T[];
+  }>>;
+}
+interface ContentBindings {
+  /** The publication store (D1). */
+  PUBLICATION_DB?: SqlDatabase;
+  /** The trusted refresh's bearer token (a Worker secret). */
+  FRONTEND_REFRESH_TOKEN?: string;
+  /** The key the CMS signs its publication events with (a Worker secret). */
+  PUBLICATION_EVENT_SECRET?: string;
+  /** Read-only CMS edge identity; never the automation service or public env. */
+  GQ_AUTH_GRAPHQL_CLIENT_ID?: string;
+  GQ_AUTH_GRAPHQL_CLIENT_SECRET?: string;
+}
+//#endregion
+//#region frontend/src/page-types.d.ts
+/** The front page as stored: what WordPress delivered, without read details. */
+type HomePublication<X = unknown> = Omit<HomeContent<X>, "blocksOmitted" | "nodeId">;
+/** A published page or post as stored, with the design presets it was read with. */
+type EntryPublication<X = unknown> = Omit<EntryContent<X>, "blocksOmitted" | "modifiedAt">;
+/**
+ * A page in another language that a visitor of this one may switch to: its
+ * published translation (`translation`), or else that language's home.
+ */
+interface Alternate {
+  language: SiteLanguage;
+  route: string;
+  translation: boolean;
+}
+interface HomePage<X = unknown> {
+  home: HomePublication<X>;
+  chrome: SiteChrome;
+  /** The other languages' homes that are served; none on a monolingual Site. */
+  alternates: Alternate[];
+}
+interface EntryPage<X = unknown> {
+  entry: EntryPublication<X>;
+  chrome: SiteChrome;
+  /** Where its readers may switch language; none on a monolingual Site. */
+  alternates: Alternate[];
+}
+/** The entry a route served is published at another URI now: the route redirects there. */
+interface Moved {
+  kind: "moved";
+  uri: string;
+}
+/**
+ * Why there is nothing to serve: the CMS failed (live reads, in explicit development),
+ * the store couldn't be read (`store`), or the Site has never been refreshed,
+ * or holds only state this Frontend can't read (`not-ready`).
+ */
+type DeliveryFailureReason = CmsFailureReason | "store" | "not-ready";
+interface NotServed {
+  kind: "unavailable";
+  failure: {
+    reason: DeliveryFailureReason;
+    message: string;
+  };
+}
+type HomeDelivery<X = unknown> = Found<HomePage<X>> | (Missing & {
+  chrome: SiteChrome | null;
+}) | NotServed;
+type EntryDelivery<X = unknown> = Found<EntryPage<X>> | (Missing & {
+  chrome: SiteChrome | null;
+}) | Moved | NotServed;
+/** Which of a collection's items to list, from the publication store. */
+interface CollectionQuery {
+  /** The collection's name, as ContentConfig's `collections` declares it. */
+  collection: string;
+  /**
+   * Only items with one of these terms (slugs) in each of these taxonomies:
+   * any slug of a taxonomy, and every taxonomy given.
+   */
+  terms?: Record<string, readonly string[]>;
+  /** Only items whose title or excerpt contains this text (ignoring case and accents). */
+  search?: string;
+  /** The page of items, from 1 (the default). */
+  page?: number;
+  /** Items per page, 1 to 100; 12 by default. */
+  perPage?: number;
+  /** A multilingual Site's language (its slug); the default language's by default. */
+  language?: string;
+}
+/** An item as a collection lists it. */
+interface CollectionItem<X = unknown> {
+  uri: string;
+  title: string;
+  /** When it was published, as WordPress gives it (its date, without a zone). */
+  date: string;
+  /** When WordPress last modified it (ms, the CMS's clock), if it said. */
+  modifiedAt: number | null;
+  excerpt: string;
+  featuredImage: WordPressImage | null;
+  /** Its terms in each of the collection's taxonomies. */
+  terms: Record<string, CollectionTerm[]>;
+  /** The Site's own content on it (ContentConfig's `extension`), when it has one. */
+  extension?: X;
+  /** Its language's slug, on a multilingual Site. */
+  language?: string;
+}
+/** A page of a collection's items, newest first, and how many there are in all. */
+interface CollectionPage<X = unknown> {
+  items: CollectionItem<X>[];
+  /** Items matching the query, on every page. */
+  total: number;
+  page: number;
+  /** Pages of items matching the query (0 when none does). */
+  pages: number;
+}
+type CollectionListing<X = unknown> = ({
+  kind: "found";
+} & CollectionPage<X>) | NotServed;
+/** A term of a collection's taxonomy, and how many of its stored items have it. */
+interface CollectionTermCount extends CollectionTerm {
+  count: number;
+}
+type CollectionTermListing = {
+  kind: "found";
+  terms: CollectionTermCount[];
+} | NotServed;
+//#endregion
+//#region frontend/src/server.d.ts
+interface ContentConfig<X = never> {
+  site: string;
+  graphqlEndpoint: string;
+  cmsOrigin: string;
+  wordpress?: WordPressLanguages;
+  /**
+   * The GQ Design route (Design → Header & Footer) whose header and footer
+   * patterns are the Site chrome's: "page" by default; "front-page", "home",
+   * "archive", "single-post" or a route a Site plugin defines.
+   */
+  designTemplate?: string;
+  /** Live delivery without a publication store is opt-in; false by default. */
+  development?: boolean;
+  isServer: () => boolean;
+  bindings: () => ContentBindings | Promise<ContentBindings>;
+  fetch?: typeof globalThis.fetch;
+  /**
+   * CONSENT-1 for this Site. Present, every published body's third-party
+   * embeds are rewritten into consent placeholders (unknown hosts blocked) on
+   * delivery; absent, bodies are delivered as published.
+   */
+  consent?: ContentConsentConfig;
+  /**
+   * The Site's own content on its pages and posts: GraphQL fields the runtime
+   * reads with each of them, and the value the Site makes of them, stored with
+   * the publication and served as its `extension`.
+   */
+  extension?: ContentExtension<X>;
+  /**
+   * The content types the runtime stores besides pages and posts, by the
+   * Site's name for each (`biblioteca`). Their items are stored, refreshed,
+   * withdrawn and reconciled as pages and posts are, served by
+   * `publishedEntry`, and listed from the store by `list`.
+   */
+  collections?: Record<string, CollectionConfig>;
+}
+/** A content type (a WordPress custom post type) whose items the runtime stores. */
+interface CollectionConfig {
+  /** WordPress's name for the post type (register_post_type's), e.g. `biblioteca`. */
+  postType: string;
+  /** Its WPGraphQL type (its `graphql_single_name`), e.g. `Biblioteca`. */
+  graphqlType: string;
+  /**
+   * The taxonomies (WordPress's names) whose terms are stored with each item,
+   * for filtering and showing them. Each must be shown in WPGraphQL.
+   */
+  taxonomies?: readonly string[];
+}
+/**
+ * A Site's own content on its pages and posts, beyond what the runtime reads:
+ * fields a plugin adds to WPGraphQL (a block tree, a page setting), read with
+ * every front page, page and post, stored with it, and served with it through
+ * outages, as the rest of it is.
+ */
+interface ContentExtension<X> {
+  /**
+   * GraphQL selections added to each kind of node the runtime reads: `page`
+   * to front pages and pages, `post` to posts (e.g. `wpBlocksJson`). They are
+   * read with the blocks: a read WordPress can only complete without its
+   * blocks leaves them out too, and isn't stored. A kind without fields has
+   * no extension. `collections`: each collection's items' fields, by its name.
+   */
+  fields: {
+    page?: string;
+    post?: string;
+    collections?: Partial<Record<string, string>>;
+  };
+  /**
+   * The Site's value for a node WordPress returned (its fields, the runtime's
+   * among them), or undefined when it has none (`extension` is then left
+   * out). It is stored as JSON, so it must survive JSON. Throwing fails the
+   * read as WordPress answering with the wrong schema: what is stored stays
+   * served.
+   */
+  read(node: ExtensionNode): X | undefined;
+  /**
+   * The value read back from the store, or from a read about to be stored
+   * (JSON), or undefined when the Site can't serve it. A stored row whose
+   * extension doesn't parse is unusable, as any body that doesn't; one stored
+   * without an extension (before the Site declared it) still serves, without.
+   * Return a valid value as it is: reconciliation compares it with new reads.
+   */
+  parse(stored: unknown): X | undefined;
+}
+/** A front page, page, post or collection item as WordPress returned it, for a Site's extension. */
+interface ExtensionNode {
+  kind: "page" | "post" | "item";
+  /** The collection's name, for an item. */
+  collection?: string;
+  fields: Readonly<Record<string, unknown>>;
+}
+interface ContentConsentConfig {
+  /** The catalog services the Site declares in code (e.g. "youtube", "google_maps"). */
+  services?: readonly string[];
+  /**
+   * Hosts that are the Site itself besides relative URLs: its Frontend and its
+   * CMS/media origin. The CMS origin is included by default.
+   */
+  firstPartyHosts?: readonly string[];
+  /**
+   * Read gq-config's Legal Contract and GA4 settings into each language's
+   * chrome (requires gq-config with the `getquickLegal` field). Their changes
+   * arrive as `legal` and `analytics` settings events.
+   */
+  cmsSettings?: boolean;
+}
+declare function createContentRuntime<X = never>(input: ContentConfig<X>): {
+  languages: SiteLanguage[];
+  defaultLanguage: SiteLanguage;
+  multilingual: boolean;
+  routeLanguage: (route: string) => SiteLanguage;
+  isLanguageHome: (route: string) => boolean;
+  wordpress: WordPressClient<X>;
+  handleEvent: (request: Request, context?: {
+    siteOrigin?: string;
+  }) => Promise<Response>;
+  handleRefresh: (request: Request, context?: {
+    siteOrigin?: string;
+  }) => Promise<Response>;
+  publishedHome: (siteOrigin?: string, language?: SiteLanguage) => Promise<HomeDelivery<X>>;
+  publishedEntry: (path: string, siteOrigin?: string) => Promise<EntryDelivery<X>>;
+  /**
+   * A page of a collection's items, from the publication store alone (never
+   * WordPress), newest first: those with the given terms and text, in the
+   * language. Unavailable when the store can't be read, or there is none.
+   */
+  list: (query: CollectionQuery) => Promise<CollectionListing<X>>;
+  /**
+   * The terms of a collection's taxonomy that its stored items have, with how
+   * many of them have each, by name: for filters.
+   */
+  terms: (name: string, taxonomy: string, options?: {
+    language?: string;
+  }) => Promise<CollectionTermListing>;
+  /**
+   * Where a collection's archive is: the Page assigned to it in GETQUICK →
+   * Archives, else its post type's own archive. Null when it has neither, or
+   * the store can't be read.
+   */
+  archiveUri: (collection: string) => Promise<string | null>;
+  pageChrome: (siteOrigin?: string) => Promise<SiteChrome | null>;
+  /**
+   * A chrome pattern as HTML, by the Site's block renderers (see
+   * `renderDesignPattern`), with links into the CMS or `siteOrigin` served
+   * as this Site's paths.
+   */
+  renderDesignPattern: (pattern: DesignPattern | DesignBlock[] | null | undefined, options?: DesignRenderOptions & {
+    siteOrigin?: string;
+  }) => string;
+  /**
+   * The design presets every page shares (GQ Design's spacing sizes and
+   * colors), for a page that isn't a publication: the stored ones when there
+   * is a store, else (in explicit development) a live read. Null when
+   * neither has them.
+   */
+  designPresets: () => Promise<DesignPresets | null>;
+  /**
+   * The origins a link into this Site may use: WordPress's, and the
+   * Frontend's when given. `menuItemHref` turns links at them into paths.
+   */
+  internalOrigins: (siteOrigin?: string) => string[];
+  /**
+   * The Site's consent configuration for a page served with this chrome:
+   * declared services, GA4 when gq-config's toggle is on, and the
+   * controller from the Legal Contract. Null when consent isn't configured.
+   */
+  consentConfiguration: (chrome?: SiteChrome | null) => ConsentConfiguration | null;
+};
+type ContentRuntime<X = never> = ReturnType<typeof createContentRuntime<X>>;
+//#endregion
+//#region frontend/src/wordpress.d.ts
+interface WordPressClient<X = unknown> {
+  getHomeContent(this: void, language?: SiteLanguage): Promise<Delivery<HomeContent<X>>>;
+  getEntryByUri(this: void, uri: string): Promise<Delivery<EntryContent<X>>>;
+  getDesignPresets(this: void): Promise<Found<DesignPresets> | Unavailable>;
+  getPublishedEntries(this: void): Promise<Found<{
+    entries: PublishedEntry[];
+    requests: number;
+  }> | Unavailable>;
+  getPublishedRoutes(this: void): Promise<Found<string[]> | Unavailable>;
+  getArchives(this: void): Promise<Found<Archives> | Unavailable>;
+  getSiteChrome(this: void, siteOrigin?: string, options?: {
+    location?: string;
+    language?: SiteLanguage;
+  }): Promise<Found<SiteChrome> | Unavailable>;
+}
+//#endregion
+export { Found as $, htmlLang as A, designMenuItems as B, Moved as C, SqlStatement as D, SqlDatabase as E, DesignBlock as F, CmsFailure as G, parseDesignBlocks as H, DesignBlockRenderer as I, CollectionTerm as J, CmsFailureReason as K, DesignPattern as L, languageSubject as M, routeLanguage as N, SiteLanguage as O, siteLanguages as P, Extended as Q, DesignRenderContext as R, HomePublication as S, ContentBindings as T, renderDesignPattern as U, escapeHtml as V, Archives as W, DesignPresets as X, Delivery as Y, EntryContent as Z, EntryDelivery as _, ContentExtension as a, Unavailable as at, HomeDelivery as b, createContentRuntime as c, WordPressPost as ct, CollectionListing as d, HomeContent as et, CollectionPage as f, DeliveryFailureReason as g, CollectionTermListing as h, ContentConsentConfig as i, Translation as it, isLanguageHome as j, WordPressLanguages as k, Alternate as l, WordPressSettings as lt, CollectionTermCount as m, CollectionConfig as n, PublishedEntry as nt, ContentRuntime as o, WordPressImage as ot, CollectionQuery as p, CollectionMembership as q, ContentConfig as r, SiteChrome as rt, ExtensionNode as s, WordPressMenuItem as st, WordPressClient as t, Missing as tt, CollectionItem as u, EntryPage as v, NotServed as w, HomePage as x, EntryPublication as y, DesignRenderOptions as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getquick/content",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "license": "UNLICENSED",
   "files": [
     "dist",
@@ -45,6 +45,18 @@
     "./consent/testing": {
       "types": "./dist/consent-testing.d.ts",
       "import": "./dist/consent-testing.js"
+    },
+    "./metadata": {
+      "types": "./dist/metadata.d.ts",
+      "import": "./dist/metadata.js"
+    },
+    "./metadata/testing": {
+      "types": "./dist/metadata-testing.d.ts",
+      "import": "./dist/metadata-testing.js"
+    },
+    "./metadata/content": {
+      "types": "./dist/metadata-content.d.ts",
+      "import": "./dist/metadata-content.js"
     }
   },
   "publishConfig": {