pocketbase-zod-schema 0.2.2 → 0.2.4

package/dist/index.js

@@ -15,784 +15,708 @@ var StatusEnum = z.enum([
   "fail"
   // Failed project at any stage
 ]);
-var baseSchema = {
-  id: z.string().describe("unique id"),
-  collectionId: z.string().describe("collection id"),
-  collectionName: z.string().describe("collection name"),
-  expand: z.record(z.any()).describe("expandable fields"),
-  created: z.string().describe("creation timestamp"),
-  updated: z.string().describe("last update timestamp")
-};
-var baseSchemaWithTimestamps = {
-  ...baseSchema,
-  created: z.string().describe("creation timestamp"),
-  updated: z.string().describe("last update timestamp")
-};
-var baseImageFileSchema = {
-  ...baseSchema,
-  thumbnailURL: z.string().optional(),
-  imageFiles: z.array(z.string())
-};
-var inputImageFileSchema = {
-  imageFiles: z.array(z.instanceof(File))
-};
-var omitImageFilesSchema = {
-  imageFiles: true
-};
-function textField(options) {
-  let schema = z.string();
-  if (options?.min !== void 0) schema = schema.min(options.min);
-  if (options?.max !== void 0) schema = schema.max(options.max);
-  if (options?.pattern !== void 0) schema = schema.regex(options.pattern);
-  return schema;
-}
-function emailField() {
-  return z.string().email();
-}
-function urlField() {
-  return z.string().url();
-}
-function numberField(options) {
-  let schema = z.number();
-  if (options?.min !== void 0) schema = schema.min(options.min);
-  if (options?.max !== void 0) schema = schema.max(options.max);
-  return schema;
-}
-function boolField() {
-  return z.boolean();
-}
-function dateField() {
-  return z.date();
-}
-function selectField(values) {
-  return z.enum(values);
-}
-function jsonField(schema) {
-  return schema ?? z.record(z.any());
-}
-function fileField() {
-  return z.instanceof(File);
-}
-function filesField(options) {
-  let schema = z.array(z.instanceof(File));
-  if (options?.min !== void 0) schema = schema.min(options.min);
-  if (options?.max !== void 0) schema = schema.max(options.max);
-  return schema;
-}
-var RELATION_METADATA_KEY = "__pocketbase_relation__";
-function RelationField(config) {
-  const metadata = {
-    [RELATION_METADATA_KEY]: {
-      type: "single",
-      collection: config.collection,
-      cascadeDelete: config.cascadeDelete ?? false,
-      maxSelect: 1,
-      minSelect: 0
-    }
+var BaseMutator = class {
+  pb;
+  // Define a default property that subclasses will override
+  options = {
+    expand: [],
+    filter: [],
+    sort: []
   };
-  return z.string().describe(JSON.stringify(metadata));
-}
-function RelationsField(config) {
-  const metadata = {
-    [RELATION_METADATA_KEY]: {
-      type: "multiple",
-      collection: config.collection,
-      cascadeDelete: config.cascadeDelete ?? false,
-      maxSelect: config.maxSelect ?? 999,
-      minSelect: config.minSelect ?? 0
+  constructor(pb, options) {
+    this.pb = pb;
+    this.initializeOptions();
+    if (options) {
+      this.overrideOptions(options);
     }
-  };
-  let schema = z.array(z.string());
-  if (config.minSelect !== void 0) {
-    schema = schema.min(config.minSelect);
   }
-  if (config.maxSelect !== void 0) {
-    schema = schema.max(config.maxSelect);
+  initializeOptions() {
+    this.options = this.setDefaults();
   }
-  return schema.describe(JSON.stringify(metadata));
-}
-function extractRelationMetadata(description) {
-  if (!description) return null;
-  try {
-    const parsed = JSON.parse(description);
-    if (parsed[RELATION_METADATA_KEY]) {
-      return parsed[RELATION_METADATA_KEY];
-    }
-  } catch {
+  /**
+   * Initialize options with class-specific defaults
+   * Subclasses should override this instead of directly setting options
+   */
+  setDefaults() {
+    return {
+      expand: [],
+      filter: [],
+      sort: []
+    };
   }
-  return null;
-}
-function editorField() {
-  return z.string();
-}
-function geoPointField() {
-  return z.object({
-    lon: z.number(),
-    lat: z.number()
-  });
-}
-function withPermissions(schema, config) {
-  const metadata = {
-    permissions: config
-  };
-  return schema.describe(JSON.stringify(metadata));
-}
-function withIndexes(schema, indexes) {
-  let existingMetadata = {};
-  if (schema.description) {
-    try {
-      existingMetadata = JSON.parse(schema.description);
-    } catch {
+  /**
+   * Merge provided options with current options
+   */
+  overrideOptions(newOptions) {
+    if (newOptions.expand !== void 0) {
+      this.options.expand = newOptions.expand;
+    }
+    if (newOptions.filter !== void 0) {
+      this.options.filter = newOptions.filter;
+    }
+    if (newOptions.sort !== void 0) {
+      this.options.sort = newOptions.sort;
     }
   }
-  const metadata = {
-    ...existingMetadata,
-    indexes
-  };
-  return schema.describe(JSON.stringify(metadata));
-}
-function defineCollection(config) {
-  const { collectionName, schema, permissions, indexes, type, ...futureOptions } = config;
-  const metadata = {
-    collectionName
-  };
-  if (type) {
-    metadata.type = type;
+  toSnakeCase(str) {
+    return str.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
   }
-  if (permissions) {
-    metadata.permissions = permissions;
+  /**
+   * Create a new entity
+   */
+  async create(input) {
+    try {
+      const data = await this.validateInput(input);
+      const record = await this.entityCreate(data);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.errorWrapper(error);
+    }
   }
-  if (indexes) {
-    metadata.indexes = indexes;
+  /**
+   * Update an existing entity
+   */
+  async update(id, input) {
+    try {
+      const record = await this.entityUpdate(id, input);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.errorWrapper(error);
+    }
   }
-  if (Object.keys(futureOptions).length > 0) {
-    Object.assign(metadata, futureOptions);
+  /**
+   * Create or update entity (upsert)
+   */
+  async upsert(input) {
+    if (input?.id) {
+      return await this.update(input.id, input);
+    }
+    return await this.create(input);
   }
-  return schema.describe(JSON.stringify(metadata));
-}
-
-// src/utils/permission-templates.ts
-var PermissionTemplates = {
   /**
-   * Public access - anyone can perform all operations
+   * Get entity by ID
    */
-  public: () => ({
-    listRule: "",
-    viewRule: "",
-    createRule: "",
-    updateRule: "",
-    deleteRule: ""
-  }),
+  async getById(id, expand) {
+    try {
+      const record = await this.entityGetById(id, expand);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.handleError(error, { allowNotFound: true });
+    }
+  }
   /**
-   * Authenticated users only - requires valid authentication for all operations
+   * Get first entity by filter
    */
-  authenticated: () => ({
-    listRule: '@request.auth.id != ""',
-    viewRule: '@request.auth.id != ""',
-    createRule: '@request.auth.id != ""',
-    updateRule: '@request.auth.id != ""',
-    deleteRule: '@request.auth.id != ""'
-  }),
+  async getFirstByFilter(filter, expand, sort) {
+    try {
+      const record = await this.entityGetFirstByFilter(filter, expand, sort);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.handleError(error, { allowNotFound: true });
+    }
+  }
   /**
-   * Owner-only access - users can only manage their own records
-   * @param ownerField - Name of the relation field pointing to user (default: 'User')
+   * Get list of entities
    */
-  ownerOnly: (ownerField = "User") => ({
-    listRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
-    viewRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
-    createRule: '@request.auth.id != ""',
-    updateRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
-    deleteRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`
-  }),
+  async getList(page = 1, perPage = 100, filter, sort, expand) {
+    try {
+      const result = await this.entityGetList(page, perPage, filter, sort, expand);
+      return await this.processListResult(result);
+    } catch (error) {
+      return this.errorWrapper(error);
+    }
+  }
   /**
-   * Admin/superuser only access
-   * Assumes a 'role' field exists with 'admin' value
-   * @param roleField - Name of the role field (default: 'role')
+   * Delete entity by ID
    */
-  adminOnly: (roleField = "role") => ({
-    listRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
-    viewRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
-    createRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
-    updateRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
-    deleteRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`
-  }),
+  async delete(id) {
+    try {
+      return await this.entityDelete(id);
+    } catch (error) {
+      return this.handleError(error, { returnValue: false });
+    }
+  }
   /**
-   * Public read, authenticated write
-   * Anyone can list/view, but only authenticated users can create/update/delete
+   * Process a single record before returning it
+   * Can be overridden to handle special cases like mapped entities
    */
-  readPublic: () => ({
-    listRule: "",
-    viewRule: "",
-    createRule: '@request.auth.id != ""',
-    updateRule: '@request.auth.id != ""',
-    deleteRule: '@request.auth.id != ""'
-  }),
+  async processRecord(record) {
+    return record;
+  }
   /**
-   * Locked access - only superusers can perform operations
-   * All rules are set to null (locked)
+   * Process a list result before returning it
+   * Can be overridden to handle special cases like mapped entities
    */
-  locked: () => ({
-    listRule: null,
-    viewRule: null,
-    createRule: null,
-    updateRule: null,
-    deleteRule: null
-  }),
+  async processListResult(result) {
+    const processedItems = await Promise.all(result.items.map((item) => this.processRecord(item)));
+    return {
+      ...result,
+      items: processedItems
+    };
+  }
   /**
-   * Read-only authenticated - authenticated users can read, no write access
+   * Prepare expand parameter
+   * Combines default expands with provided expands
    */
-  readOnlyAuthenticated: () => ({
-    listRule: '@request.auth.id != ""',
-    viewRule: '@request.auth.id != ""',
-    createRule: null,
-    updateRule: null,
-    deleteRule: null
-  })
-};
-function resolveTemplate(config) {
-  let baseRules;
-  switch (config.template) {
-    case "public":
-      baseRules = PermissionTemplates.public();
-      break;
-    case "authenticated":
-      baseRules = PermissionTemplates.authenticated();
-      break;
-    case "owner-only":
-      baseRules = PermissionTemplates.ownerOnly(config.ownerField);
-      break;
-    case "admin-only":
-      baseRules = PermissionTemplates.adminOnly(config.roleField);
-      break;
-    case "read-public":
-      baseRules = PermissionTemplates.readPublic();
-      break;
-    case "custom":
-      baseRules = {};
-      break;
-    default: {
-      const _exhaustive = config.template;
-      throw new Error(`Unknown template type: ${_exhaustive}`);
+  prepareExpand(expand) {
+    if (!this.options.expand.length && !expand) {
+      return void 0;
     }
-  }
-  return {
-    ...baseRules,
-    ...config.customRules
-  };
-}
-function isTemplateConfig(config) {
-  return "template" in config;
-}
-function isPermissionSchema(config) {
-  return "listRule" in config || "viewRule" in config || "createRule" in config || "updateRule" in config || "deleteRule" in config || "manageRule" in config;
-}
-function validatePermissionConfig(config, isAuthCollection2 = false) {
-  const result = {
-    valid: true,
-    errors: [],
-    warnings: []
-  };
-  let permissions;
-  if (isTemplateConfig(config)) {
-    if (config.template === "owner-only" && !config.ownerField) {
-      result.warnings.push("owner-only template without ownerField specified - using default 'User'");
+    let expandArray = [...this.options.expand];
+    if (expand) {
+      if (typeof expand === "string") {
+        expandArray = expandArray.concat(expand.split(",").map((e) => e.trim()));
+      } else {
+        expandArray = expandArray.concat(expand);
+      }
     }
-    if (config.template === "admin-only" && !config.roleField) {
-      result.warnings.push("admin-only template without roleField specified - using default 'role'");
+    const uniqueExpands = [...new Set(expandArray)].filter((e) => e !== "" && e !== void 0);
+    if (!uniqueExpands.length) {
+      return void 0;
     }
-    permissions = resolveTemplate(config);
-  } else {
-    permissions = config;
-  }
-  if (permissions.manageRule !== void 0 && !isAuthCollection2) {
-    result.errors.push("manageRule is only valid for auth collections");
-    result.valid = false;
-  }
-  const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule"];
-  if (isAuthCollection2) {
-    ruleTypes.push("manageRule");
+    return uniqueExpands.join(",");
   }
-  for (const ruleType of ruleTypes) {
-    const rule = permissions[ruleType];
-    if (rule !== void 0 && rule !== null && rule !== "") {
-      const ruleValidation = validateRuleExpression(rule);
-      if (!ruleValidation.valid) {
-        result.errors.push(`${ruleType}: ${ruleValidation.errors.join(", ")}`);
-        result.valid = false;
+  /**
+   * Prepare filter parameter
+   * Combines default filters with provided filters
+   */
+  prepareFilter(filter) {
+    if (!this.options.filter.length && !filter) {
+      return void 0;
+    }
+    let filterArray = [...this.options.filter];
+    if (filter) {
+      if (typeof filter === "string") {
+        if (filter) filterArray.push(filter);
+      } else {
+        filterArray = filterArray.concat(filter);
       }
-      result.warnings.push(...ruleValidation.warnings.map((w) => `${ruleType}: ${w}`));
     }
-  }
-  return result;
-}
-function validateRuleExpression(expression) {
-  const result = {
-    valid: true,
-    errors: [],
-    warnings: []
-  };
-  if (expression === null || expression === "") {
-    return result;
-  }
-  let parenCount = 0;
-  for (const char of expression) {
-    if (char === "(") parenCount++;
-    if (char === ")") parenCount--;
-    if (parenCount < 0) {
-      result.errors.push("Unbalanced parentheses");
-      result.valid = false;
-      return result;
+    const validFilters = filterArray.filter((f) => f !== "" && f !== void 0);
+    if (!validFilters.length) {
+      return void 0;
     }
+    return validFilters.join("&&");
   }
-  if (parenCount !== 0) {
-    result.errors.push("Unbalanced parentheses");
-    result.valid = false;
-  }
-  if (expression.includes("==")) {
-    result.warnings.push("Use '=' instead of '==' for equality comparison");
-  }
-  const requestRefs = expression.match(/@request\.[a-zA-Z_][a-zA-Z0-9_.]*/g) || [];
-  for (const ref of requestRefs) {
-    const isValid = ref.startsWith("@request.auth.") || ref === "@request.method" || ref === "@request.context" || ref.startsWith("@request.body.") || ref.startsWith("@request.query.") || ref.startsWith("@request.headers.");
-    if (!isValid) {
-      result.errors.push(`Invalid @request reference: '${ref}'`);
-      result.valid = false;
+  /**
+   * Prepare sort parameter
+   * Uses provided sort or falls back to default sort
+   */
+  prepareSort(sort) {
+    if (sort && sort !== "") {
+      return sort;
+    }
+    if (this.options.sort.length) {
+      const validSorts = this.options.sort.filter((s) => s !== "" && s !== void 0);
+      if (validSorts.length) {
+        return validSorts.join(",");
+      }
     }
+    return void 0;
   }
-  return result;
-}
-function createPermissions(permissions) {
-  return {
-    listRule: permissions.listRule ?? null,
-    viewRule: permissions.viewRule ?? null,
-    createRule: permissions.createRule ?? null,
-    updateRule: permissions.updateRule ?? null,
-    deleteRule: permissions.deleteRule ?? null,
-    manageRule: permissions.manageRule ?? null
-  };
-}
-function mergePermissions(...schemas) {
-  const merged = {
-    listRule: null,
-    viewRule: null,
-    createRule: null,
-    updateRule: null,
-    deleteRule: null,
-    manageRule: null
-  };
-  for (const schema of schemas) {
-    if (schema.listRule !== void 0) merged.listRule = schema.listRule;
-    if (schema.viewRule !== void 0) merged.viewRule = schema.viewRule;
-    if (schema.createRule !== void 0) merged.createRule = schema.createRule;
-    if (schema.updateRule !== void 0) merged.updateRule = schema.updateRule;
-    if (schema.deleteRule !== void 0) merged.deleteRule = schema.deleteRule;
-    if (schema.manageRule !== void 0) merged.manageRule = schema.manageRule;
+  /**
+   * Perform the actual create operation
+   */
+  async entityCreate(data) {
+    return await this.getCollection().create(data);
   }
-  return merged;
-}
-var ProjectInputSchema = z.object({
-  // Required fields
-  title: z.string(),
-  content: z.string(),
-  status: StatusEnum,
-  summary: z.string().optional(),
-  OwnerUser: RelationField({ collection: "Users" }),
-  SubscriberUsers: RelationsField({ collection: "Users" })
-}).extend(inputImageFileSchema);
-var ProjectSchema = ProjectInputSchema.omit(omitImageFilesSchema).extend(baseImageFileSchema);
-var ProjectCollection = defineCollection({
-  collectionName: "Projects",
-  schema: ProjectSchema,
-  permissions: {
-    template: "owner-only",
-    ownerField: "OwnerUser",
-    customRules: {
-      listRule: '@request.auth.id != ""',
-      viewRule: '@request.auth.id != "" && (OwnerUser = @request.auth.id || SubscriberUsers ?= @request.auth.id)'
-    }
+  /**
+   * Perform the actual update operation
+   */
+  async entityUpdate(id, data) {
+    return await this.getCollection().update(id, data);
   }
-});
-var UserInputSchema = z.object({
-  name: z.string().optional(),
-  email: z.string().email(),
-  password: z.string().min(8, "Password must be at least 8 characters"),
-  passwordConfirm: z.string(),
-  avatar: z.instanceof(File).optional()
-});
-var UserCollectionSchema = z.object({
-  name: z.string().optional(),
-  email: z.string().email(),
-  password: z.string().min(8, "Password must be at least 8 characters"),
-  avatar: z.instanceof(File).optional()
-});
-var UserSchema = UserCollectionSchema.extend(baseSchema);
-var UserCollection = defineCollection({
-  collectionName: "users",
-  type: "auth",
-  schema: UserSchema,
-  permissions: {
-    // Users can list their own profile
-    listRule: "id = @request.auth.id",
-    // Users can view their own profile
-    viewRule: "id = @request.auth.id",
-    // Anyone can create an account (sign up)
-    createRule: "",
-    // Users can only update their own profile
-    updateRule: "id = @request.auth.id",
-    // Users can only delete their own account
-    deleteRule: "id = @request.auth.id"
-    // manageRule is null in PocketBase default (not set)
-  },
-  indexes: [
-    // PocketBase's default indexes for auth collections
-    "CREATE UNIQUE INDEX `idx_tokenKey__pb_users_auth_` ON `users` (`tokenKey`)",
-    "CREATE UNIQUE INDEX `idx_email__pb_users_auth_` ON `users` (`email`) WHERE `email` != ''"
-  ]
-});
-var BaseMutator = class {
-  pb;
-  // Define a default property that subclasses will override
-  options = {
-    expand: [],
-    filter: [],
-    sort: []
-  };
-  constructor(pb, options) {
-    this.pb = pb;
-    this.initializeOptions();
-    if (options) {
-      this.overrideOptions(options);
-    }
+  /**
+   * Perform the actual getById operation
+   */
+  async entityGetById(id, expand) {
+    const finalExpand = this.prepareExpand(expand);
+    const options = finalExpand ? { expand: finalExpand } : {};
+    return await this.getCollection().getOne(id, options);
   }
-  initializeOptions() {
-    this.options = this.setDefaults();
+  /**
+   * Perform the actual getFirstByFilter operation
+   */
+  async entityGetFirstByFilter(filter, expand, sort) {
+    const finalFilter = this.prepareFilter(filter);
+    const finalExpand = this.prepareExpand(expand);
+    const finalSort = this.prepareSort(sort);
+    const options = {};
+    if (finalExpand) options.expand = finalExpand;
+    if (finalSort) options.sort = finalSort;
+    return await this.getCollection().getFirstListItem(finalFilter || "", options);
   }
   /**
-   * Initialize options with class-specific defaults
-   * Subclasses should override this instead of directly setting options
+   * Perform the actual getList operation
+   * Returns a list result with items of type T
    */
-  setDefaults() {
-    return {
-      expand: [],
-      filter: [],
-      sort: []
-    };
+  async entityGetList(page, perPage, filter, sort, expand) {
+    const finalFilter = this.prepareFilter(filter);
+    const finalExpand = this.prepareExpand(expand);
+    const finalSort = this.prepareSort(sort);
+    const options = {};
+    if (finalFilter) options.filter = finalFilter;
+    if (finalExpand) options.expand = finalExpand;
+    if (finalSort) options.sort = finalSort;
+    return await this.getCollection().getList(page, perPage, options);
   }
   /**
-   * Merge provided options with current options
+   * Perform the actual delete operation
    */
-  overrideOptions(newOptions) {
-    if (newOptions.expand !== void 0) {
-      this.options.expand = newOptions.expand;
+  async entityDelete(id) {
+    await this.getCollection().delete(id);
+    return true;
+  }
+  /**
+   * Error handler for common errors
+   * @param error The error to handle
+   * @param options Handler options
+   * @returns The value to return if the error is handled, or throws if not handled
+   */
+  handleError(error, options = { logError: true }) {
+    const { allowNotFound = false, returnValue, logError: logError2 = true } = options;
+    if (logError2) {
+      console.error(`Error in ${this.constructor.name}:`, error);
     }
-    if (newOptions.filter !== void 0) {
-      this.options.filter = newOptions.filter;
+    if (allowNotFound && this.isNotFoundError(error)) {
+      return null;
     }
-    if (newOptions.sort !== void 0) {
-      this.options.sort = newOptions.sort;
+    if (returnValue !== void 0) {
+      return returnValue;
     }
+    throw error;
   }
-  toSnakeCase(str) {
-    return str.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  /**
+   * Check if an error is a "not found" error
+   */
+  isNotFoundError(error) {
+    return error instanceof Error && (error.message.includes("404") || error.message.toLowerCase().includes("not found"));
   }
   /**
-   * Create a new entity
+   * Standard error handling wrapper (legacy method, consider using handleError instead)
    */
-  async create(input) {
-    try {
-      const data = await this.validateInput(input);
-      const record = await this.entityCreate(data);
-      return await this.processRecord(record);
-    } catch (error) {
-      return this.errorWrapper(error);
-    }
+  errorWrapper(error) {
+    console.error(`Error in ${this.constructor.name}:`, error);
+    throw error;
   }
   /**
-   * Update an existing entity
+   * Subscribe to changes on a specific record
+   * @param id The ID of the record to subscribe to
+   * @param callback Function to call when changes occur
+   * @param expand Optional expand parameters
+   * @returns Promise that resolves to an unsubscribe function
    */
-  async update(id, input) {
-    try {
-      const record = await this.entityUpdate(id, input);
-      return await this.processRecord(record);
-    } catch (error) {
-      return this.errorWrapper(error);
-    }
+  async subscribeToRecord(id, callback, expand) {
+    const finalExpand = this.prepareExpand(expand);
+    const options = finalExpand ? { expand: finalExpand } : {};
+    return this.getCollection().subscribe(id, callback, options);
   }
   /**
-   * Create or update entity (upsert)
+   * Subscribe to changes on the entire collection
+   * @param callback Function to call when changes occur
+   * @param expand Optional expand parameters
+   * @returns Promise that resolves to an unsubscribe function
    */
-  async upsert(input) {
-    if (input?.id) {
-      return await this.update(input.id, input);
+  async subscribeToCollection(callback, expand) {
+    const finalExpand = this.prepareExpand(expand);
+    const options = finalExpand ? { expand: finalExpand } : {};
+    return this.getCollection().subscribe("*", callback, options);
+  }
+  /**
+   * Unsubscribe from a specific record's changes
+   * @param id The ID of the record to unsubscribe from
+   */
+  unsubscribeFromRecord(id) {
+    this.getCollection().unsubscribe(id);
+  }
+  /**
+   * Unsubscribe from collection-wide changes
+   */
+  unsubscribeFromCollection() {
+    this.getCollection().unsubscribe("*");
+  }
+  /**
+   * Unsubscribe from all subscriptions in this collection
+   */
+  unsubscribeAll() {
+    this.getCollection().unsubscribe();
+  }
+};
+var baseSchema = {
+  id: z.string().describe("unique id"),
+  collectionId: z.string().describe("collection id"),
+  collectionName: z.string().describe("collection name"),
+  expand: z.record(z.any()).describe("expandable fields"),
+  created: z.string().describe("creation timestamp"),
+  updated: z.string().describe("last update timestamp")
+};
+var baseSchemaWithTimestamps = {
+  ...baseSchema,
+  created: z.string().describe("creation timestamp"),
+  updated: z.string().describe("last update timestamp")
+};
+var baseImageFileSchema = {
+  ...baseSchema,
+  thumbnailURL: z.string().optional(),
+  imageFiles: z.array(z.string())
+};
+var inputImageFileSchema = {
+  imageFiles: z.array(z.instanceof(File))
+};
+var omitImageFilesSchema = {
+  imageFiles: true
+};
+function textField(options) {
+  let schema = z.string();
+  if (options?.min !== void 0) schema = schema.min(options.min);
+  if (options?.max !== void 0) schema = schema.max(options.max);
+  if (options?.pattern !== void 0) schema = schema.regex(options.pattern);
+  return schema;
+}
+function emailField() {
+  return z.string().email();
+}
+function urlField() {
+  return z.string().url();
+}
+function numberField(options) {
+  let schema = z.number();
+  if (options?.min !== void 0) schema = schema.min(options.min);
+  if (options?.max !== void 0) schema = schema.max(options.max);
+  return schema;
+}
+function boolField() {
+  return z.boolean();
+}
+function dateField() {
+  return z.date();
+}
+function selectField(values) {
+  return z.enum(values);
+}
+function jsonField(schema) {
+  return schema ?? z.record(z.any());
+}
+function fileField() {
+  return z.instanceof(File);
+}
+function filesField(options) {
+  let schema = z.array(z.instanceof(File));
+  if (options?.min !== void 0) schema = schema.min(options.min);
+  if (options?.max !== void 0) schema = schema.max(options.max);
+  return schema;
+}
+var RELATION_METADATA_KEY = "__pocketbase_relation__";
+function RelationField(config) {
+  const metadata = {
+    [RELATION_METADATA_KEY]: {
+      type: "single",
+      collection: config.collection,
+      cascadeDelete: config.cascadeDelete ?? false,
+      maxSelect: 1,
+      minSelect: 0
     }
-    return await this.create(input);
-  }
-  /**
-   * Get entity by ID
-   */
-  async getById(id, expand) {
-    try {
-      const record = await this.entityGetById(id, expand);
-      return await this.processRecord(record);
-    } catch (error) {
-      return this.handleError(error, { allowNotFound: true });
+  };
+  return z.string().describe(JSON.stringify(metadata));
+}
+function RelationsField(config) {
+  const metadata = {
+    [RELATION_METADATA_KEY]: {
+      type: "multiple",
+      collection: config.collection,
+      cascadeDelete: config.cascadeDelete ?? false,
+      maxSelect: config.maxSelect ?? 999,
+      minSelect: config.minSelect ?? 0
     }
+  };
+  let schema = z.array(z.string());
+  if (config.minSelect !== void 0) {
+    schema = schema.min(config.minSelect);
   }
-  /**
-   * Get first entity by filter
-   */
-  async getFirstByFilter(filter, expand, sort) {
-    try {
-      const record = await this.entityGetFirstByFilter(filter, expand, sort);
-      return await this.processRecord(record);
-    } catch (error) {
-      return this.handleError(error, { allowNotFound: true });
-    }
+  if (config.maxSelect !== void 0) {
+    schema = schema.max(config.maxSelect);
   }
-  /**
-   * Get list of entities
-   */
-  async getList(page = 1, perPage = 100, filter, sort, expand) {
-    try {
-      const result = await this.entityGetList(page, perPage, filter, sort, expand);
-      return await this.processListResult(result);
-    } catch (error) {
-      return this.errorWrapper(error);
+  return schema.describe(JSON.stringify(metadata));
+}
+function extractRelationMetadata(description) {
+  if (!description) return null;
+  try {
+    const parsed = JSON.parse(description);
+    if (parsed[RELATION_METADATA_KEY]) {
+      return parsed[RELATION_METADATA_KEY];
     }
+  } catch {
   }
-  /**
-   * Delete entity by ID
-   */
-  async delete(id) {
+  return null;
+}
+function editorField() {
+  return z.string();
+}
+function geoPointField() {
+  return z.object({
+    lon: z.number(),
+    lat: z.number()
+  });
+}
+function withPermissions(schema, config) {
+  const metadata = {
+    permissions: config
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+function withIndexes(schema, indexes) {
+  let existingMetadata = {};
+  if (schema.description) {
     try {
-      return await this.entityDelete(id);
-    } catch (error) {
-      return this.handleError(error, { returnValue: false });
+      existingMetadata = JSON.parse(schema.description);
+    } catch {
     }
   }
-  /**
-   * Process a single record before returning it
-   * Can be overridden to handle special cases like mapped entities
-   */
-  async processRecord(record) {
-    return record;
-  }
-  /**
-   * Process a list result before returning it
-   * Can be overridden to handle special cases like mapped entities
-   */
-  async processListResult(result) {
-    const processedItems = await Promise.all(result.items.map((item) => this.processRecord(item)));
-    return {
-      ...result,
-      items: processedItems
-    };
+  const metadata = {
+    ...existingMetadata,
+    indexes
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+function defineCollection(config) {
+  const { collectionName, schema, permissions, indexes, type, ...futureOptions } = config;
+  const metadata = {
+    collectionName
+  };
+  if (type) {
+    metadata.type = type;
   }
-  /**
-   * Prepare expand parameter
-   * Combines default expands with provided expands
-   */
-  prepareExpand(expand) {
-    if (!this.options.expand.length && !expand) {
-      return void 0;
-    }
-    let expandArray = [...this.options.expand];
-    if (expand) {
-      if (typeof expand === "string") {
-        expandArray = expandArray.concat(expand.split(",").map((e) => e.trim()));
-      } else {
-        expandArray = expandArray.concat(expand);
-      }
-    }
-    const uniqueExpands = [...new Set(expandArray)].filter((e) => e !== "" && e !== void 0);
-    if (!uniqueExpands.length) {
-      return void 0;
-    }
-    return uniqueExpands.join(",");
+  if (permissions) {
+    metadata.permissions = permissions;
   }
-  /**
-   * Prepare filter parameter
-   * Combines default filters with provided filters
-   */
-  prepareFilter(filter) {
-    if (!this.options.filter.length && !filter) {
-      return void 0;
-    }
-    let filterArray = [...this.options.filter];
-    if (filter) {
-      if (typeof filter === "string") {
-        if (filter) filterArray.push(filter);
-      } else {
-        filterArray = filterArray.concat(filter);
-      }
-    }
-    const validFilters = filterArray.filter((f) => f !== "" && f !== void 0);
-    if (!validFilters.length) {
-      return void 0;
-    }
-    return validFilters.join("&&");
+  if (indexes) {
+    metadata.indexes = indexes;
   }
-  /**
-   * Prepare sort parameter
-   * Uses provided sort or falls back to default sort
-   */
-  prepareSort(sort) {
-    if (sort && sort !== "") {
-      return sort;
-    }
-    if (this.options.sort.length) {
-      const validSorts = this.options.sort.filter((s) => s !== "" && s !== void 0);
-      if (validSorts.length) {
-        return validSorts.join(",");
-      }
-    }
-    return void 0;
+  if (Object.keys(futureOptions).length > 0) {
+    Object.assign(metadata, futureOptions);
   }
+  return schema.describe(JSON.stringify(metadata));
+}
+
+// src/utils/permission-templates.ts
+var PermissionTemplates = {
   /**
-   * Perform the actual create operation
+   * Public access - anyone can perform all operations
    */
-  async entityCreate(data) {
-    return await this.getCollection().create(data);
-  }
+  public: () => ({
+    listRule: "",
+    viewRule: "",
+    createRule: "",
+    updateRule: "",
+    deleteRule: ""
+  }),
   /**
-   * Perform the actual update operation
+   * Authenticated users only - requires valid authentication for all operations
    */
-  async entityUpdate(id, data) {
-    return await this.getCollection().update(id, data);
-  }
+  authenticated: () => ({
+    listRule: '@request.auth.id != ""',
+    viewRule: '@request.auth.id != ""',
+    createRule: '@request.auth.id != ""',
+    updateRule: '@request.auth.id != ""',
+    deleteRule: '@request.auth.id != ""'
+  }),
   /**
-   * Perform the actual getById operation
+   * Owner-only access - users can only manage their own records
+   * @param ownerField - Name of the relation field pointing to user (default: 'User')
    */
-  async entityGetById(id, expand) {
-    const finalExpand = this.prepareExpand(expand);
-    const options = finalExpand ? { expand: finalExpand } : {};
-    return await this.getCollection().getOne(id, options);
-  }
+  ownerOnly: (ownerField = "User") => ({
+    listRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    viewRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    createRule: '@request.auth.id != ""',
+    updateRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    deleteRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`
+  }),
   /**
-   * Perform the actual getFirstByFilter operation
+   * Admin/superuser only access
+   * Assumes a 'role' field exists with 'admin' value
+   * @param roleField - Name of the role field (default: 'role')
    */
-  async entityGetFirstByFilter(filter, expand, sort) {
-    const finalFilter = this.prepareFilter(filter);
-    const finalExpand = this.prepareExpand(expand);
-    const finalSort = this.prepareSort(sort);
-    const options = {};
-    if (finalExpand) options.expand = finalExpand;
-    if (finalSort) options.sort = finalSort;
-    return await this.getCollection().getFirstListItem(finalFilter || "", options);
-  }
+  adminOnly: (roleField = "role") => ({
+    listRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    viewRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    createRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    updateRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    deleteRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`
+  }),
   /**
-   * Perform the actual getList operation
-   * Returns a list result with items of type T
+   * Public read, authenticated write
+   * Anyone can list/view, but only authenticated users can create/update/delete
    */
-  async entityGetList(page, perPage, filter, sort, expand) {
-    const finalFilter = this.prepareFilter(filter);
-    const finalExpand = this.prepareExpand(expand);
-    const finalSort = this.prepareSort(sort);
-    const options = {};
-    if (finalFilter) options.filter = finalFilter;
-    if (finalExpand) options.expand = finalExpand;
-    if (finalSort) options.sort = finalSort;
-    return await this.getCollection().getList(page, perPage, options);
-  }
+  readPublic: () => ({
+    listRule: "",
+    viewRule: "",
+    createRule: '@request.auth.id != ""',
+    updateRule: '@request.auth.id != ""',
+    deleteRule: '@request.auth.id != ""'
+  }),
   /**
-   * Perform the actual delete operation
+   * Locked access - only superusers can perform operations
+   * All rules are set to null (locked)
    */
-  async entityDelete(id) {
-    await this.getCollection().delete(id);
-    return true;
-  }
+  locked: () => ({
+    listRule: null,
+    viewRule: null,
+    createRule: null,
+    updateRule: null,
+    deleteRule: null
+  }),
   /**
-   * Error handler for common errors
-   * @param error The error to handle
-   * @param options Handler options
-   * @returns The value to return if the error is handled, or throws if not handled
+   * Read-only authenticated - authenticated users can read, no write access
    */
-  handleError(error, options = { logError: true }) {
-    const { allowNotFound = false, returnValue, logError: logError2 = true } = options;
-    if (logError2) {
-      console.error(`Error in ${this.constructor.name}:`, error);
+  readOnlyAuthenticated: () => ({
+    listRule: '@request.auth.id != ""',
+    viewRule: '@request.auth.id != ""',
+    createRule: null,
+    updateRule: null,
+    deleteRule: null
+  })
+};
+function resolveTemplate(config) {
+  let baseRules;
+  switch (config.template) {
+    case "public":
+      baseRules = PermissionTemplates.public();
+      break;
+    case "authenticated":
+      baseRules = PermissionTemplates.authenticated();
+      break;
+    case "owner-only":
+      baseRules = PermissionTemplates.ownerOnly(config.ownerField);
+      break;
+    case "admin-only":
+      baseRules = PermissionTemplates.adminOnly(config.roleField);
+      break;
+    case "read-public":
+      baseRules = PermissionTemplates.readPublic();
+      break;
+    case "custom":
+      baseRules = {};
+      break;
+    default: {
+      const _exhaustive = config.template;
+      throw new Error(`Unknown template type: ${_exhaustive}`);
     }
-    if (allowNotFound && this.isNotFoundError(error)) {
-      return null;
+  }
+  return {
+    ...baseRules,
+    ...config.customRules
+  };
+}
+function isTemplateConfig(config) {
+  return "template" in config;
+}
+function isPermissionSchema(config) {
+  return "listRule" in config || "viewRule" in config || "createRule" in config || "updateRule" in config || "deleteRule" in config || "manageRule" in config;
+}
+function validatePermissionConfig(config, isAuthCollection2 = false) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  let permissions;
+  if (isTemplateConfig(config)) {
+    if (config.template === "owner-only" && !config.ownerField) {
+      result.warnings.push("owner-only template without ownerField specified - using default 'User'");
     }
-    if (returnValue !== void 0) {
-      return returnValue;
+    if (config.template === "admin-only" && !config.roleField) {
+      result.warnings.push("admin-only template without roleField specified - using default 'role'");
     }
-    throw error;
-  }
-  /**
-   * Check if an error is a "not found" error
-   */
-  isNotFoundError(error) {
-    return error instanceof Error && (error.message.includes("404") || error.message.toLowerCase().includes("not found"));
+    permissions = resolveTemplate(config);
+  } else {
+    permissions = config;
   }
-  /**
-   * Standard error handling wrapper (legacy method, consider using handleError instead)
-   */
-  errorWrapper(error) {
-    console.error(`Error in ${this.constructor.name}:`, error);
-    throw error;
+  if (permissions.manageRule !== void 0 && !isAuthCollection2) {
+    result.errors.push("manageRule is only valid for auth collections");
+    result.valid = false;
   }
-  /**
-   * Subscribe to changes on a specific record
-   * @param id The ID of the record to subscribe to
-   * @param callback Function to call when changes occur
-   * @param expand Optional expand parameters
-   * @returns Promise that resolves to an unsubscribe function
-   */
-  async subscribeToRecord(id, callback, expand) {
-    const finalExpand = this.prepareExpand(expand);
-    const options = finalExpand ? { expand: finalExpand } : {};
-    return this.getCollection().subscribe(id, callback, options);
+  const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule"];
+  if (isAuthCollection2) {
+    ruleTypes.push("manageRule");
   }
-  /**
-   * Subscribe to changes on the entire collection
-   * @param callback Function to call when changes occur
-   * @param expand Optional expand parameters
-   * @returns Promise that resolves to an unsubscribe function
-   */
-  async subscribeToCollection(callback, expand) {
-    const finalExpand = this.prepareExpand(expand);
-    const options = finalExpand ? { expand: finalExpand } : {};
-    return this.getCollection().subscribe("*", callback, options);
+  for (const ruleType of ruleTypes) {
+    const rule = permissions[ruleType];
+    if (rule !== void 0 && rule !== null && rule !== "") {
+      const ruleValidation = validateRuleExpression(rule);
+      if (!ruleValidation.valid) {
+        result.errors.push(`${ruleType}: ${ruleValidation.errors.join(", ")}`);
+        result.valid = false;
+      }
+      result.warnings.push(...ruleValidation.warnings.map((w) => `${ruleType}: ${w}`));
+    }
   }
-  /**
-   * Unsubscribe from a specific record's changes
-   * @param id The ID of the record to unsubscribe from
-   */
-  unsubscribeFromRecord(id) {
-    this.getCollection().unsubscribe(id);
+  return result;
+}
+function validateRuleExpression(expression) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  if (expression === null || expression === "") {
+    return result;
   }
-  /**
-   * Unsubscribe from collection-wide changes
-   */
-  unsubscribeFromCollection() {
-    this.getCollection().unsubscribe("*");
+  let parenCount = 0;
+  for (const char of expression) {
+    if (char === "(") parenCount++;
+    if (char === ")") parenCount--;
+    if (parenCount < 0) {
+      result.errors.push("Unbalanced parentheses");
+      result.valid = false;
+      return result;
+    }
   }
-  /**
-   * Unsubscribe from all subscriptions in this collection
-   */
-  unsubscribeAll() {
-    this.getCollection().unsubscribe();
+  if (parenCount !== 0) {
+    result.errors.push("Unbalanced parentheses");
+    result.valid = false;
   }
-};
-
-// src/mutator/userMutator.ts
-var UserMutator = class extends BaseMutator {
-  setDefaults() {
-    return {
-      expand: [],
-      filter: [],
-      sort: ["-updated"]
-    };
+  if (expression.includes("==")) {
+    result.warnings.push("Use '=' instead of '==' for equality comparison");
   }
-  getCollection() {
-    return this.pb.collection("Users");
+  const requestRefs = expression.match(/@request\.[a-zA-Z_][a-zA-Z0-9_.]*/g) || [];
+  for (const ref of requestRefs) {
+    const isValid = ref.startsWith("@request.auth.") || ref === "@request.method" || ref === "@request.context" || ref.startsWith("@request.body.") || ref.startsWith("@request.query.") || ref.startsWith("@request.headers.");
+    if (!isValid) {
+      result.errors.push(`Invalid @request reference: '${ref}'`);
+      result.valid = false;
+    }
   }
-  async validateInput(input) {
-    return UserInputSchema.parse(input);
+  return result;
+}
+function createPermissions(permissions) {
+  return {
+    listRule: permissions.listRule ?? null,
+    viewRule: permissions.viewRule ?? null,
+    createRule: permissions.createRule ?? null,
+    updateRule: permissions.updateRule ?? null,
+    deleteRule: permissions.deleteRule ?? null,
+    manageRule: permissions.manageRule ?? null
+  };
+}
+function mergePermissions(...schemas) {
+  const merged = {
+    listRule: null,
+    viewRule: null,
+    createRule: null,
+    updateRule: null,
+    deleteRule: null,
+    manageRule: null
+  };
+  for (const schema of schemas) {
+    if (schema.listRule !== void 0) merged.listRule = schema.listRule;
+    if (schema.viewRule !== void 0) merged.viewRule = schema.viewRule;
+    if (schema.createRule !== void 0) merged.createRule = schema.createRule;
+    if (schema.updateRule !== void 0) merged.updateRule = schema.updateRule;
+    if (schema.deleteRule !== void 0) merged.deleteRule = schema.deleteRule;
+    if (schema.manageRule !== void 0) merged.manageRule = schema.manageRule;
   }
-};
+  return merged;
+}
 
 // src/migration/errors.ts
 var MigrationError = class _MigrationError extends Error {
@@ -3982,6 +3906,55 @@ function generateIndexesArray(indexes) {
     ${indexStrings.join(",\n    ")},
   ]`;
 }
+function getSystemFields() {
+  return [
+    // id field - primary key, auto-generated
+    {
+      name: "id",
+      type: "text",
+      required: true,
+      options: {
+        autogeneratePattern: "[a-z0-9]{15}",
+        hidden: false,
+        id: "text3208210256",
+        max: 15,
+        min: 15,
+        pattern: "^[a-z0-9]+$",
+        presentable: false,
+        primaryKey: true,
+        system: true
+      }
+    },
+    // created field - autodate, set on creation
+    {
+      name: "created",
+      type: "autodate",
+      required: true,
+      options: {
+        hidden: false,
+        id: "autodate2990389176",
+        onCreate: true,
+        onUpdate: false,
+        presentable: false,
+        system: false
+      }
+    },
+    // updated field - autodate, set on creation and update
+    {
+      name: "updated",
+      type: "autodate",
+      required: true,
+      options: {
+        hidden: false,
+        id: "autodate3332085495",
+        onCreate: true,
+        onUpdate: true,
+        presentable: false,
+        system: false
+      }
+    }
+  ];
+}
 function generateCollectionCreation(collection, varName = "collection", isLast = false) {
   const lines = [];
   lines.push(`  const ${varName} = new Collection({`);
@@ -3994,7 +3967,9 @@ function generateCollectionCreation(collection, varName = "collection", isLast =
   } else if (rulesCode) {
     lines.push(`    ${rulesCode},`);
   }
-  lines.push(`    fields: ${generateFieldsArray(collection.fields)},`);
+  const systemFields = getSystemFields();
+  const allFields = [...systemFields, ...collection.fields];
+  lines.push(`    fields: ${generateFieldsArray(allFields)},`);
   lines.push(`    indexes: ${generateIndexesArray(collection.indexes)},`);
   lines.push(`  });`);
   lines.push(``);
@@ -5268,6 +5243,6 @@ async function executeStatus(options) {
   }
 }
 
-export { CLIUsageError, ConfigurationError, DiffEngine, FIELD_TYPE_INFO, FileSystemError, MigrationError, MigrationGenerationError, MigrationGenerator, POCKETBASE_FIELD_TYPES, PermissionTemplates, ProjectCollection, ProjectInputSchema, ProjectSchema, RelationField, RelationsField, SchemaAnalyzer, SchemaParsingError, SnapshotError, SnapshotManager, StatusEnum, UserCollection, UserCollectionSchema, UserInputSchema, UserMutator, UserSchema, aggregateChanges, baseImageFileSchema, baseSchema, baseSchemaWithTimestamps, boolField, buildFieldDefinition, buildSchemaDefinition, categorizeChangesBySeverity, compare, compareFieldConstraints, compareFieldOptions, compareFieldTypes, comparePermissions, compareRelationConfigurations, convertPocketBaseMigration, convertZodSchemaToCollectionSchema, createMigrationFileStructure, createPermissions, dateField, defineCollection, detectDestructiveChanges, detectFieldChanges, discoverSchemaFiles, editorField, emailField, extractComprehensiveFieldOptions, extractFieldDefinitions, extractFieldOptions, extractIndexes, extractRelationMetadata, extractSchemaDefinitions, fileField, filesField, filterSystemCollections, findLatestSnapshot, findNewCollections, findNewFields, findRemovedCollections, findRemovedFields, formatChangeSummary, generate, generateChangeSummary, generateCollectionCreation, generateCollectionPermissions, generateCollectionRules, generateDownMigration, generateFieldAddition, generateFieldDefinitionObject, generateFieldDeletion, generateFieldModification, generateFieldsArray, generateIndexesArray, executeGenerate as generateMigration, generateMigrationDescription, generateMigrationFilename, generatePermissionUpdate, generateTimestamp, generateUpMigration, geoPointField, getArrayElementType, getCollectionNameFromFile, getDefaultValue, getFieldTypeInfo, getMaxSelect, executeStatus as getMigrationStatus, getMinSelect, getSnapshotPath, getSnapshotVersion, getUsersSystemFields, importSchemaModule, inputImageFileSchema, isArrayType, isAuthCollection, isEditorField, isFieldRequired, isFileFieldByName, isGeoPointType, isMultipleRelationField, isPermissionSchema, isRelationField, isSingleRelationField, isSystemCollection, isTemplateConfig, jsonField, loadBaseMigration, loadConfig, loadSnapshot, loadSnapshotIfExists, loadSnapshotWithMigrations, logError, logInfo, logSection, logSuccess, logWarning, mapZodArrayType, mapZodBooleanType, mapZodDateType, mapZodEnumType, mapZodNumberType, mapZodRecordType, mapZodStringType, mapZodTypeToPocketBase, matchCollectionsByName, matchFieldsByName, mergePermissions, mergeSnapshots, numberField, omitImageFilesSchema, parseSchemaFiles, pluralize, requiresForceFlag, resolveTargetCollection, resolveTemplate, saveSnapshot, selectField, selectSchemaForCollection, singularize, snapshotExists, textField, toCollectionName, unwrapZodType, urlField, validatePermissionConfig, validateRuleExpression, validateSnapshot, withIndexes, withPermissions, withProgress, writeMigrationFile };
+export { BaseMutator, CLIUsageError, ConfigurationError, DiffEngine, FIELD_TYPE_INFO, FileSystemError, MigrationError, MigrationGenerationError, MigrationGenerator, POCKETBASE_FIELD_TYPES, PermissionTemplates, RelationField, RelationsField, SchemaAnalyzer, SchemaParsingError, SnapshotError, SnapshotManager, StatusEnum, aggregateChanges, baseImageFileSchema, baseSchema, baseSchemaWithTimestamps, boolField, buildFieldDefinition, buildSchemaDefinition, categorizeChangesBySeverity, compare, compareFieldConstraints, compareFieldOptions, compareFieldTypes, comparePermissions, compareRelationConfigurations, convertPocketBaseMigration, convertZodSchemaToCollectionSchema, createMigrationFileStructure, createPermissions, dateField, defineCollection, detectDestructiveChanges, detectFieldChanges, discoverSchemaFiles, editorField, emailField, extractComprehensiveFieldOptions, extractFieldDefinitions, extractFieldOptions, extractIndexes, extractRelationMetadata, extractSchemaDefinitions, fileField, filesField, filterSystemCollections, findLatestSnapshot, findNewCollections, findNewFields, findRemovedCollections, findRemovedFields, formatChangeSummary, generate, generateChangeSummary, generateCollectionCreation, generateCollectionPermissions, generateCollectionRules, generateDownMigration, generateFieldAddition, generateFieldDefinitionObject, generateFieldDeletion, generateFieldModification, generateFieldsArray, generateIndexesArray, executeGenerate as generateMigration, generateMigrationDescription, generateMigrationFilename, generatePermissionUpdate, generateTimestamp, generateUpMigration, geoPointField, getArrayElementType, getCollectionNameFromFile, getDefaultValue, getFieldTypeInfo, getMaxSelect, executeStatus as getMigrationStatus, getMinSelect, getSnapshotPath, getSnapshotVersion, getUsersSystemFields, importSchemaModule, inputImageFileSchema, isArrayType, isAuthCollection, isEditorField, isFieldRequired, isFileFieldByName, isGeoPointType, isMultipleRelationField, isPermissionSchema, isRelationField, isSingleRelationField, isSystemCollection, isTemplateConfig, jsonField, loadBaseMigration, loadConfig, loadSnapshot, loadSnapshotIfExists, loadSnapshotWithMigrations, logError, logInfo, logSection, logSuccess, logWarning, mapZodArrayType, mapZodBooleanType, mapZodDateType, mapZodEnumType, mapZodNumberType, mapZodRecordType, mapZodStringType, mapZodTypeToPocketBase, matchCollectionsByName, matchFieldsByName, mergePermissions, mergeSnapshots, numberField, omitImageFilesSchema, parseSchemaFiles, pluralize, requiresForceFlag, resolveTargetCollection, resolveTemplate, saveSnapshot, selectField, selectSchemaForCollection, singularize, snapshotExists, textField, toCollectionName, unwrapZodType, urlField, validatePermissionConfig, validateRuleExpression, validateSnapshot, withIndexes, withPermissions, withProgress, writeMigrationFile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map