@postedin/cms-client 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,570 @@
+import { Locale, LocaleOptions, HomePageRef, CmsLink, Locales, CmsMainMenu, Routes } from './browser.js';
+export { CmsCallToActionLinks, CmsFooter, CmsHeader, CmsMenuItem, CmsSocialLinks, CmsToHref, CreateRoutes, defineCmsToHref, defineLocales, defineRoutes } from './browser.js';
+import { Media, Project, Area, Page, TeamMember, Tag, Question, QuestionTag, Category, Post, Appearance, Author, Banner, ImageLink, Form, HeaderFooter, Options as Options$1, Seo, MemberType } from './payload-types.js';
+
+/** Which of the two URL helpers is asking: a download link or an `<img>`. */
+type UploadUse = 'file' | 'image';
+/**
+ * A site's own rule for where an upload is served from. Return a URL to use
+ * it, or `undefined` to let the default rule decide. Consulted for every
+ * production build, bucket or not, since a site's rewrites do not depend on
+ * one; in dev the URL the CMS returned is always used.
+ */
+type ResolveUploadUrl = (media: Media, use: UploadUse) => string | null | undefined;
+interface ApiOptions {
+    apiUrl: string;
+    apiKey: string;
+    projectSlug: string;
+    uploadsBaseUrl?: string;
+    protectionBypassSecret?: string;
+    isDev: boolean;
+    pageConcurrency?: number;
+    resolveUploadUrl?: ResolveUploadUrl;
+}
+type Collection<T> = {
+    docs: T[];
+    totalDocs: number;
+    limit: number;
+    totalPages: number;
+    page: number;
+    pagingCounter: number;
+    hasPrevPage: boolean;
+    hasNextPage: boolean;
+    prevPage: number | null;
+    nextPage: number | null;
+};
+declare function mapWithConcurrency<TItem, TResult>(items: TItem[], limit: number, worker: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;
+type FallbackMode = 'null' | 'default';
+type FetchCmsGlobalOptions = {
+    query?: any;
+    depth?: number;
+    locale?: Locale;
+    fallback?: FallbackMode;
+};
+type FetchCmsCollectionOptions = FetchCmsGlobalOptions & {
+    status?: string;
+    limit?: number;
+    sort?: string;
+};
+type Api = ReturnType<typeof createApi>;
+declare function createApi(options: ApiOptions): {
+    apiUrl: (url: string, query?: any, scoped?: boolean) => string;
+    buildHeaders: () => Record<string, string>;
+    getUploadsPublicUrl: (endpoint: string) => string;
+    fileUrl: (media?: Media | null) => string | null;
+    imageUrl: (media?: Media | null) => string;
+    fetchCmsFile: (url: string) => Promise<Response>;
+    fetchCmsGlobal: <T>(global: string, fetchOptions?: FetchCmsGlobalOptions) => Promise<T>;
+    fetchCmsGlobalCollection: <T>(collection: string, fetchOptions?: FetchCmsGlobalOptions) => Promise<T>;
+    fetchCmsCollection: <T>(collection: string, fetchOptions?: FetchCmsCollectionOptions) => Promise<T[]>;
+    fetchCmsProject: () => Promise<Project>;
+};
+
+declare function createGlobalLoader<TInput, TOutput = TInput>(fetchFn: () => Promise<TInput>, options?: {
+    transform?: (data: TInput) => Promise<TOutput> | TOutput;
+}): () => Promise<TOutput | NonNullable<TOutput>>;
+interface Doc {
+    id: string;
+    slug?: string;
+    path?: string;
+    title?: string;
+    name?: string | null;
+}
+declare function createCollectionLoader<TInput extends Array<any>, TOutput extends Array<any> = TInput>(fetchFn: () => Promise<TInput>, options?: {
+    transform?: (data: TInput) => Promise<TOutput> | TOutput;
+}): (() => Promise<TOutput>) & {
+    page: (page: number, limit: number, options?: {
+        excluded: Doc[];
+    }) => Promise<TOutput>;
+    find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+    filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+};
+
+interface WiredArea extends Omit<Area, 'page'> {
+    page?: Page | null;
+}
+
+interface WiredTeamMember extends Omit<TeamMember, 'slug' | 'areas'> {
+    slug: string;
+    areas?: {
+        docs?: (string | WiredArea)[];
+        hasNextPage?: boolean;
+        totalDocs?: number;
+    };
+}
+
+interface WiredTag extends Tag {
+}
+
+interface WiredQuestion extends Omit<Question, 'tags'> {
+    tags: QuestionTag[];
+}
+
+type CategoryBreadcrumb = {
+    label: string;
+    url: string;
+};
+interface WiredCategory extends Omit<Category, 'parent' | 'slug'> {
+    slug: string;
+    parent?: WiredCategory;
+    children: WiredCategory[];
+    path: string;
+    breadcrumbs: CategoryBreadcrumb[];
+}
+/**
+ * A category plus how many posts are filed under it. The count follows the same
+ * rule as `cms.posts.findByCategory`, counting a post under its primary and its
+ * secondary categories alike, so the number a listing prints is the number of
+ * entries the category page then shows.
+ */
+interface CountedCategory extends WiredCategory {
+    postCount: number;
+}
+
+interface WiredPost extends Post {
+    coverImage?: Media | null;
+    category?: WiredCategory | null;
+    secondaryCategories?: WiredCategory[];
+    tags?: WiredTag[];
+    searchTokens: string;
+}
+
+interface WiredPage extends Omit<Page, 'parent'> {
+    parent?: WiredPage;
+    children: WiredPage[];
+    path: string;
+}
+
+type WiredAppearance = Appearance & {
+    branding: NonNullable<Appearance['branding']> & {
+        brandColor: NonNullable<NonNullable<Appearance['branding']>['brandColor']>;
+        logo: NonNullable<NonNullable<Appearance['branding']>['logo']>;
+    };
+    backgroundColor: {
+        lightTheme: string;
+        darkTheme: string;
+    };
+};
+/**
+ * What a blank Appearance field falls back to. Both are CSS values, and both
+ * are a site's own: the template states them in its theme file, so its
+ * defaults are variables that file defines.
+ */
+interface AppearanceFallbacks {
+    brandColor: string;
+    backgroundColor: {
+        lightTheme: string;
+        darkTheme: string;
+    };
+}
+declare const DEFAULT_APPEARANCE_FALLBACKS: AppearanceFallbacks;
+
+interface WiredAuthor extends Omit<Author, 'slug'> {
+    slug: string;
+}
+
+type Cms = ReturnType<typeof buildCms>;
+declare function buildCms(ctx: Context, locale: Locale): {
+    locale: "es" | "en";
+    areas: {
+        all: (() => Promise<WiredArea[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<WiredArea[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+    };
+    authors: {
+        all: (() => Promise<WiredAuthor[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<WiredAuthor[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+        findBySlug: (slug: string) => Promise<any>;
+    };
+    banners: {
+        all: (() => Promise<Banner[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<Banner[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+    };
+    appearance: () => Promise<WiredAppearance | NonNullable<WiredAppearance>>;
+    imageLinks: {
+        all: (() => Promise<ImageLink[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<ImageLink[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+    };
+    categories: {
+        populated: () => Promise<WiredCategory[]>;
+        withCounts: () => Promise<CountedCategory[]>;
+        all: (() => Promise<WiredCategory[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<WiredCategory[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+        wire: (category: Category | string | null | undefined) => Promise<WiredCategory | null | undefined>;
+    };
+    forms: {
+        all: (() => Promise<Form[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<Form[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+        findById: (id: string) => Promise<Form | null>;
+        resolve: (form: Form | string) => Promise<Form | null>;
+    };
+    headerFooter: () => Promise<HeaderFooter>;
+    media: {
+        all: (() => Promise<Media[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<Media[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+    };
+    options: () => Promise<Options$1>;
+    pages: {
+        all: (() => Promise<WiredPage[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<WiredPage[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+        findByPath: (path: string) => Promise<WiredPage | undefined>;
+        findById: (id: string) => Promise<WiredPage | null>;
+    };
+    posts: {
+        all: (() => Promise<WiredPost[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<WiredPost[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+        exists: () => Promise<boolean>;
+        page: (page: number, limit: number, options?: {
+            excluded: Doc[];
+        } | undefined) => Promise<WiredPost[]>;
+        latest: () => Promise<WiredPost[]>;
+        featured: () => Promise<WiredPost[]>;
+        related: (post: WiredPost, limit?: number) => Promise<any[]>;
+        findBySlug: (slug: string) => Promise<any>;
+        findByAuthor: (author: Author) => Promise<any[]>;
+        findByTeamMember: (memberId: string) => Promise<WiredPost[]>;
+        findByCategory: (category: Category) => Promise<any[]>;
+        findByTag: (tag: Tag) => Promise<any[]>;
+        nextInCategory: (post: WiredPost) => Promise<WiredPost | undefined>;
+    };
+    project: () => Promise<Project>;
+    questions: {
+        all: (() => Promise<WiredQuestion[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<WiredQuestion[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+        filterByTag: (searchTag: QuestionTag) => Promise<any[]>;
+    };
+    seo: () => Promise<Seo>;
+    tags: {
+        all: (() => Promise<WiredTag[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<WiredTag[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+        findBySlug: (slug: string) => Promise<any>;
+    };
+    teamMembers: {
+        all: (() => Promise<WiredTeamMember[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<WiredTeamMember[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+        types: (() => Promise<MemberType[]>) & {
+            page: (page: number, limit: number, options?: {
+                excluded: Doc[];
+            }) => Promise<MemberType[]>;
+            find: (predicate: Parameters<any[]["find"]>[0]) => Promise<any>;
+            filter: (predicate: Parameters<any[]["filter"]>[0]) => Promise<any[]>;
+        };
+        findBySlug: (slug: string) => Promise<any>;
+    };
+};
+
+interface RateLimiter {
+    allow(key: string): boolean;
+}
+interface Options {
+    limit: number;
+    windowMs: number;
+    now?: () => number;
+}
+declare function createRateLimiter({ limit, windowMs, now, }: Options): RateLimiter;
+
+type CmsResult = {
+    status: number;
+    id?: string;
+    fields?: string[];
+};
+interface FormOwnershipCheck {
+    formBelongsToProject(formId: string): Promise<boolean>;
+}
+interface ProxyDeps<TClient extends FormOwnershipCheck> {
+    projectId: string;
+    cms: TClient;
+    clientAddress: string;
+    rateLimiter?: RateLimiter;
+    /**
+     * The locales a submission may name. Defaults to every locale the CMS
+     * schema knows.
+     */
+    locales?: readonly string[];
+}
+
+interface SubmissionsCmsClient extends FormOwnershipCheck {
+    createSubmission(payload: {
+        form: string;
+        project: string;
+        data: Record<string, unknown>;
+        honeypot: string;
+    }, locale?: Locale): Promise<CmsResult>;
+}
+declare const MAX_SUBMISSION_BYTES: number;
+declare function handleFormSubmission(request: Request, deps: ProxyDeps<SubmissionsCmsClient>): Promise<Response>;
+
+interface UploadsCmsClient extends FormOwnershipCheck {
+    createUpload(file: File, payload: {
+        form: string;
+        project: string;
+    }): Promise<CmsResult>;
+}
+declare function handleFormUpload(request: Request, deps: ProxyDeps<UploadsCmsClient>): Promise<Response>;
+
+type FormProxyCmsClient = SubmissionsCmsClient & UploadsCmsClient;
+declare function createFormProxyCmsClient(api: Pick<Api, 'buildHeaders' | 'fetchCmsCollection'>, apiUrl: string): FormProxyCmsClient;
+
+declare function refusedFieldNames(body: unknown): string[];
+
+/**
+ * The part of an Astro `APIContext` the proxy reads. `clientAddress` is a
+ * getter that throws on a prerendered route, which is why it is read guarded.
+ */
+interface RequestContext {
+    readonly clientAddress: string;
+}
+type FormProxy = ReturnType<typeof createFormProxy>;
+declare function createFormProxy(cms: FormProxyCmsClient, project: () => Promise<Project>, locales: readonly string[]): {
+    cms: FormProxyCmsClient;
+    submissionLimiter: RateLimiter;
+    uploadLimiter: RateLimiter;
+    buildProxyDeps: (context: RequestContext, rateLimiter: RateLimiter) => Promise<ProxyDeps<FormProxyCmsClient>>;
+    handleFormSubmission: typeof handleFormSubmission;
+    handleFormUpload: typeof handleFormUpload;
+};
+
+interface BlogListing {
+    /**
+     * What the project calls its blog. `null` when no blog page is configured or
+     * the editor left the field blank, in which case the caller falls back to the
+     * `blog.title` translation.
+     */
+    name: string | null;
+    /** Intro copy for the listing, in the dual Lexical/HTML shape. */
+    description: Page['listingDescription'] | null;
+}
+
+/** What an extension collection is built from. */
+interface ExtensionContext {
+    api: Context['api'];
+    locale: Locale;
+    /** The client's other services, for a collection that wires against them. */
+    cms: (locale: Locale) => Cms;
+    createCollectionLoader: typeof createCollectionLoader;
+    createGlobalLoader: typeof createGlobalLoader;
+}
+/**
+ * A collection only one site reads. It is built per locale and appears on
+ * `client.cms(locale)` under the key it was registered with.
+ */
+type Extension<T = unknown> = (context: ExtensionContext) => T;
+/** What each extension builds, by the key it appears under. */
+type Extensions = Record<string, unknown>;
+type CmsWith<E extends Extensions> = Cms & E;
+interface ClientOptions<E extends Extensions = Record<never, never>> extends LocaleOptions {
+    /** The CMS origin, e.g. `https://cms.example.com`. */
+    apiUrl: string;
+    /** A project-scoped `api-keys` document's key. */
+    apiKey: string;
+    /** Every query is scoped to this project. */
+    projectSlug: string;
+    /** Public origin of the uploads bucket. Without it the CMS serves files. */
+    uploadsBaseUrl?: string;
+    /** Sent as `x-vercel-protection-bypass` when the CMS sits behind it. */
+    protectionBypassSecret?: string;
+    /** Dev serves every upload from the CMS's own URL. */
+    isDev: boolean;
+    /**
+     * The Appearance document, fetched at config time. Required for
+     * `cms.appearance()`; a config-time client leaves it out.
+     */
+    appearance?: Appearance;
+    /** What a blank Appearance field falls back to. */
+    appearanceFallbacks?: AppearanceFallbacks;
+    /**
+     * The Project document, fetched at config time. Required for
+     * `cms.project()` and the form proxy; a config-time client leaves it out.
+     */
+    project?: Project;
+    /** Collection pages fetched at a time. Default 4. */
+    pageConcurrency?: number;
+    /** A site's own rule for where an upload is served from. */
+    resolveUploadUrl?: ResolveUploadUrl;
+    /** Collections only this site reads, by the key they appear under. */
+    extensions?: {
+        [K in keyof E]: Extension<E[K]>;
+    };
+}
+type Client<E extends Extensions = Record<never, never>> = ReturnType<typeof createClient<E>>;
+/**
+ * The CMS client a site builds once from its environment. Nothing in here
+ * reads the environment itself: an npm-installed package is externalised by
+ * Astro, so `import.meta.env` would be empty by the time it ran.
+ */
+declare function createClient<E extends Extensions = Record<never, never>>(options: ClientOptions<E>): {
+    options: ClientOptions<E>;
+    locales: {
+        locales: readonly ("es" | "en")[];
+        defaultLocale: "es" | "en";
+        localePrefix: Readonly<Record<"es" | "en", string>>;
+        isLocale: (value: unknown) => value is Locale;
+        resolveLocale: (value: unknown) => Locale;
+        prefixPath: (path: string, locale: Locale) => string;
+        stripLocalePrefix: (path: string) => {
+            locale: Locale;
+            path: string;
+        };
+    };
+    api: {
+        apiUrl: (url: string, query?: any, scoped?: boolean) => string;
+        buildHeaders: () => Record<string, string>;
+        getUploadsPublicUrl: (endpoint: string) => string;
+        fileUrl: (media?: Media | null) => string | null;
+        imageUrl: (media?: Media | null) => string;
+        fetchCmsFile: (url: string) => Promise<Response>;
+        fetchCmsGlobal: <T>(global: string, fetchOptions?: FetchCmsGlobalOptions) => Promise<T>;
+        fetchCmsGlobalCollection: <T>(collection: string, fetchOptions?: FetchCmsGlobalOptions) => Promise<T>;
+        fetchCmsCollection: <T>(collection: string, fetchOptions?: FetchCmsCollectionOptions) => Promise<T[]>;
+        fetchCmsProject: () => Promise<Project>;
+    };
+    cms: (locale?: Locale) => CmsWith<E>;
+    routes: (locale: Locale, homePage?: HomePageRef) => {
+        readonly locale: "es" | "en";
+        readonly root: <T extends "index" | "search" = "index">(name?: T, ...params: Parameters<{
+            readonly index: () => string;
+            readonly search: () => string;
+        }[T]>) => ReturnType<{
+            readonly index: () => string;
+            readonly search: () => string;
+        }[T]>;
+        readonly blog: <T extends "page" | "author" | "category" | "post" | "tag" | "index" | "more" = "index">(name?: T, ...params: Parameters<{
+            readonly index: () => string;
+            readonly more: () => string;
+            readonly page: (n: number) => string;
+            readonly category: (path: string) => string;
+            readonly author: (slug: string) => string;
+            readonly post: (slug: string) => string;
+            readonly tag: (slug: string) => string;
+        }[T]>) => ReturnType<{
+            readonly index: () => string;
+            readonly more: () => string;
+            readonly page: (n: number) => string;
+            readonly category: (path: string) => string;
+            readonly author: (slug: string) => string;
+            readonly post: (slug: string) => string;
+            readonly tag: (slug: string) => string;
+        }[T]>;
+        readonly team: <T extends "index" | "member" | "vcard" = "index">(name?: T, ...params: Parameters<{
+            readonly index: () => string;
+            readonly member: (slug: string) => string;
+            readonly vcard: (slug: string) => string;
+        }[T]>) => ReturnType<{
+            readonly index: () => string;
+            readonly member: (slug: string) => string;
+            readonly vcard: (slug: string) => string;
+        }[T]>;
+        readonly page: (slugOrPage: string | Page) => string;
+        readonly search: () => string;
+        readonly find: (routeType: ("team-member" | "page" | "author" | "category" | "blog" | "post" | "tag") | string, slugOrPath: string | undefined) => string | undefined;
+        readonly fromCMSCollection: (collectionSlug: string, doc: {
+            slug: string;
+        } & Partial<Page>) => string | undefined;
+    };
+    cmsToHref: (link: Partial<CmsLink>, locale: Locale, homePage: HomePageRef) => string | undefined;
+    getHomePage: (locale: Locale) => Promise<WiredPage | null>;
+    getHomePageRef: (locale: Locale) => Promise<HomePageRef>;
+    getBlogListing: (locale: Locale) => Promise<BlogListing>;
+    /** Wires a single post document, e.g. a draft for live preview. */
+    wirePost: (post: Post | undefined, locale: Locale) => Promise<WiredPost | undefined>;
+    formProxy: {
+        cms: FormProxyCmsClient;
+        submissionLimiter: RateLimiter;
+        uploadLimiter: RateLimiter;
+        buildProxyDeps: (context: RequestContext, rateLimiter: RateLimiter) => Promise<ProxyDeps<FormProxyCmsClient>>;
+        handleFormSubmission: typeof handleFormSubmission;
+        handleFormUpload: typeof handleFormUpload;
+    };
+    /** The fetches `astro.config.mjs` makes before the build starts. */
+    config: {
+        fetchProjectSettings(): Promise<{
+            project: Project;
+            appearance: Appearance;
+            options: Options$1;
+        }>;
+        redirects(): Promise<Record<string, string>>;
+        fetchIconBuffer(icon: Media): Promise<false | Buffer<ArrayBuffer>>;
+    };
+};
+
+/** What every collection service is built from. Internal to the package. */
+interface Context {
+    api: Api;
+    locales: Locales;
+    options: ClientOptions<any>;
+    cms: (locale: Locale) => Cms;
+}
+
+type MenuCollectionData = {
+    pages: WiredPage[];
+    categories: WiredCategory[];
+    tags: WiredTag[];
+    teamMembers: WiredTeamMember[];
+};
+/** The words the menu adds of its own. Site copy, so the site supplies it. */
+type MenuLabels = {
+    /** Heads the team-members submenu: the site's `team.title`. */
+    team: string;
+};
+declare function resolveMenuItems(mainMenu: CmsMainMenu, data: MenuCollectionData, routes: Routes, labels: MenuLabels): CmsMainMenu;
+
+export { type Api, type AppearanceFallbacks, type BlogListing, type CategoryBreadcrumb, type Client, type ClientOptions, type Cms, CmsLink, CmsMainMenu, type CmsResult, type CmsWith, type Collection, type CountedCategory, DEFAULT_APPEARANCE_FALLBACKS, type Doc, type Extension, type ExtensionContext, type Extensions, type FallbackMode, type FetchCmsCollectionOptions, type FetchCmsGlobalOptions, type FormOwnershipCheck, type FormProxy, type FormProxyCmsClient, HomePageRef, Locale, LocaleOptions, Locales, MAX_SUBMISSION_BYTES, type MenuCollectionData, type MenuLabels, type ProxyDeps, type RateLimiter, type RequestContext, type ResolveUploadUrl, Routes, type SubmissionsCmsClient, type UploadUse, type UploadsCmsClient, type WiredAppearance, type WiredArea, type WiredAuthor, type WiredCategory, type WiredPage, type WiredPost, type WiredQuestion, type WiredTag, type WiredTeamMember, createClient, createCollectionLoader, createFormProxy, createFormProxyCmsClient, createGlobalLoader, createRateLimiter, handleFormSubmission, handleFormUpload, mapWithConcurrency, refusedFieldNames, resolveMenuItems };