astro-loader-pocketbase 2.10.1 → 3.0.0-astro-v6.2

package/README.md

@@ -15,6 +15,7 @@ This package is a simple loader to load data from a PocketBase database into Ast
 
 | Loader | Astro | PocketBase |
 | ------ | ----- | ---------- |
+| 3.0.0  | 6.0.0 | >= 0.23.0  |
 | 2.0.0  | 5.0.0 | >= 0.23.0  |
 | 1.0.0  | 5.0.0 | <= 0.22.0  |
 
@@ -42,7 +43,7 @@ If you want to update your deployed site with new entries, you need to rebuild i
 <sub>When running the dev server, you can trigger a reload by using `s + enter`.</sub>
 
 > [!TIP]
-> If you need live data on your production site, you can use the experimental live content loader described below.
+> If you need live data on your production site, you can use the live content loader described below.
 
 ## Incremental builds
 
@@ -201,23 +202,6 @@ When superuser credentials are provided, the loader will **always use the remote
 If you don't want to use the automatic type generation, you can also [provide your own schema manually](https://docs.astro.build/en/guides/content-collections/#defining-the-collection-schema).
 This manual schema will **always override the automatic type generation**.
 
-### Improved types
-
-By default PocketBase reports `number` and `boolean` fields as not required, even though the API will always return `0` and `false` respectively if no value is set.
-This means that the loader will add `undefined` to the type of these fields.
-If you want to enforce that these fields are always present, you can set the `improveTypes` option to `true`.
-
-```ts
-const blog = defineCollection({
-  loader: pocketbaseLoader({
-    ...options,
-    improveTypes: true
-  })
-});
-```
-
-This will remove `undefined` from the type of these fields and mark them as required.
-
 ## All options
 
 | Option                 | Type                                                                  | Required | Description                                                                                                                        |
@@ -230,16 +214,9 @@ This will remove `undefined` from the type of these fields and mark them as requ
 | `filter`               | `string`                                                              |          | Custom filter to use when fetching entries. Used to filter the entries by specific conditions.                                     |
 | `superuserCredentials` | `{ email: string, password: string } \| { impersonateToken: string }` |          | The email and password or impersonate token of a superuser of the PocketBase instance. This is used for automatic type generation. |
 | `localSchema`          | `string`                                                              |          | The path to a local schema file. This is used for automatic type generation.                                                       |
-| `jsonSchemas`          | `Record<string, z.ZodSchema>`                                         |          | A record of Zod schemas to use for type generation of `json` fields.                                                               |
-| `improveTypes`         | `boolean`                                                             |          | Whether to improve the types of `number` and `boolean` fields, removing `undefined` from them.                                     |
-
-## Experimental live content loader
-
-> [!WARNING]
-> Live content collections are still experimental and may change in the future.
-> This means that this packages live content loader is also experimental and may include breaking changes with every release.
+| `jsonSchemas`          | `Record<string, ZodType>`                                             |          | A record of Zod schemas to use for type generation of `json` fields.                                                               |
 
-For more information on how to enable and use live content collections, please refer to the [Astro documentation](https://docs.astro.build/en/reference/experimental-flags/live-content-collections/).
+## Live content loader
 
 ### General usage
 
@@ -249,7 +226,7 @@ The options for this packages loader are similar to the regular PocketBase loade
 
 ```ts
 const blogLive = defineLiveCollection({
-  loader: experimentalPocketbaseLiveLoader({
+  loader: pocketbaseLiveLoader({
     url: "https://<your-pocketbase-url>",
     collectionName: "<collection-in-pocketbase>"
   })
@@ -302,7 +279,7 @@ If you also want to use the `lastModified` hint, just tell the loader which fiel
 
 ```ts
 const blogLive = defineLiveCollection({
-  loader: experimentalPocketbaseLiveLoader({
+  loader: pocketbaseLiveLoader({
     ...options,
     updatedField: "<field-in-collection>"
   })
@@ -311,7 +288,7 @@ const blogLive = defineLiveCollection({
 
 ### Error handling
 
-The live content loader follows Astro's standard error handling conventions for live collections. For more information on how to handle errors in your components, see the [Astro documentation on error handling](https://docs.astro.build/en/reference/experimental-flags/live-content-collections/#error-handling).
+The live content loader follows Astro's standard error handling conventions for live collections. For more information on how to handle errors in your components, see the [Astro documentation on error handling](https://docs.astro.build/en/reference/content-loader-reference/#error-handling-in-live-loaders).
 
 | Error                           | When it's returned                                                                                            |
 | ------------------------------- | ------------------------------------------------------------------------------------------------------------- |
@@ -340,10 +317,7 @@ const blogTypes = defineCollection({
 });
 
 const blogLive = defineLiveCollection({
-  loader:
-    experimentalPocketbaseLiveLoader<CollectionEntry<"blogTypes">["data"]>(
-      options
-    )
+  loader: pocketbaseLiveLoader<CollectionEntry<"blogTypes">["data"]>(options)
 });
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-loader-pocketbase",
-  "version": "2.10.1",
+  "version": "3.0.0-astro-v6.2",
   "description": "A content loader for Astro that uses the PocketBase API",
   "keywords": [
     "astro",
@@ -27,10 +27,10 @@
     "src"
   ],
   "scripts": {
-    "format": "npx prettier . --write --cache --cache-location=./.prettier-cache --experimental-cli",
-    "format:check": "npx prettier . --check --cache --cache-location=./.prettier-cache --experimental-cli",
-    "lint": "oxlint --type-aware",
-    "lint:fix": "oxlint --type-aware --fix",
+    "format": "prettier . --write --cache --cache-location=./.prettier-cache --experimental-cli",
+    "format:check": "prettier . --check --cache --cache-location=./.prettier-cache --experimental-cli",
+    "lint": "oxlint --type-aware --type-check",
+    "lint:fix": "oxlint --type-aware --type-check --fix",
     "prepare": "husky",
     "test": "vitest run",
     "test:e2e": "vitest run $(find test -name '*.e2e-spec.ts')",
@@ -40,27 +40,29 @@
     "test:unit": "vitest run $(find test -name '*.spec.ts')",
     "test:unit:watch": "vitest watch $(find test -name '*.spec.ts')",
     "test:watch": "vitest watch",
-    "typecheck": "npx tsc --noEmit"
+    "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@commitlint/cli": "20.2.0",
-    "@commitlint/config-conventional": "20.2.0",
+    "@commitlint/cli": "20.3.1",
+    "@commitlint/config-conventional": "20.3.1",
     "@types/node": "24.10.1",
-    "@vitest/coverage-v8": "4.0.15",
-    "astro": "5.16.5",
-    "globals": "16.5.0",
+    "@vitest/coverage-v8": "4.0.17",
+    "astro": "6.0.0-beta.1",
+    "globals": "17.0.0",
     "husky": "9.1.7",
     "lint-staged": "16.2.7",
-    "oxlint": "1.32.0",
-    "oxlint-tsgolint": "0.8.6",
-    "prettier": "3.7.4",
+    "oxlint": "1.39.0",
+    "oxlint-tsgolint": "0.11.1",
+    "prettier": "3.8.0",
     "prettier-plugin-organize-imports": "4.3.0",
-    "prettier-plugin-packagejson": "2.5.20",
+    "prettier-plugin-packagejson": "2.5.21",
     "typescript": "5.9.3",
-    "vitest": "4.0.15"
+    "vitest": "4.0.17",
+    "zod-to-ts": "2.0.0"
   },
   "peerDependencies": {
-    "astro": "^5.10.0"
+    "astro": "^6.0.0",
+    "zod-to-ts": "^2.0.0"
   },
   "packageManager": "npm@11.7.0",
   "publishConfig": {

package/src/index.ts

@@ -1,27 +1,24 @@
-import {
-  experimentalPocketbaseLiveLoader,
-  pocketbaseLoader
-} from "./pocketbase-loader";
+import { pocketbaseLiveLoader, pocketbaseLoader } from "./pocketbase-loader";
 import { transformFileUrl } from "./schema/transform-files";
 import { PocketBaseAuthenticationError } from "./types/errors";
 import type {
-  ExperimentalPocketBaseLiveLoaderCollectionFilter,
-  ExperimentalPocketBaseLiveLoaderEntryFilter
+  PocketBaseLiveLoaderCollectionFilter,
+  PocketBaseLiveLoaderEntryFilter
 } from "./types/pocketbase-live-loader-filter.type";
 import type {
-  ExperimentalPocketBaseLiveLoaderOptions,
+  PocketBaseLiveLoaderOptions,
   PocketBaseLoaderOptions
 } from "./types/pocketbase-loader-options.type";
 
 export {
-  experimentalPocketbaseLiveLoader,
   PocketBaseAuthenticationError,
+  pocketbaseLiveLoader,
   pocketbaseLoader,
   transformFileUrl
 };
 export type {
-  ExperimentalPocketBaseLiveLoaderCollectionFilter,
-  ExperimentalPocketBaseLiveLoaderEntryFilter,
-  ExperimentalPocketBaseLiveLoaderOptions,
+  PocketBaseLiveLoaderCollectionFilter,
+  PocketBaseLiveLoaderEntryFilter,
+  PocketBaseLiveLoaderOptions,
   PocketBaseLoaderOptions
 };

package/src/loader/cleanup-entries.ts

@@ -5,7 +5,7 @@ import {
   pocketBaseListResponse
 } from "../types/pocketbase-api-response.type";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
-import { pocketBaseBaseEntry } from "../types/pocketbase-entry.type";
+import { pocketBaseEntry } from "../types/pocketbase-entry.type";
 import type { PocketBaseLoaderBaseOptions } from "../types/pocketbase-loader-options.type";
 
 /**
@@ -133,5 +133,5 @@ export async function cleanupEntries(
 const cleanUpEntriesResponse = pocketBaseListResponse
   .omit({ items: true })
   .extend({
-    items: z.array(pocketBaseBaseEntry.pick({ id: true }))
+    items: z.array(pocketBaseEntry.pick({ id: true }))
   });

package/src/loader/fetch-collection.ts

@@ -8,7 +8,7 @@ import {
   pocketBaseListResponse
 } from "../types/pocketbase-api-response.type";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
-import type { ExperimentalPocketBaseLiveLoaderCollectionFilter } from "../types/pocketbase-live-loader-filter.type";
+import type { PocketBaseLiveLoaderCollectionFilter } from "../types/pocketbase-live-loader-filter.type";
 import type { PocketBaseLoaderBaseOptions } from "../types/pocketbase-loader-options.type";
 import { combineFieldsForRequest } from "../utils/combine-fields-for-request";
 import { formatFields } from "../utils/format-fields";
@@ -22,7 +22,7 @@ export type CollectionFilter = {
    * If not provided, all entries will be fetched.
    */
   lastModified?: string;
-} & ExperimentalPocketBaseLiveLoaderCollectionFilter;
+} & PocketBaseLiveLoaderCollectionFilter;
 
 /**
  * Fetches entries from a PocketBase collection, optionally filtering by modification date and supporting pagination.

package/src/loader/fetch-entry.ts

@@ -6,7 +6,7 @@ import { PocketBaseAuthenticationError } from "../types/errors";
 import { pocketBaseErrorResponse } from "../types/pocketbase-api-response.type";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
 import { pocketBaseEntry } from "../types/pocketbase-entry.type";
-import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
+import type { PocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
 import { combineFieldsForRequest } from "../utils/combine-fields-for-request";
 import { formatFields } from "../utils/format-fields";
 
@@ -15,7 +15,7 @@ import { formatFields } from "../utils/format-fields";
  */
 export async function fetchEntry<TEntry extends PocketBaseEntry>(
   id: string,
-  options: ExperimentalPocketBaseLiveLoaderOptions,
+  options: PocketBaseLiveLoaderOptions,
   token: string | undefined
 ): Promise<TEntry> {
   // Build the URL for the entry endpoint

package/src/loader/live-collection-loader.ts

@@ -1,8 +1,8 @@
 import type { LiveDataCollection, LiveDataEntry } from "astro";
 import { LiveCollectionError } from "astro/content/runtime";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
-import type { ExperimentalPocketBaseLiveLoaderCollectionFilter } from "../types/pocketbase-live-loader-filter.type";
-import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
+import type { PocketBaseLiveLoaderCollectionFilter } from "../types/pocketbase-live-loader-filter.type";
+import type { PocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
 import { fetchCollection } from "./fetch-collection";
 import { parseLiveEntry } from "./parse-live-entry";
 
@@ -10,10 +10,8 @@ import { parseLiveEntry } from "./parse-live-entry";
  * Loads and parses a PocketBase collection for live data, returning entries or an error.
  */
 export async function liveCollectionLoader<TEntry extends PocketBaseEntry>(
-  collectionFilter:
-    | ExperimentalPocketBaseLiveLoaderCollectionFilter
-    | undefined,
-  options: ExperimentalPocketBaseLiveLoaderOptions,
+  collectionFilter: PocketBaseLiveLoaderCollectionFilter | undefined,
+  options: PocketBaseLiveLoaderOptions,
   token: string | undefined
 ): Promise<LiveDataCollection<TEntry> | { error: LiveCollectionError }> {
   const entries: Array<LiveDataEntry<TEntry>> = [];

package/src/loader/live-entry-loader.ts

@@ -1,7 +1,7 @@
 import type { LiveDataEntry } from "astro";
 import { LiveCollectionError } from "astro/content/runtime";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
-import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
+import type { PocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
 import { fetchEntry } from "./fetch-entry";
 import { parseLiveEntry } from "./parse-live-entry";
 
@@ -10,7 +10,7 @@ import { parseLiveEntry } from "./parse-live-entry";
  */
 export async function liveEntryLoader<TEntry extends PocketBaseEntry>(
   id: string,
-  options: ExperimentalPocketBaseLiveLoaderOptions,
+  options: PocketBaseLiveLoaderOptions,
   token: string | undefined
 ): Promise<LiveDataEntry<TEntry> | { error: LiveCollectionError }> {
   try {

package/src/loader/parse-live-entry.ts

@@ -2,14 +2,14 @@ import type { LiveDataEntry } from "astro";
 import { LiveCollectionValidationError } from "astro/content/runtime";
 import { z } from "astro/zod";
 import type { PocketBaseEntry } from "../types/pocketbase-entry.type";
-import type { ExperimentalPocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
+import type { PocketBaseLiveLoaderOptions } from "../types/pocketbase-loader-options.type";
 
 /**
  * Converts a PocketBase entry into a LiveDataEntry for Astro, extracting content and cache metadata.
  */
 export function parseLiveEntry<TEntry extends PocketBaseEntry>(
   entry: TEntry,
-  options: ExperimentalPocketBaseLiveLoaderOptions
+  options: PocketBaseLiveLoaderOptions
 ): LiveDataEntry<TEntry> {
   // Build a cache tag
   const tag = `${options.collectionName}-${entry.id}`;

package/src/pocketbase-loader.ts

@@ -1,18 +1,18 @@
 import type { LiveDataCollection, LiveDataEntry } from "astro";
 import type { LiveCollectionError } from "astro/content/runtime";
-import type { LiveLoader, Loader } from "astro/loaders";
-import type { ZodSchema } from "astro/zod";
+import type { LiveLoader, Loader, LoaderContext } from "astro/loaders";
 import { liveCollectionLoader } from "./loader/live-collection-loader";
 import { liveEntryLoader } from "./loader/live-entry-loader";
 import { loader } from "./loader/loader";
 import { generateSchema } from "./schema/generate-schema";
+import { generateType } from "./schema/generate-type";
 import type { PocketBaseEntry } from "./types/pocketbase-entry.type";
 import type {
-  ExperimentalPocketBaseLiveLoaderCollectionFilter,
-  ExperimentalPocketBaseLiveLoaderEntryFilter
+  PocketBaseLiveLoaderCollectionFilter,
+  PocketBaseLiveLoaderEntryFilter
 } from "./types/pocketbase-live-loader-filter.type";
 import type {
-  ExperimentalPocketBaseLiveLoaderOptions,
+  PocketBaseLiveLoaderOptions,
   PocketBaseLoaderOptions
 } from "./types/pocketbase-loader-options.type";
 import { createTokenPromise } from "./utils/create-token-promise";
@@ -22,13 +22,14 @@ import { createTokenPromise } from "./utils/create-token-promise";
  *
  * @param options Options for the loader. See {@link PocketBaseLoaderOptions} for more details.
  */
-export function pocketbaseLoader(options: PocketBaseLoaderOptions): Loader {
+// oxlint-disable-next-line explicit-module-boundary-types
+export function pocketbaseLoader(options: PocketBaseLoaderOptions) {
   // Create shared promise for the superuser token, which can be reused
   const tokenPromise = createTokenPromise(options);
 
   return {
     name: "pocketbase-loader",
-    load: async (context): Promise<void> => {
+    load: async (context: LoaderContext): Promise<void> => {
       if (options.experimental?.liveTypesOnly) {
         context.logger.label = `pocketbase-loader:${options.collectionName}`;
         context.logger.info(
@@ -42,31 +43,33 @@ export function pocketbaseLoader(options: PocketBaseLoaderOptions): Loader {
       // Load the entries from the collection
       await loader(context, options, token);
     },
-    schema: async (): Promise<ZodSchema> => {
+    // oxlint-disable-next-line explicit-module-boundary-types
+    createSchema: async () => {
       const token = await tokenPromise;
 
       // Generate the schema for the collection according to the API
-      return generateSchema(options, token);
+      const schema = await generateSchema(options, token);
+      const types = generateType(schema);
+
+      return {
+        schema,
+        types
+      };
     }
-  };
+  } satisfies Loader;
 }
 
 /**
  * Live loader for collections stored in PocketBase.
- * This loader is currently experimental and may change in any future release.
- *
- * @param options Options for the live loader. See {@link ExperimentalPocketBaseLiveLoaderOptions} for more details.
  *
- * @experimental Live content collections are still experimental
+ * @param options Options for the live loader. See {@link PocketBaseLiveLoaderOptions} for more details.
  */
-export function experimentalPocketbaseLiveLoader<
-  TEntry extends PocketBaseEntry
->(
-  options: ExperimentalPocketBaseLiveLoaderOptions
+export function pocketbaseLiveLoader<TEntry extends PocketBaseEntry>(
+  options: PocketBaseLiveLoaderOptions
 ): LiveLoader<
   TEntry,
-  ExperimentalPocketBaseLiveLoaderEntryFilter,
-  ExperimentalPocketBaseLiveLoaderCollectionFilter,
+  PocketBaseLiveLoaderEntryFilter,
+  PocketBaseLiveLoaderCollectionFilter,
   LiveCollectionError
 > {
   // Create shared promise for the superuser token, which can be reused

package/src/schema/generate-schema.ts

@@ -1,4 +1,3 @@
-import type { ZodSchema } from "astro/zod";
 import { z } from "astro/zod";
 import type { PocketBaseLoaderOptions } from "../types/pocketbase-loader-options.type";
 import type { PocketBaseCollection } from "../types/pocketbase-schema.type";
@@ -13,11 +12,11 @@ import { transformFiles } from "./transform-files";
 /**
  * Basic schema for every PocketBase collection.
  */
-const BASIC_SCHEMA = {
+const BASIC_SCHEMA = z.object({
   id: z.string(),
   collectionId: z.string(),
   collectionName: z.string()
-};
+});
 
 /**
  * Types of fields that can be used as an ID.
@@ -33,10 +32,11 @@ const VALID_ID_TYPES = ["text", "number", "email", "url", "date"];
  * @param options Options for the loader. See {@link PocketBaseLoaderOptions} for more details.
  * @param token The superuser token to authenticate the request.
  */
+// oxlint-disable-next-line explicit-module-boundary-types
 export async function generateSchema(
   options: PocketBaseLoaderOptions,
   token: string | undefined
-): Promise<ZodSchema> {
+) {
   let collection: PocketBaseCollection | undefined;
 
   if (token) {
@@ -60,7 +60,7 @@ export async function generateSchema(
       `No schema available for "${options.collectionName}". Only basic types are available. Please check your configuration and provide a valid schema file or superuser credentials.`
     );
     // Return the basic schema since every collection has at least these fields
-    return z.object(BASIC_SCHEMA);
+    return BASIC_SCHEMA;
   }
 
   // Get fields to include from options
@@ -71,7 +71,6 @@ export async function generateSchema(
   // Parse the schema with optional field filtering
   const fields = parseSchema(collection, options.jsonSchemas, {
     hasSuperuserRights,
-    improveTypes: options.improveTypes,
     fieldsToInclude,
     experimentalLiveTypesOnly: options.experimental?.liveTypesOnly
   });
@@ -83,7 +82,7 @@ export async function generateSchema(
 
   // Combine the basic schema with the parsed fields
   const schema = z.object({
-    ...BASIC_SCHEMA,
+    ...BASIC_SCHEMA.shape,
     ...fields
   });
 

package/src/schema/generate-type.ts

@@ -0,0 +1,19 @@
+import type { ZodType } from "astro/zod";
+import {
+  createAuxiliaryTypeStore,
+  createTypeAlias,
+  printNode,
+  zodToTs
+} from "zod-to-ts";
+
+/**
+ * Generate a TypeScript type from a Zod schema.
+ */
+export function generateType(schema: ZodType): string {
+  const { node } = zodToTs(schema, {
+    auxiliaryTypeStore: createAuxiliaryTypeStore()
+  });
+  const typeAlias = createTypeAlias(node, "Entry");
+
+  return `export ${printNode(typeAlias)}`;
+}

package/src/schema/parse-schema.ts

@@ -6,7 +6,6 @@ import type {
 
 export interface ParseSchemaOptions {
   hasSuperuserRights: boolean;
-  improveTypes?: boolean;
   fieldsToInclude?: Array<string>;
   experimentalLiveTypesOnly?: boolean;
 }
@@ -43,7 +42,7 @@ export function parseSchema(
       continue;
     }
 
-    let fieldType;
+    let fieldType: z.ZodType;
 
     // Determine the field type and create the corresponding Zod type
     // oxlint-disable-next-line switch-exhaustiveness-check
@@ -113,9 +112,9 @@ export function parseSchema(
       field.required ||
       // `onCreate autodate` fields are always set
       (field.type === "autodate" && field.onCreate) ||
-      // Improve number and boolean types by providing default values
-      (options.improveTypes &&
-        (field.type === "number" || field.type === "bool"));
+      // number and bool fields are always set
+      field.type === "number" ||
+      field.type === "bool";
 
     // If the field is not required, mark it as optional
     if (!isRequired) {

package/src/types/pocketbase-entry.type.ts

@@ -1,9 +1,9 @@
 import { z } from "astro/zod";
 
 /**
- * Base schema for all PocketBase entries.
+ * Schema for a PocketBase entry.
  */
-export const pocketBaseBaseEntry = z.object({
+export const pocketBaseEntry = z.looseObject({
   /**
    * ID of the entry.
    */
@@ -18,16 +18,6 @@ export const pocketBaseBaseEntry = z.object({
   collectionName: z.string()
 });
 
-/**
- * Base interface for all PocketBase entries.
- */
-export type PocketBaseBaseEntry = z.infer<typeof pocketBaseBaseEntry>;
-
-/**
- * Schema for a PocketBase entry.
- */
-export const pocketBaseEntry = pocketBaseBaseEntry.passthrough();
-
 /**
  * Type for a PocketBase entry.
  */

package/src/types/pocketbase-live-loader-filter.type.ts

@@ -1,9 +1,7 @@
 /**
  * Filter for a single entry
- *
- * @experimental Live content collections are still experimental
  */
-export interface ExperimentalPocketBaseLiveLoaderEntryFilter {
+export interface PocketBaseLiveLoaderEntryFilter {
   /**
    * Id of the entry.
    */
@@ -12,13 +10,11 @@ export interface ExperimentalPocketBaseLiveLoaderEntryFilter {
 
 /**
  * Filter for a collection of entries.
- *
- * @experimental Live content collections are still experimental
  */
-export interface ExperimentalPocketBaseLiveLoaderCollectionFilter {
+export interface PocketBaseLiveLoaderCollectionFilter {
   /**
    * Additional filter to apply to the collection.
-   * This will be added to the filter supplied in the {@link ExperimentalPocketBaseLiveLoaderOptions}.
+   * This will be added to the filter supplied in the {@link PocketBaseLiveLoaderOptions}.
    *
    * Example:
    * ```ts

package/src/types/pocketbase-loader-options.type.ts

@@ -1,4 +1,4 @@
-import type { z } from "astro/zod";
+import type { ZodType } from "astro/zod";
 
 /**
  * Options for both build time and live collection loader
@@ -125,15 +125,7 @@ export type PocketBaseLoaderOptions = PocketBaseLoaderBaseOptions & {
    *
    * Note that this will only be used for fields of type `json`.
    */
-  jsonSchemas?: Record<string, z.ZodSchema>;
-  /**
-   * Whether to improve the types of the generated schema.
-   * With this option enabled, the schema will not include `undefined` as possible value for number and boolean fields and mark them as required.
-   *
-   * Why do we need this option?
-   * The PocketBase API does always return at least `0` or `false` as the default values, even though the fields are not marked as required in the schema.
-   */
-  improveTypes?: boolean;
+  jsonSchemas?: Record<string, ZodType>;
   /**
    * Experimental options for the loader.
    *
@@ -143,8 +135,6 @@ export type PocketBaseLoaderOptions = PocketBaseLoaderBaseOptions & {
     /**
      * Whether to only create types for the live loader.
      * This will not load any data, but only generate types that can be used with the live loader.
-     *
-     * @experimental Live content collections are still experimental
      */
     liveTypesOnly?: boolean;
   };
@@ -152,8 +142,5 @@ export type PocketBaseLoaderOptions = PocketBaseLoaderBaseOptions & {
 
 /**
  * Options for the PocketBase live loader.
- *
- * @experimental Live content collections are still experimental
  */
-export type ExperimentalPocketBaseLiveLoaderOptions =
-  PocketBaseLoaderBaseOptions;
+export type PocketBaseLiveLoaderOptions = PocketBaseLoaderBaseOptions;