@lupinum/ginko-content 0.1.0

package/dist/types/fields.d.ts

@@ -0,0 +1,81 @@
+import { z, type ZodTypeAny } from 'zod';
+export declare const CONTENT_FIELD_METADATA_KEY: unique symbol;
+export type ContentFieldMetadata = {
+    type: 'text' | 'textarea' | 'richtext' | 'slug' | 'email' | 'url' | 'number' | 'boolean' | 'date' | 'datetime' | 'select' | 'json' | 'object' | 'array' | 'relation' | 'relations' | 'image' | 'asset' | 'file' | 'icon';
+    label?: string | Record<string, string> | null;
+    description?: string | null;
+    required?: boolean;
+    localized?: boolean;
+    options?: string[] | null;
+    relation?: {
+        collectionId: string;
+        multiple?: boolean;
+    } | null;
+    slugFrom?: string | null;
+    image?: {
+        aspectRatio?: string;
+        accept?: string[];
+    } | null;
+    asset?: {
+        kind?: 'asset' | 'file';
+        accept?: string[];
+    } | null;
+};
+export type ContentFieldSchema<T extends ZodTypeAny = ZodTypeAny, TRequired extends ZodTypeAny = T> = T & {
+    [CONTENT_FIELD_METADATA_KEY]?: ContentFieldMetadata;
+    required(): ContentFieldSchema<TRequired, TRequired>;
+    label(value: string | Record<string, string> | null): ContentFieldSchema<T, TRequired>;
+    help(value: string | null): ContentFieldSchema<T, TRequired>;
+    localized(value?: boolean): ContentFieldSchema<T, TRequired>;
+    shared(): ContentFieldSchema<T, TRequired>;
+};
+export declare function getContentFieldMetadata(schema: unknown): ContentFieldMetadata | null;
+export declare function isContentFieldSchema(schema: unknown): schema is ContentFieldSchema;
+export declare const fields: {
+    object<const Shape extends z.ZodRawShape>(shape: Shape): ContentFieldSchema<z.ZodObject<{ -readonly [P in keyof Shape]: Shape[P]; }, z.core.$strip>, z.ZodObject<{ -readonly [P in keyof Shape]: Shape[P]; }, z.core.$strip>>;
+    array<Item extends ZodTypeAny>(item: Item): ContentFieldSchema<z.ZodOptional<z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>, z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    text: () => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    textarea: () => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    richtext: () => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    markdown: () => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    slug: (options?: {
+        from?: string;
+    }) => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    email: () => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    url: () => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    number: () => ContentFieldSchema<z.ZodOptional<z.ZodNumber>, z.ZodNumber>;
+    boolean: () => ContentFieldSchema<z.ZodOptional<z.ZodBoolean>, z.ZodBoolean>;
+    toggle: () => ContentFieldSchema<z.ZodOptional<z.ZodBoolean>, z.ZodBoolean>;
+    date: () => ContentFieldSchema<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodCoercedDate<unknown>>;
+    datetime: () => ContentFieldSchema<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodCoercedDate<unknown>>;
+    select<const Values extends readonly [string, ...string[]]>(values: Values): ContentFieldSchema<z.ZodOptional<z.ZodEnum<{ [k_1 in Values[number]]: k_1; } extends infer T ? { [k in keyof T]: T[k]; } : never>>, z.ZodEnum<{ [k_1 in Values[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>>;
+    enum<const Values extends readonly [string, ...string[]]>(values: Values): ContentFieldSchema<z.ZodOptional<z.ZodEnum<{ [k_1 in Values[number]]: k_1; } extends infer T ? { [k in keyof T]: T[k]; } : never>>, z.ZodEnum<{ [k_1 in Values[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>>;
+    json: () => ContentFieldSchema<z.ZodOptional<z.ZodUnknown>, z.ZodUnknown>;
+    icon: () => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    image(options?: {
+        aspectRatio?: string;
+        accept?: string[];
+    }): ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    asset(options?: {
+        accept?: string[];
+    }): ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    file(options?: {
+        accept?: string[];
+    }): ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    relation(collection: string): ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+    relations(collection: string): ContentFieldSchema<z.ZodOptional<z.ZodArray<z.ZodString>>, z.ZodArray<z.ZodString>>;
+};
+export declare const image: (options?: {
+    aspectRatio?: string;
+    accept?: string[];
+}) => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+export declare const asset: (options?: {
+    accept?: string[];
+}) => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+export declare const file: (options?: {
+    accept?: string[];
+}) => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+export declare const relation: (collection: string) => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+export declare const relations: (collection: string) => ContentFieldSchema<z.ZodOptional<z.ZodArray<z.ZodString>>, z.ZodArray<z.ZodString>>;
+export declare const richtext: () => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;
+export declare const text: () => ContentFieldSchema<z.ZodOptional<z.ZodString>, z.ZodString>;

package/dist/types/fields.js

@@ -0,0 +1,146 @@
+import { z } from "zod";
+import { CONTENT_REFERENCE_PREFIX } from "./reference.js";
+export const CONTENT_FIELD_METADATA_KEY = Symbol.for("lupinum.ginko-content.field-metadata");
+function readFieldMetadata(schema) {
+  const value = schema?.[CONTENT_FIELD_METADATA_KEY];
+  return value ? { ...value } : null;
+}
+function writeFieldMetadata(schema, metadata) {
+  Object.defineProperty(schema, CONTENT_FIELD_METADATA_KEY, {
+    configurable: true,
+    enumerable: false,
+    value: metadata,
+    writable: true
+  });
+  return schema;
+}
+function cloneMetadata(metadata, patch) {
+  return { ...metadata, ...patch };
+}
+function decorate(schema, metadata, requiredSchema = schema) {
+  const decorated = writeFieldMetadata(schema, metadata);
+  decorated.required = () => decorate(requiredSchema, cloneMetadata(metadata, { required: true }));
+  decorated.label = (value) => decorate(schema, cloneMetadata(metadata, { label: value }), requiredSchema);
+  decorated.help = (value) => decorate(schema, cloneMetadata(metadata, { description: value }), requiredSchema);
+  decorated.localized = (value = true) => decorate(schema, cloneMetadata(metadata, { localized: value }), requiredSchema);
+  decorated.shared = () => decorate(schema, cloneMetadata(metadata, { localized: false }), requiredSchema);
+  return decorated;
+}
+function optionalField(requiredSchema, metadata) {
+  const optionalSchema = requiredSchema.optional();
+  writeFieldMetadata(requiredSchema, cloneMetadata(metadata, { required: true }));
+  return decorate(optionalSchema, cloneMetadata(metadata, { required: false }), requiredSchema);
+}
+function textLike(type) {
+  return optionalField(z.string(), { type });
+}
+function getZodType(schema) {
+  const definition = schema?._def;
+  return typeof definition?.type === "string" ? definition.type : typeof definition?.typeName === "string" ? definition.typeName.replace(/^Zod/, "").toLowerCase() : void 0;
+}
+function requiredArrayItem(item) {
+  if (!readFieldMetadata(item)) return item;
+  let current = item;
+  while (current) {
+    const type = getZodType(current);
+    if (type !== "optional" && type !== "nullable" && type !== "default" && type !== "catch") {
+      return current;
+    }
+    const innerType = current._def.innerType;
+    if (!innerType) return current;
+    current = innerType;
+  }
+  return item;
+}
+export function getContentFieldMetadata(schema) {
+  return readFieldMetadata(schema);
+}
+export function isContentFieldSchema(schema) {
+  return getContentFieldMetadata(schema) !== null;
+}
+export const fields = {
+  object(shape) {
+    return decorate(z.object(shape), { type: "object", required: true });
+  },
+  array(item) {
+    const metadata = readFieldMetadata(item);
+    const itemSchema = requiredArrayItem(item);
+    const type = metadata?.type === "relation" ? "relations" : "array";
+    const relation2 = metadata?.type === "relation" && metadata.relation ? { ...metadata.relation, multiple: true } : metadata?.type === "relations" ? metadata.relation : null;
+    return optionalField(z.array(itemSchema), {
+      type,
+      ...relation2 ? { relation: relation2 } : {}
+    });
+  },
+  text: () => textLike("text"),
+  textarea: () => textLike("textarea"),
+  richtext: () => textLike("richtext"),
+  markdown: () => textLike("richtext"),
+  slug: (options = {}) => optionalField(z.string(), { type: "slug", slugFrom: options.from ?? null }),
+  email: () => optionalField(z.string().email(), { type: "email" }),
+  url: () => optionalField(z.string().url(), { type: "url" }),
+  number: () => optionalField(z.number(), { type: "number", localized: false }),
+  boolean: () => optionalField(z.boolean(), { type: "boolean", localized: false }),
+  toggle: () => optionalField(z.boolean(), { type: "boolean", localized: false }),
+  date: () => optionalField(z.coerce.date(), { type: "date", localized: false }),
+  datetime: () => optionalField(z.coerce.date(), { type: "datetime", localized: false }),
+  select(values) {
+    return optionalField(z.enum(values), { type: "select", options: [...values] });
+  },
+  enum(values) {
+    return fields.select(values);
+  },
+  json: () => optionalField(z.unknown(), { type: "json" }),
+  icon: () => optionalField(z.string(), { type: "icon" }),
+  image(options = {}) {
+    return optionalField(z.string(), {
+      type: "image",
+      localized: false,
+      image: {
+        ...options.aspectRatio ? { aspectRatio: options.aspectRatio } : {},
+        ...options.accept ? { accept: options.accept } : {}
+      }
+    });
+  },
+  asset(options = {}) {
+    return optionalField(z.string(), {
+      type: "asset",
+      localized: false,
+      asset: {
+        kind: "asset",
+        ...options.accept ? { accept: options.accept } : {}
+      }
+    });
+  },
+  file(options = {}) {
+    return optionalField(z.string(), {
+      type: "file",
+      localized: false,
+      asset: {
+        kind: "file",
+        ...options.accept ? { accept: options.accept } : {}
+      }
+    });
+  },
+  relation(collection) {
+    return optionalField(z.string().describe(`${CONTENT_REFERENCE_PREFIX}${collection}`), {
+      type: "relation",
+      localized: false,
+      relation: { collectionId: collection, multiple: false }
+    });
+  },
+  relations(collection) {
+    return optionalField(z.array(z.string().describe(`${CONTENT_REFERENCE_PREFIX}${collection}`)), {
+      type: "relations",
+      localized: false,
+      relation: { collectionId: collection, multiple: true }
+    });
+  }
+};
+export const image = fields.image;
+export const asset = fields.asset;
+export const file = fields.file;
+export const relation = fields.relation;
+export const relations = fields.relations;
+export const richtext = fields.richtext;
+export const text = fields.text;

package/dist/types/index

@@ -0,0 +1 @@
+export * from './index.js'

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './config';
+export * from './content';
+export * from './query';
+export * from './module';
+export * from './runtime';
+export * from './search';

package/dist/types/index.js

@@ -0,0 +1,6 @@
+export * from "./config.js";
+export * from "./content.js";
+export * from "./query.js";
+export * from "./module.js";
+export * from "./runtime.js";
+export * from "./search.js";

package/dist/types/module

@@ -0,0 +1 @@
+export * from './module.js'

package/dist/types/module.d.ts

@@ -0,0 +1,428 @@
+import type { ListenOptions } from 'listhen';
+import type { MarkdownPluginDescriptor } from './content';
+import type { ContentCollectionConfig, ContentProviderName } from './config';
+import type { ContentQueryBuilderWhere } from './query';
+import type { ContentMiniSearchOptions, ContentSearchEngine } from './search';
+export type MountOptions = {
+    driver: 'fs' | 'http' | string;
+    name?: string;
+    prefix?: string;
+    [options: string]: unknown;
+};
+export interface ContentI18nOptions {
+    /**
+     * Enable locale-aware content behavior.
+     *
+     * `true` means "detect from Nuxt I18n and/or content.config".
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * List of locale codes used by content.
+     *
+     * @default []
+     */
+    locales?: string[];
+    /**
+     * Default locale for top level contents.
+     *
+     * @default undefined
+     */
+    defaultLocale?: string;
+    /**
+     * Ordered locale fallback chains keyed by locale code.
+     *
+     * @default {}
+     */
+    fallback?: Record<string, string[]>;
+    /**
+     * Use numeric prefixes as the canonical cross-locale identity source.
+     *
+     * Example:
+     * `en/1.guide/1.getting-started.md` and `de/1.leitfaden/1.erste-schritte.md`
+     * share the same canonical key `1/1`.
+     *
+     * This is intentionally opt-in.
+     *
+     * @default false
+     */
+    translatedSlugs?: boolean;
+    /**
+     * Treat translated-slug warnings as build/runtime validation errors.
+     *
+     * @default false
+     */
+    strictTranslatedSlugs?: boolean;
+}
+export interface ContentSitemapOptions {
+    /**
+     * Route suffix appended to `content.api.baseURL`.
+     *
+     * @default '/sitemap'
+     */
+    path?: string;
+    /**
+     * Collections to include in the generated content sitemap source.
+     *
+     * When omitted, all configured collections are considered.
+     *
+     * @default undefined
+     */
+    include?: string[];
+    /**
+     * Collections to exclude from the generated content sitemap source.
+     *
+     * @default []
+     */
+    exclude?: string[];
+    /**
+     * Include draft content in sitemap entries.
+     *
+     * Production default is `false`.
+     * Development remains permissive for easier debugging.
+     *
+     * @default undefined
+     */
+    includeDrafts?: boolean;
+    /**
+     * Optional build-time validation for generated sitemap output.
+     *
+     * This is intended as a release-safety check for content-heavy sites where
+     * shipping an empty docs/blog sitemap is a production failure.
+     *
+     * @default disabled
+     */
+    assert?: ContentSitemapAssertOptions;
+}
+export interface ContentSitemapAssertSitemapOptions {
+    /**
+     * Allow this sitemap to contain zero URLs.
+     *
+     * When `true`, URL count assertions are skipped for this sitemap.
+     *
+     * @default inherits global `allowEmpty`
+     */
+    allowEmpty?: boolean;
+    /**
+     * Minimum number of URLs required for this sitemap.
+     *
+     * @default inherits global `minUrlsPerSitemap`
+     */
+    minUrls?: number;
+    /**
+     * Require at least one image entry in this sitemap.
+     *
+     * @default inherits global `requireImages`
+     */
+    requireImages?: boolean;
+}
+export interface ContentSitemapAssertOptions {
+    /**
+     * Enable sitemap artifact assertions.
+     *
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Which build path should enforce assertions.
+     *
+     * `generate` maps to static generation, `build` maps to non-static builds,
+     * and `both` enables both paths.
+     *
+     * @default 'generate'
+     */
+    mode?: 'generate' | 'build' | 'both';
+    /**
+     * Allow discovered sitemap files to contain zero URLs.
+     *
+     * @default false
+     */
+    allowEmpty?: boolean;
+    /**
+     * Minimum number of URLs required in each discovered sitemap.
+     *
+     * @default 1
+     */
+    minUrlsPerSitemap?: number;
+    /**
+     * Require at least one image entry in each discovered sitemap.
+     *
+     * @default false
+     */
+    requireImages?: boolean;
+    /**
+     * Collections that must contribute at least one route to the content sitemap.
+     *
+     * This is preferred over hardcoded URL checks because it asserts the real
+     * content invariant rather than a single route sample.
+     *
+     * @default []
+     */
+    requiredCollections?: string[];
+    /**
+     * Optional per-sitemap overrides keyed by sitemap name, for example `en-US`.
+     *
+     * @default {}
+     */
+    sitemaps?: Record<string, ContentSitemapAssertSitemapOptions>;
+}
+export interface ContentSearchOptions {
+    /**
+     * Base route used for the built-in search api.
+     *
+     * Defaults to `${content.api.baseURL}/search`.
+     */
+    apiBaseURL?: string;
+    /**
+     * Search engine used by `useContentSearchResults`.
+     *
+     * @default 'minisearch'
+     */
+    engine?: ContentSearchEngine;
+    /**
+     * HTML tags ignored when flattening rich content into search text.
+     *
+     * @default ['script', 'style', 'pre']
+     */
+    ignoredTags?: string[];
+    /**
+     * Query predicate applied before records are indexed.
+     *
+     * @default { _draft: false, _partial: false }
+     */
+    filterQuery?: ContentQueryBuilderWhere;
+    /**
+     * Collections included in the built-in index.
+     *
+     * When omitted, all configured collections are indexed.
+     */
+    collections?: string[];
+    /**
+     * Extra top-level document fields copied into each generated search record.
+     *
+     * Use this when `minisearch.fields`, `minisearch.storeFields`, or
+     * `minisearch.boost` refer to frontmatter fields such as `tags`.
+     *
+     * @default []
+     */
+    extraFields?: string[];
+    /**
+     * MiniSearch index and ranking options.
+     */
+    minisearch?: Partial<ContentMiniSearchOptions>;
+}
+export interface ContentPreviewOptions {
+    /**
+     * Server-side token required before preview storage can be read.
+     */
+    token?: string;
+}
+export interface ContentRevalidateOptions {
+    /**
+     * Server-side token required before the built-in revalidation endpoint accepts
+     * tag/path invalidation requests.
+     */
+    token: string;
+    /**
+     * Allow token-only revalidation requests without HMAC headers.
+     *
+     * This is intended for local/dev compatibility only. Production CMS delivery
+     * should leave this disabled so requests are timestamped and signed.
+     *
+     * @default false
+     */
+    allowUnsigned?: boolean;
+}
+export interface ModuleOptions {
+    api: {
+        /**
+         * Base route that will be used for content api
+         *
+         * @default '/api/_content'
+         */
+        baseURL: string;
+    };
+    /**
+     * Locale-aware content behavior.
+     */
+    i18n: boolean | ContentI18nOptions;
+    /**
+     * Content-owned sitemap source configuration for Nuxt SEO.
+     *
+     * When enabled, Ginko exposes a JSON endpoint that can be consumed by
+     * `@nuxtjs/sitemap` through `sitemap.sources`.
+     */
+    sitemap: boolean | ContentSitemapOptions;
+    /**
+     * Built-in full-text search configuration.
+     *
+     * When enabled, Ginko exposes JSON/Pagefind search endpoints under
+     * the content api base route. Import `useContentSearchResults()` from
+     * `@lupinum/ginko-content/client` to consume them from app components.
+     */
+    search: false | ContentSearchOptions;
+    /**
+     * Preview storage access configuration.
+     *
+     * Preview mode is disabled unless a token is configured and the incoming
+     * preview token matches it.
+     */
+    preview?: false | ContentPreviewOptions;
+    /**
+     * Built-in cache revalidation endpoint configuration.
+     *
+     * When a token is configured, callers must send it as
+     * `x-ginko-revalidate-token` or `authorization: Bearer <token>`.
+     */
+    revalidate?: false | ContentRevalidateOptions;
+    /**
+     * Optional server-side cache adapter module.
+     *
+     * The module must default-export a `ContentCacheAdapter`, or export one as
+     * `contentCacheAdapter` or `cacheAdapter`.
+     */
+    cache?: false | string;
+    /**
+     * Disable content watcher and hot content reload.
+     * Note: Watcher is a development feature and will not includes in the production.
+     *
+     * @default true
+     */
+    watch: false | {
+        ws: Partial<ListenOptions>;
+    };
+    /**
+     * Contents can be located in multiple places, in multiple directories or even in remote git repositories.
+     * Using sources option you can tell Content module where to look for contents.
+     *
+     * @default ['content']
+     */
+    sources: Record<string, MountOptions>;
+    /**
+     * List of ignore patterns that will be used to exclude content from parsing, rendering and watching.
+     *
+     * Note that files with a leading . or - are ignored by default
+     *
+     * @default []
+     */
+    ignores: Array<string>;
+    /**
+     * Content module uses Comark under the hood to parse markdown files.
+     */
+    markdown: {
+        /**
+         * Tags will be used to replace markdown components and render custom components instead of default ones.
+         *
+         * @default {}
+         */
+        tags?: Record<string, string>;
+        /**
+         * Ordered list of Comark plugin descriptors.
+         *
+         * @default []
+         */
+        plugins?: MarkdownPluginDescriptor[];
+        /**
+         * Anchor link generation config
+         *
+         * @default {}
+         */
+        anchorLinks?: boolean | {
+            /**
+              * Sets the maximal depth for anchor link generation
+              *
+              * @default 4
+              */
+            depth?: number;
+            /**
+             * Excludes headings from link generation when they are in the depth range.
+             *
+             * @default [1]
+             */
+            exclude?: number[];
+        };
+        /**
+         * Markdown image renderer.
+         *
+         * `auto` uses Nuxt Image when `<NuxtImg>` is available and otherwise
+         * falls back to a native `<img>`.
+         *
+         * @default 'auto'
+         */
+        image?: 'auto' | 'img' | 'nuxt-image';
+    };
+    /**
+     * Options for yaml parser.
+     *
+     * @default {}
+     */
+    yaml: false | Record<string, unknown>;
+    /**
+     * Options for yaml parser.
+     *
+     * @default {}
+     */
+    csv: false | {
+        json?: boolean;
+        delimiter?: string;
+    };
+    /**
+     * Enable/Disable navigation.
+     *
+     * @default {}
+     */
+    navigation: false | {
+        fields: Array<string>;
+    };
+    /**
+     * Typed collection definitions loaded from `content.config.*`.
+     *
+     * Globs are relative to the content source root.
+     *
+     * @default {}
+     */
+    collections?: Record<string, ContentCollectionConfig>;
+    /**
+     * Backing implementation for public content reads.
+     *
+     * `filesystem` is the default. `cms`, `ginko-cms`, and `ginko` resolve to the
+     * official Ginko CMS provider when `@lupinum/ginko-cms` is installed.
+     */
+    provider?: ContentProviderName;
+    /**
+     * External provider modules keyed by provider name.
+     */
+    providers?: Record<string, string>;
+    /**
+     * Enable automatic usage of `useContentHead`
+     *
+     * @default true
+     */
+    contentHead?: boolean;
+    /**
+     * Enable to keep uppercase characters in the generated routes.
+     *
+     * @default false
+     */
+    respectPathCase: boolean;
+    experimental: {
+        stripQueryParameters?: boolean;
+    };
+}
+export interface ResolvedContentI18nOptions {
+    locales: string[];
+    defaultLocale?: string;
+    fallback: Record<string, string[]>;
+    translatedSlugs: boolean;
+    strictTranslatedSlugs: boolean;
+}
+export interface ContentContext extends ModuleOptions {
+    transformers: Array<string>;
+    sitemap: false | ContentSitemapOptions;
+    locales: string[];
+    defaultLocale?: string;
+    localeFallback: Record<string, string[]>;
+    translatedSlugs: boolean;
+    strictTranslatedSlugs: boolean;
+}

package/dist/types/picomatch.d.ts

@@ -0,0 +1,8 @@
+declare module 'picomatch' {
+  export interface PicomatchOptions {
+    dot?: boolean
+  }
+
+  const picomatch: (glob: string, options?: PicomatchOptions) => (input: string) => boolean
+  export default picomatch
+}

package/dist/types/query

@@ -0,0 +1 @@
+export * from './query.js'