@wollycms/astro 0.1.0

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@wollycms/astro",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Astro.js integration for WollyCMS — components, helpers, and route generation",
+  "author": "Chad Wollenberg",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wollycms/wollycms.git",
+    "directory": "packages/astro"
+  },
+  "homepage": "https://github.com/wollycms/wollycms",
+  "bugs": {
+    "url": "https://github.com/wollycms/wollycms/issues"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./components/BlockRenderer.astro": "./src/components/BlockRenderer.astro",
+    "./components/WollyImage.astro": "./src/components/WollyImage.astro",
+    "./components/RichText.astro": "./src/components/RichText.astro",
+    "./components/PreviewBlockRenderer.astro": "./src/components/PreviewBlockRenderer.astro",
+    "./helpers/tracking.js": "./src/helpers/tracking.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "keywords": [
+    "astro",
+    "withastro",
+    "astro-component",
+    "cms",
+    "wollycms",
+    "headless-cms",
+    "block-editor"
+  ],
+  "peerDependencies": {
+    "astro": "^5.0.0 || ^6.0.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,125 @@
+import type {
+  WollyConfig,
+  PageListParams,
+  PageSummary,
+  Page,
+  Menu,
+  Term,
+  MediaInfo,
+  MediaVariant,
+  Redirect,
+  SiteConfig,
+  Schemas,
+  ApiResponse,
+  PaginatedResponse,
+} from './types.js';
+import type { TrackingScriptsData } from './helpers/tracking.js';
+
+export class WollyClient {
+  private baseUrl: string;
+
+  constructor(config: WollyConfig) {
+    this.baseUrl = config.apiUrl.replace(/\/+$/, '');
+  }
+
+  private async fetch<T>(path: string): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`WollyCMS API error: ${res.status} ${res.statusText} (${url})`);
+    }
+    return res.json() as Promise<T>;
+  }
+
+  readonly pages = {
+    list: async (params?: PageListParams): Promise<PaginatedResponse<PageSummary>> => {
+      const searchParams = new URLSearchParams();
+      if (params?.type) searchParams.set('type', params.type);
+      if (params?.taxonomy) searchParams.set('taxonomy', params.taxonomy);
+      if (params?.sort) searchParams.set('sort', params.sort);
+      if (params?.limit) searchParams.set('limit', String(params.limit));
+      if (params?.offset) searchParams.set('offset', String(params.offset));
+      const qs = searchParams.toString();
+      return this.fetch(`/pages${qs ? `?${qs}` : ''}`);
+    },
+
+    getBySlug: async (slug: string): Promise<Page> => {
+      const res = await this.fetch<ApiResponse<Page>>(`/pages/${slug}`);
+      return res.data;
+    },
+  };
+
+  readonly menus = {
+    get: async (slug: string, depth?: number): Promise<Menu> => {
+      const qs = depth != null ? `?depth=${depth}` : '';
+      const res = await this.fetch<ApiResponse<Menu>>(`/menus/${slug}${qs}`);
+      return res.data;
+    },
+  };
+
+  readonly taxonomies = {
+    getTerms: async (slug: string): Promise<Term[]> => {
+      const res = await this.fetch<ApiResponse<Term[]>>(`/taxonomies/${slug}/terms`);
+      return res.data;
+    },
+  };
+
+  readonly media = {
+    getInfo: async (id: number): Promise<MediaInfo> => {
+      const res = await this.fetch<ApiResponse<MediaInfo>>(`/media/${id}/info`);
+      return res.data;
+    },
+
+    getVariant: async (id: number, variant: string): Promise<MediaVariant> => {
+      const res = await this.fetch<ApiResponse<MediaVariant>>(`/media/${id}/${variant}`);
+      return res.data;
+    },
+
+    url: (id: number, variant: string = 'original'): string => {
+      return `${this.baseUrl}/media/${id}/${variant}`;
+    },
+  };
+
+  readonly search = {
+    query: async (q: string, options?: { type?: string; limit?: number }): Promise<{ data: Array<{ id: number; type: string; title: string; slug: string; description: string | null }>; meta: { total: number; query: string } }> => {
+      const params = new URLSearchParams({ q });
+      if (options?.type) params.set('type', options.type);
+      if (options?.limit) params.set('limit', String(options.limit));
+      return this.fetch(`/search?${params}`);
+    },
+  };
+
+  readonly redirects = {
+    list: async (): Promise<Redirect[]> => {
+      const res = await this.fetch<ApiResponse<Redirect[]>>('/redirects');
+      return res.data;
+    },
+  };
+
+  readonly config = {
+    get: async (): Promise<SiteConfig> => {
+      const res = await this.fetch<ApiResponse<SiteConfig>>('/config');
+      return res.data;
+    },
+  };
+
+  readonly schemas = {
+    get: async (): Promise<Schemas> => {
+      const res = await this.fetch<ApiResponse<Schemas>>('/schemas');
+      return res.data;
+    },
+  };
+
+  readonly trackingScripts = {
+    /** Get active tracking scripts, optionally filtered for a specific page slug. */
+    getForPage: async (slug?: string): Promise<TrackingScriptsData> => {
+      const qs = slug ? `?page=${encodeURIComponent(slug)}` : '';
+      const res = await this.fetch<ApiResponse<TrackingScriptsData>>(`/tracking-scripts${qs}`);
+      return res.data;
+    },
+  };
+}
+
+export function createClient(config: WollyConfig): WollyClient {
+  return new WollyClient(config);
+}

package/src/components/BlockRenderer.astro

@@ -0,0 +1,31 @@
+---
+import type { ResolvedBlock } from '../types.js';
+
+interface Props {
+  blocks: ResolvedBlock[];
+  region: string;
+  components: Record<string, any>;
+}
+
+const { blocks, region, components } = Astro.props;
+---
+
+{blocks.map((block, index) => {
+  const Component = components[block.block_type];
+  if (!Component) {
+    return <div class="wolly-block-unknown" data-type={block.block_type}>Unknown block type: {block.block_type}</div>;
+  }
+  return (
+    <Component
+      fields={block.fields}
+      block={{
+        id: block.id,
+        type: block.block_type,
+        title: block.title,
+        is_shared: block.is_shared,
+      }}
+      region={region}
+      position={index}
+    />
+  );
+})}

package/src/components/PreviewBlockRenderer.astro

@@ -0,0 +1,43 @@
+---
+/**
+ * PreviewBlockRenderer — Like BlockRenderer but wraps each block in a
+ * clickable wrapper div for the admin inline-editing bridge.
+ * Only used in preview pages, not in production rendering.
+ */
+import type { ResolvedBlock } from '../types.js';
+
+interface Props {
+  blocks: ResolvedBlock[];
+  region: string;
+  components: Record<string, any>;
+}
+
+const { blocks, region, components } = Astro.props;
+---
+
+{blocks.map((block, index) => {
+  const Component = components[block.block_type];
+  if (!Component) {
+    return <div class="wolly-block wolly-block-unknown" data-wolly-pb={block.id} data-wolly-region={region} data-wolly-type={block.block_type}>Unknown block type: {block.block_type}</div>;
+  }
+  return (
+    <div
+      class="wolly-block"
+      data-wolly-pb={block.id}
+      data-wolly-region={region}
+      data-wolly-type={block.block_type}
+    >
+      <Component
+        fields={block.fields}
+        block={{
+          id: block.id,
+          type: block.block_type,
+          title: block.title,
+          is_shared: block.is_shared,
+        }}
+        region={region}
+        position={index}
+      />
+    </div>
+  );
+})}

package/src/components/RichText.astro

@@ -0,0 +1,13 @@
+---
+import { renderRichText } from '../helpers/richtext.js';
+
+interface Props {
+  content: any;
+  class?: string;
+}
+
+const { content, class: className } = Astro.props;
+const html = renderRichText(content);
+---
+
+<div class:list={['rich-text', className]} set:html={html} />

package/src/components/SpacelyImage.astro

@@ -0,0 +1,34 @@
+---
+interface Props {
+  src: string;
+  alt?: string;
+  width?: number;
+  height?: number;
+  srcset?: string;
+  sizes?: string;
+  loading?: 'lazy' | 'eager';
+  class?: string;
+}
+
+const {
+  src,
+  alt = '',
+  width,
+  height,
+  srcset,
+  sizes,
+  loading = 'lazy',
+  class: className,
+} = Astro.props;
+---
+
+<img
+  src={src}
+  alt={alt}
+  width={width}
+  height={height}
+  srcset={srcset}
+  sizes={sizes}
+  loading={loading}
+  class={className}
+/>

package/src/helpers/menu.ts

@@ -0,0 +1,75 @@
+import type { MenuItem } from '../types.js';
+
+/** Get the href for a menu item */
+export function getItemHref(item: MenuItem): string | null {
+  if (item.url) return item.url;
+  if (item.page_slug) return `/${item.page_slug}`;
+  return null;
+}
+
+/** Check if a menu item or any of its children match the current path */
+export function isActive(item: MenuItem, currentPath: string): boolean {
+  const href = getItemHref(item);
+  const normalized = currentPath.replace(/\/+$/, '') || '/';
+
+  if (href) {
+    const normalizedHref = href.replace(/\/+$/, '') || '/';
+    if (normalizedHref === normalized) return true;
+  }
+
+  return item.children.some((child) => isActive(child, currentPath));
+}
+
+/** Get the breadcrumb trail from a menu tree to the current path */
+export function getBreadcrumbs(
+  items: MenuItem[],
+  currentPath: string,
+): MenuItem[] {
+  const normalized = currentPath.replace(/\/+$/, '') || '/';
+
+  for (const item of items) {
+    const href = getItemHref(item);
+    const normalizedHref = href ? href.replace(/\/+$/, '') || '/' : null;
+
+    if (normalizedHref === normalized) {
+      return [item];
+    }
+
+    if (item.children.length > 0) {
+      const trail = getBreadcrumbs(item.children, currentPath);
+      if (trail.length > 0) {
+        return [item, ...trail];
+      }
+    }
+  }
+
+  return [];
+}
+
+/** Get direct children of a menu item by its slug or URL */
+export function getChildren(
+  items: MenuItem[],
+  identifier: string,
+): MenuItem[] {
+  for (const item of items) {
+    const href = getItemHref(item);
+    if (href === identifier || href === `/${identifier}`) {
+      return item.children;
+    }
+    const found = getChildren(item.children, identifier);
+    if (found.length > 0) return found;
+  }
+  return [];
+}
+
+/** Flatten a menu tree into a list */
+export function flattenMenu(items: MenuItem[]): MenuItem[] {
+  const result: MenuItem[] = [];
+  for (const item of items) {
+    result.push(item);
+    if (item.children.length > 0) {
+      result.push(...flattenMenu(item.children));
+    }
+  }
+  return result;
+}

package/src/helpers/richtext.ts

@@ -0,0 +1,114 @@
+/** TipTap JSON node types */
+interface TipTapNode {
+  type: string;
+  content?: TipTapNode[];
+  text?: string;
+  attrs?: Record<string, unknown>;
+  marks?: Array<{ type: string; attrs?: Record<string, unknown> }>;
+}
+
+/** Escape HTML special characters */
+function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+/** Render marks (bold, italic, links, etc.) around text */
+function renderMarks(text: string, marks?: TipTapNode['marks']): string {
+  if (!marks || marks.length === 0) return escapeHtml(text);
+
+  let result = escapeHtml(text);
+  for (const mark of marks) {
+    switch (mark.type) {
+      case 'bold':
+        result = `<strong>${result}</strong>`;
+        break;
+      case 'italic':
+        result = `<em>${result}</em>`;
+        break;
+      case 'underline':
+        result = `<u>${result}</u>`;
+        break;
+      case 'strike':
+        result = `<s>${result}</s>`;
+        break;
+      case 'code':
+        result = `<code>${result}</code>`;
+        break;
+      case 'link': {
+        const href = escapeHtml(String(mark.attrs?.href ?? ''));
+        const target = mark.attrs?.target ? ` target="${escapeHtml(String(mark.attrs.target))}"` : '';
+        result = `<a href="${href}"${target}>${result}</a>`;
+        break;
+      }
+      case 'subscript':
+        result = `<sub>${result}</sub>`;
+        break;
+      case 'superscript':
+        result = `<sup>${result}</sup>`;
+        break;
+    }
+  }
+  return result;
+}
+
+/** Render a TipTap JSON node to HTML */
+function renderNode(node: TipTapNode): string {
+  if (node.type === 'text') {
+    return renderMarks(node.text ?? '', node.marks);
+  }
+
+  const children = node.content?.map(renderNode).join('') ?? '';
+
+  switch (node.type) {
+    case 'doc':
+      return children;
+    case 'paragraph':
+      return `<p>${children}</p>`;
+    case 'heading': {
+      const level = Math.min(Math.max(Number(node.attrs?.level ?? 2), 1), 6);
+      return `<h${level}>${children}</h${level}>`;
+    }
+    case 'bulletList':
+      return `<ul>${children}</ul>`;
+    case 'orderedList':
+      return `<ol>${children}</ol>`;
+    case 'listItem':
+      return `<li>${children}</li>`;
+    case 'blockquote':
+      return `<blockquote>${children}</blockquote>`;
+    case 'codeBlock': {
+      const lang = node.attrs?.language ? ` class="language-${escapeHtml(String(node.attrs.language))}"` : '';
+      return `<pre><code${lang}>${children}</code></pre>`;
+    }
+    case 'horizontalRule':
+      return '<hr />';
+    case 'hardBreak':
+      return '<br />';
+    case 'image': {
+      const src = escapeHtml(String(node.attrs?.src ?? ''));
+      const alt = escapeHtml(String(node.attrs?.alt ?? ''));
+      const title = node.attrs?.title ? ` title="${escapeHtml(String(node.attrs.title))}"` : '';
+      return `<img src="${src}" alt="${alt}"${title} />`;
+    }
+    case 'table':
+      return `<table>${children}</table>`;
+    case 'tableRow':
+      return `<tr>${children}</tr>`;
+    case 'tableHeader':
+      return `<th>${children}</th>`;
+    case 'tableCell':
+      return `<td>${children}</td>`;
+    default:
+      return children;
+  }
+}
+
+/** Convert TipTap JSON document to HTML string */
+export function renderRichText(doc: TipTapNode | null | undefined): string {
+  if (!doc || doc.type !== 'doc') return '';
+  return renderNode(doc);
+}

package/src/helpers/seo.ts

@@ -0,0 +1,123 @@
+import type { Page, SiteConfig } from '../types.js';
+
+export interface SeoMeta {
+  title: string;
+  description?: string;
+  ogImage?: string;
+  canonicalUrl?: string;
+  robots?: string;
+}
+
+/**
+ * Generate meta tag objects from a page's SEO fields.
+ * Use with Astro's <head> to render meta tags.
+ */
+export function getPageSeo(page: Page, siteConfig?: SiteConfig): SeoMeta {
+  const seo = page.seo;
+  const siteName = siteConfig?.siteName || 'WollyCMS';
+
+  return {
+    title: seo?.meta_title || `${page.title} | ${siteName}`,
+    description: seo?.meta_description || undefined,
+    ogImage: seo?.og_image || undefined,
+    canonicalUrl: seo?.canonical_url || undefined,
+    robots: seo?.robots || undefined,
+  };
+}
+
+/** Article structured data (JSON-LD) */
+export function articleJsonLd(page: Page, options: {
+  siteUrl: string;
+  siteName?: string;
+  authorName?: string;
+  ogImage?: string;
+}): Record<string, unknown> {
+  const seo = page.seo;
+
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'Article',
+    headline: seo?.meta_title || page.title,
+    description: seo?.meta_description || undefined,
+    image: seo?.og_image || options.ogImage || undefined,
+    datePublished: page.meta.published_at || page.meta.created_at,
+    dateModified: page.meta.updated_at,
+    url: `${options.siteUrl.replace(/\/$/, '')}/${page.slug}`,
+    publisher: {
+      '@type': 'Organization',
+      name: options.siteName || 'WollyCMS',
+    },
+    author: options.authorName ? {
+      '@type': 'Person',
+      name: options.authorName,
+    } : undefined,
+  };
+}
+
+/** WebPage structured data (JSON-LD) */
+export function webPageJsonLd(page: Page, options: {
+  siteUrl: string;
+  siteName?: string;
+}): Record<string, unknown> {
+  const seo = page.seo;
+
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'WebPage',
+    name: seo?.meta_title || page.title,
+    description: seo?.meta_description || undefined,
+    url: `${options.siteUrl.replace(/\/$/, '')}/${page.slug}`,
+    datePublished: page.meta.published_at || page.meta.created_at,
+    dateModified: page.meta.updated_at,
+    isPartOf: {
+      '@type': 'WebSite',
+      name: options.siteName || 'WollyCMS',
+      url: options.siteUrl,
+    },
+  };
+}
+
+/** BreadcrumbList structured data from menu hierarchy */
+export function breadcrumbJsonLd(
+  breadcrumbs: Array<{ title: string; url: string }>,
+  siteUrl: string,
+): Record<string, unknown> {
+  const baseUrl = siteUrl.replace(/\/$/, '');
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'BreadcrumbList',
+    itemListElement: breadcrumbs.map((crumb, i) => ({
+      '@type': 'ListItem',
+      position: i + 1,
+      name: crumb.title,
+      item: crumb.url.startsWith('http') ? crumb.url : `${baseUrl}${crumb.url}`,
+    })),
+  };
+}
+
+/** Organization structured data */
+export function organizationJsonLd(config: SiteConfig, options: {
+  siteUrl: string;
+  logoUrl?: string;
+}): Record<string, unknown> {
+  const sameAs: string[] = [];
+  if (config.social?.facebook) sameAs.push(config.social.facebook);
+  if (config.social?.twitter) sameAs.push(config.social.twitter);
+  if (config.social?.instagram) sameAs.push(config.social.instagram);
+
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'Organization',
+    name: config.siteName,
+    url: options.siteUrl,
+    logo: options.logoUrl || undefined,
+    sameAs: sameAs.length > 0 ? sameAs : undefined,
+  };
+}
+
+/** Serialize JSON-LD to a script tag string for use in <head> */
+export function jsonLdScript(data: Record<string, unknown>): string {
+  // Remove undefined values for cleaner output
+  const cleaned = JSON.parse(JSON.stringify(data));
+  return `<script type="application/ld+json">${JSON.stringify(cleaned)}</script>`;
+}

package/src/helpers/tracking.ts

@@ -0,0 +1,33 @@
+/** Tracking script entry from content API */
+export interface TrackingScript {
+  id: number;
+  name: string;
+  code: string;
+}
+
+/** Tracking scripts grouped by position */
+export interface TrackingScriptsData {
+  head: TrackingScript[];
+  body: TrackingScript[];
+}
+
+/**
+ * Render head tracking scripts as raw HTML for use in Astro's <head>.
+ * Each script is wrapped with an HTML comment for debuggability.
+ */
+export function renderHeadScripts(scripts: TrackingScriptsData): string {
+  if (!scripts.head.length) return '';
+  return scripts.head
+    .map((s) => `<!-- WollyCMS Tracking: ${s.name} -->\n${s.code}`)
+    .join('\n');
+}
+
+/**
+ * Render body tracking scripts as raw HTML for use before </body>.
+ */
+export function renderBodyScripts(scripts: TrackingScriptsData): string {
+  if (!scripts.body.length) return '';
+  return scripts.body
+    .map((s) => `<!-- WollyCMS Tracking: ${s.name} -->\n${s.code}`)
+    .join('\n');
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export { WollyClient, createClient } from './client.js';
+export * from './types.js';
+export * as menuHelpers from './helpers/menu.js';
+export { renderRichText } from './helpers/richtext.js';
+export * as seoHelpers from './helpers/seo.js';
+export * as trackingHelpers from './helpers/tracking.js';

package/src/types.ts

@@ -0,0 +1,214 @@
+/** API response wrapper */
+export interface ApiResponse<T> {
+  data: T;
+}
+
+/** Paginated list response */
+export interface PaginatedResponse<T> {
+  data: T[];
+  meta: {
+    total: number;
+    limit: number;
+    offset: number;
+  };
+}
+
+/** Page metadata */
+export interface PageMeta {
+  created_at: string;
+  updated_at: string;
+  published_at: string | null;
+}
+
+/** Page summary (from list endpoint) */
+/** Taxonomy term attached to a page */
+export interface PageTerm {
+  taxonomy: string;
+  term: string;
+  weight: number;
+}
+
+export interface PageSummary {
+  id: number;
+  type: string;
+  title: string;
+  slug: string;
+  status: 'draft' | 'published' | 'archived';
+  fields: Record<string, unknown>;
+  terms?: PageTerm[];
+  meta: PageMeta;
+}
+
+/** Resolved block in a page region */
+export interface ResolvedBlock {
+  id: string;
+  block_type: string;
+  title?: string;
+  is_shared?: boolean;
+  block_id?: number;
+  fields: Record<string, unknown>;
+}
+
+/** SEO metadata for a page (matches content API snake_case keys) */
+export interface PageSeo {
+  meta_title: string | null;
+  meta_description: string | null;
+  og_image: string | null;
+  canonical_url: string | null;
+  robots: string | null;
+}
+
+/** Full page with resolved regions */
+export interface Page extends PageSummary {
+  regions: Record<string, ResolvedBlock[]>;
+  seo?: PageSeo;
+}
+
+/** Menu item (recursive tree) */
+export interface MenuItem {
+  id: number;
+  title: string;
+  url: string | null;
+  page_slug: string | null;
+  target: string;
+  attributes: Record<string, unknown> | null;
+  children: MenuItem[];
+}
+
+/** Menu */
+export interface Menu {
+  id: number;
+  name: string;
+  slug: string;
+  items: MenuItem[];
+}
+
+/** Taxonomy term */
+export interface Term {
+  id: number;
+  name: string;
+  slug: string;
+  weight: number;
+  fields: Record<string, unknown> | null;
+  children?: Term[];
+}
+
+/** Media info */
+export interface MediaInfo {
+  id: number;
+  filename: string;
+  originalName: string;
+  mimeType: string;
+  size: number;
+  width: number | null;
+  height: number | null;
+  altText: string | null;
+  title: string | null;
+  variants: Record<string, string>;
+  metadata: Record<string, unknown> | null;
+  createdAt: string;
+}
+
+/** Media variant reference */
+export interface MediaVariant {
+  id: number;
+  variant: string;
+  mimeType: string;
+  path: string;
+  width: number | null;
+  height: number | null;
+  altText: string | null;
+  title: string | null;
+}
+
+/** Redirect */
+export interface Redirect {
+  id: number;
+  fromPath: string;
+  toPath: string;
+  statusCode: number;
+}
+
+/** Site config */
+export interface SiteConfig {
+  siteName: string;
+  tagline: string;
+  logo: string | null;
+  footer: { text: string };
+  social: {
+    facebook: string | null;
+    twitter: string | null;
+    instagram: string | null;
+  };
+}
+
+/** Field schema definition */
+export interface FieldDefinition {
+  name: string;
+  label: string;
+  type: string;
+  required?: boolean;
+  default?: unknown;
+  options?: Array<{ value: string; label: string }>;
+  fields?: FieldDefinition[];
+  min?: number;
+  max?: number;
+}
+
+/** Content type schema */
+export interface ContentTypeSchema {
+  id: number;
+  name: string;
+  slug: string;
+  description: string | null;
+  fieldsSchema: FieldDefinition[];
+  regions: Array<{
+    name: string;
+    label: string;
+    allowed_types: string[] | null;
+  }>;
+}
+
+/** Block type schema */
+export interface BlockTypeSchema {
+  id: number;
+  name: string;
+  slug: string;
+  description: string | null;
+  fieldsSchema: FieldDefinition[];
+  icon: string | null;
+}
+
+/** Schemas response */
+export interface Schemas {
+  contentTypes: ContentTypeSchema[];
+  blockTypes: BlockTypeSchema[];
+}
+
+/** Block component props */
+export interface BlockProps {
+  fields: Record<string, unknown>;
+  block: {
+    id: string;
+    type: string;
+    title?: string;
+    is_shared?: boolean;
+  };
+  region: string;
+  position: number;
+}
+
+/** Client configuration */
+export interface WollyConfig {
+  apiUrl: string;
+}
+
+/** Page list query parameters */
+export interface PageListParams {
+  type?: string;
+  taxonomy?: string;
+  sort?: string;
+  limit?: number;
+  offset?: number;
+  status?: string;
+}