@magnet-cms/common 0.1.1 → 0.3.0

package/dist/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
 require('reflect-metadata');
+var common = require('@nestjs/common');
 var fs = require('fs');
 var path = require('path');
-var common = require('@nestjs/common');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -13,6 +13,21 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var EVENT_HANDLER_METADATA = "magnet:event_handler";
+function OnEvent(event, options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const metadata = {
+      event,
+      options
+    };
+    common.SetMetadata(EVENT_HANDLER_METADATA, metadata)(target, propertyKey, descriptor);
+    return descriptor;
+  };
+}
+__name(OnEvent, "OnEvent");
+var Validators = /* @__PURE__ */ __name((...validators) => {
+  return common.applyDecorators(...validators);
+}, "Validators");
 
 // src/constants.ts
 var RESOLVER_METADATA_KEY = "magnet:resolver";
@@ -22,13 +37,936 @@ var SCHEMA_OPTIONS_METADATA_KEY = "magnet:schema:options";
 var BASE_SCHEMA_METADATA_KEY = "magnet:schema:base";
 var PROP_METADATA_KEY = "magnet:schema:prop";
 var UI_METADATA_KEY = "magnet:schema:ui";
+var FIELD_METADATA_KEY = "magnet:schema:field";
 var SETTING_METADATA_KEY = "magnet:setting";
+var SETTINGS_OPTIONS_METADATA_KEY = "magnet:settings:options";
+var SETTING_FIELD_METADATA_KEY = "magnet:settings:field";
+var EXTEND_USER_METADATA_KEY = "magnet:extend:user";
+var PERMISSION_METADATA_KEY = "magnet:permission";
+var PERMISSION_OPTIONS_METADATA_KEY = "magnet:permission:options";
+var RESOLVED_PERMISSION_KEY = "magnet:permission:resolved";
 var INJECT_MODEL = "magnet:inject:model";
 var DESIGN_TYPE = "design:type";
 var DESIGN_META = "design:metadata";
 var DESIGN_PARAM_TYPES = "design:paramtypes";
 var DESIGN_RETURN_TYPE = "design:returntype";
 
+// src/utils/database-adapter-singleton-for-feature.util.ts
+var GETTER_KEY = Symbol.for("@magnet-cms/common/database-adapter-singleton-for-feature");
+function getGetterSlot() {
+  const g = globalThis;
+  return g[GETTER_KEY] ?? null;
+}
+__name(getGetterSlot, "getGetterSlot");
+function setGetterSlot(getter) {
+  const g = globalThis;
+  g[GETTER_KEY] = getter;
+}
+__name(setGetterSlot, "setGetterSlot");
+function registerDatabaseAdapterSingletonForFeature(getter) {
+  setGetterSlot(getter);
+}
+__name(registerDatabaseAdapterSingletonForFeature, "registerDatabaseAdapterSingletonForFeature");
+function getDatabaseAdapterSingletonForFeature() {
+  const databaseAdapterSingletonGetter = getGetterSlot();
+  if (!databaseAdapterSingletonGetter) return null;
+  try {
+    return databaseAdapterSingletonGetter();
+  } catch {
+    return null;
+  }
+}
+__name(getDatabaseAdapterSingletonForFeature, "getDatabaseAdapterSingletonForFeature");
+function clearDatabaseAdapterSingletonForFeature() {
+  setGetterSlot(null);
+}
+__name(clearDatabaseAdapterSingletonForFeature, "clearDatabaseAdapterSingletonForFeature");
+var cachedAdapter = null;
+function isPackageInstalled(packageName) {
+  try {
+    return fs.existsSync(path.join(__require.resolve(packageName), "../../"));
+  } catch {
+    return false;
+  }
+}
+__name(isPackageInstalled, "isPackageInstalled");
+function detectDatabaseAdapter(dbConfig) {
+  if (dbConfig) {
+    if ("connectionString" in dbConfig || "dialect" in dbConfig) {
+      cachedAdapter = "drizzle";
+      return cachedAdapter;
+    }
+    if ("uri" in dbConfig) {
+      cachedAdapter = "mongoose";
+      return cachedAdapter;
+    }
+  }
+  if (cachedAdapter) return cachedAdapter;
+  if (isPackageInstalled("@magnet-cms/adapter-db-mongoose")) {
+    cachedAdapter = "mongoose";
+  } else if (isPackageInstalled("@magnet-cms/adapter-db-drizzle")) {
+    cachedAdapter = "drizzle";
+  } else {
+    throw new Error("\u274C No supported database adapter found. Install @magnet-cms/adapter-db-mongoose or @magnet-cms/adapter-db-drizzle.");
+  }
+  return cachedAdapter;
+}
+__name(detectDatabaseAdapter, "detectDatabaseAdapter");
+function setDatabaseAdapter(adapter) {
+  cachedAdapter = adapter;
+}
+__name(setDatabaseAdapter, "setDatabaseAdapter");
+function clearAdapterCache() {
+  cachedAdapter = null;
+}
+__name(clearAdapterCache, "clearAdapterCache");
+
+// src/utils/get-model-token.util.ts
+function getModelToken(schema) {
+  const name = typeof schema === "string" ? schema : schema.name;
+  return `MAGNET_MODEL_${name.toUpperCase()}`;
+}
+__name(getModelToken, "getModelToken");
+function getAdapterToken() {
+  return "MAGNET_DATABASE_ADAPTER";
+}
+__name(getAdapterToken, "getAdapterToken");
+var globalModelRegistry = /* @__PURE__ */ new Map();
+function registerModel(token, model) {
+  globalModelRegistry.set(token, model);
+}
+__name(registerModel, "registerModel");
+function getRegisteredModel(token) {
+  return globalModelRegistry.get(token);
+}
+__name(getRegisteredModel, "getRegisteredModel");
+
+// src/utils/get-schema-token.util.ts
+var getSchemaToken = /* @__PURE__ */ __name((schema) => {
+  return `${schema.name}Schema`;
+}, "getSchemaToken");
+var getSettingToken = /* @__PURE__ */ __name((setting) => {
+  return `${setting.name}Setting`;
+}, "getSettingToken");
+
+// src/utils/type-guards.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObject, "isObject");
+function hasProperty(value, key) {
+  return isObject(value) && key in value;
+}
+__name(hasProperty, "hasProperty");
+function hasProperties(value, keys) {
+  return isObject(value) && keys.every((key) => key in value);
+}
+__name(hasProperties, "hasProperties");
+function isString(value) {
+  return typeof value === "string";
+}
+__name(isString, "isString");
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+__name(isNumber, "isNumber");
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+__name(isBoolean, "isBoolean");
+function isArray(value) {
+  return Array.isArray(value);
+}
+__name(isArray, "isArray");
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+__name(isStringArray, "isStringArray");
+function isFunction(value) {
+  return typeof value === "function";
+}
+__name(isFunction, "isFunction");
+function isDocument(value) {
+  return isObject(value) && hasProperty(value, "id") && typeof value.id === "string";
+}
+__name(isDocument, "isDocument");
+function isCastError(error) {
+  return isObject(error) && hasProperty(error, "name") && error.name === "CastError" && hasProperty(error, "path") && typeof error.path === "string";
+}
+__name(isCastError, "isCastError");
+function isDuplicateKeyError(error) {
+  return isObject(error) && hasProperty(error, "code") && error.code === 11e3;
+}
+__name(isDuplicateKeyError, "isDuplicateKeyError");
+function isValidationError(error) {
+  return isObject(error) && hasProperty(error, "name") && error.name === "ValidationError" && hasProperty(error, "errors");
+}
+__name(isValidationError, "isValidationError");
+function isPostgresUniqueError(error) {
+  return isObject(error) && hasProperty(error, "code") && error.code === "23505";
+}
+__name(isPostgresUniqueError, "isPostgresUniqueError");
+function hasMethod(value, methodName) {
+  return isObject(value) && hasProperty(value, methodName) && typeof value[methodName] === "function";
+}
+__name(hasMethod, "hasMethod");
+function hasSetLocale(value) {
+  return isObject(value) && hasMethod(value, "setLocale");
+}
+__name(hasSetLocale, "hasSetLocale");
+function hasToString(value) {
+  return isObject(value) && hasMethod(value, "toString");
+}
+__name(hasToString, "hasToString");
+function assertDefined(value, message) {
+  if (value === null || value === void 0) {
+    throw new Error(message ?? "Value is null or undefined");
+  }
+}
+__name(assertDefined, "assertDefined");
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message ?? "Assertion failed");
+  }
+}
+__name(assert, "assert");
+function getDocumentId(doc) {
+  if (!isObject(doc)) return void 0;
+  if (hasProperty(doc, "id") && typeof doc.id === "string") {
+    return doc.id;
+  }
+  if (hasProperty(doc, "_id")) {
+    if (typeof doc._id === "string") {
+      return doc._id;
+    }
+    if (hasToString(doc._id)) {
+      return doc._id.toString();
+    }
+  }
+  return void 0;
+}
+__name(getDocumentId, "getDocumentId");
+function isStringRecord(value) {
+  if (!isObject(value)) return false;
+  return Object.values(value).every((v) => typeof v === "string");
+}
+__name(isStringRecord, "isStringRecord");
+function isVersionDocument(value) {
+  return isObject(value) && hasProperty(value, "documentId") && typeof value.documentId === "string" && hasProperty(value, "versionId") && typeof value.versionId === "string" && hasProperty(value, "schemaName") && typeof value.schemaName === "string" && hasProperty(value, "status") && hasProperty(value, "data") && isObject(value.data);
+}
+__name(isVersionDocument, "isVersionDocument");
+
+// src/decorators/field/field.prop-mapper.ts
+function isPropDefaultValue(value) {
+  if (value === null) return true;
+  if (typeof value === "string") return true;
+  if (typeof value === "number") return true;
+  if (typeof value === "boolean") return true;
+  if (typeof value === "function") return true;
+  if (Array.isArray(value)) return true;
+  if (typeof value === "object") return true;
+  return false;
+}
+__name(isPropDefaultValue, "isPropDefaultValue");
+function mapFieldTypeToProp(type, options) {
+  const propOptions = {
+    required: options.required,
+    unique: options.unique,
+    default: isPropDefaultValue(options.default) ? options.default : void 0,
+    hidden: options.hidden,
+    readonly: options.readonly,
+    description: options.description
+  };
+  switch (type) {
+    case "text":
+    case "email":
+    case "url":
+    case "phone":
+    case "address":
+    case "color":
+    case "slug":
+    case "textarea":
+    case "markdown":
+    case "code":
+      propOptions.type = String;
+      break;
+    case "number":
+      propOptions.type = Number;
+      break;
+    case "boolean":
+      propOptions.type = Boolean;
+      break;
+    case "date":
+    case "datetime":
+      propOptions.type = Date;
+      break;
+    case "richtext":
+      propOptions.type = String;
+      break;
+    case "json":
+    case "object":
+      propOptions.type = Object;
+      break;
+    case "select":
+    case "enum":
+      propOptions.type = String;
+      break;
+    case "tags":
+      propOptions.type = [
+        String
+      ];
+      break;
+    case "image":
+    case "file":
+      propOptions.type = String;
+      break;
+    case "gallery":
+      propOptions.type = [
+        String
+      ];
+      break;
+    case "array":
+      propOptions.type = Array;
+      break;
+    case "blocks":
+      propOptions.type = Array;
+      break;
+    case "relationship": {
+      const relOptions = options;
+      propOptions.ref = relOptions.ref;
+      if (relOptions.multiple) {
+        propOptions.type = [
+          String
+        ];
+      } else {
+        propOptions.type = String;
+      }
+      break;
+    }
+    default: {
+      const _exhaustiveCheck = type;
+      throw new Error(`Unknown field type: ${_exhaustiveCheck}`);
+    }
+  }
+  return Object.fromEntries(Object.entries(propOptions).filter(([, value]) => value !== void 0));
+}
+__name(mapFieldTypeToProp, "mapFieldTypeToProp");
+
+// src/decorators/field/field.ui-mapper.ts
+function mapFieldTypeToUIType(type) {
+  const typeMap = {
+    text: "text",
+    number: "number",
+    boolean: "switch",
+    date: "date",
+    datetime: "date",
+    richtext: "richText",
+    markdown: "textarea",
+    code: "code",
+    json: "json",
+    select: "select",
+    enum: "select",
+    tags: "multiSelect",
+    image: "upload",
+    file: "fileUpload",
+    gallery: "upload",
+    slug: "text",
+    email: "email",
+    url: "text",
+    phone: "phone",
+    address: "text",
+    color: "text",
+    object: "json",
+    array: "array",
+    blocks: "blocks",
+    relationship: "relationship",
+    textarea: "textarea"
+  };
+  return typeMap[type];
+}
+__name(mapFieldTypeToUIType, "mapFieldTypeToUIType");
+function convertToUISelectItems(options) {
+  return options.map((opt) => {
+    if (typeof opt === "object" && opt !== null && "label" in opt && "value" in opt) {
+      return {
+        key: String(opt.value),
+        value: opt.label
+      };
+    }
+    return {
+      key: String(opt),
+      value: String(opt)
+    };
+  });
+}
+__name(convertToUISelectItems, "convertToUISelectItems");
+function convertEnumToUISelectItems(enumObj) {
+  return Object.entries(enumObj).filter(([key]) => Number.isNaN(Number(key))).map(([key, value]) => ({
+    key: String(value),
+    value: key
+  }));
+}
+__name(convertEnumToUISelectItems, "convertEnumToUISelectItems");
+function toUIDecoratorOptions(internal) {
+  if (internal.side) {
+    return {
+      type: internal.type,
+      label: internal.label,
+      description: internal.description,
+      side: true,
+      options: internal.options
+    };
+  }
+  const result = {
+    type: internal.type,
+    label: internal.label,
+    description: internal.description,
+    tab: internal.tab ?? "General"
+  };
+  if (internal.options) {
+    result.options = internal.options;
+  }
+  return result;
+}
+__name(toUIDecoratorOptions, "toUIDecoratorOptions");
+function mapFieldTypeToUI(type, options) {
+  const uiType = mapFieldTypeToUIType(type);
+  const internal = {
+    type: uiType,
+    label: options.label,
+    description: options.description,
+    tab: options.tab,
+    side: options.side ? true : void 0
+  };
+  switch (type) {
+    case "select": {
+      const selectOpts = options;
+      return toUIDecoratorOptions({
+        ...internal,
+        type: selectOpts.multiple ? "multiSelect" : "select",
+        options: convertToUISelectItems(selectOpts.options)
+      });
+    }
+    case "enum": {
+      const enumOpts = options;
+      return toUIDecoratorOptions({
+        ...internal,
+        type: enumOpts.multiple ? "multiSelect" : "select",
+        options: convertEnumToUISelectItems(enumOpts.enum)
+      });
+    }
+    case "boolean": {
+      const boolOpts = options;
+      return toUIDecoratorOptions({
+        ...internal,
+        type: boolOpts.style === "checkbox" ? "checkbox" : "switch"
+      });
+    }
+    case "richtext": {
+      return toUIDecoratorOptions({
+        ...internal,
+        type: "richText"
+      });
+    }
+    case "code": {
+      return toUIDecoratorOptions({
+        ...internal,
+        type: "code"
+      });
+    }
+    case "tags": {
+      const tagsOpts = options;
+      return toUIDecoratorOptions({
+        ...internal,
+        type: "multiSelect",
+        options: tagsOpts.suggestions?.map((s) => ({
+          key: s,
+          value: s
+        })) ?? []
+      });
+    }
+    default:
+      return toUIDecoratorOptions(internal);
+  }
+}
+__name(mapFieldTypeToUI, "mapFieldTypeToUI");
+
+// src/decorators/field/field.factory.ts
+function createFieldDecorator(type, defaultOptions = {}) {
+  return (options) => {
+    const mergedOptions = {
+      ...defaultOptions,
+      ...options
+    };
+    return (target, propertyKey) => {
+      const designType = Reflect.getMetadata(DESIGN_TYPE, target, propertyKey);
+      const metadata = {
+        type,
+        options: mergedOptions,
+        propertyKey,
+        target: target.constructor,
+        designType
+      };
+      const existingFields = Reflect.getMetadata(FIELD_METADATA_KEY, target.constructor) ?? [];
+      const filteredFields = existingFields.filter((f) => f.propertyKey !== propertyKey);
+      Reflect.defineMetadata(FIELD_METADATA_KEY, [
+        ...filteredFields,
+        metadata
+      ], target.constructor);
+      emitLegacyPropMetadata(target, propertyKey, type, mergedOptions);
+      emitLegacyUIMetadata(target, propertyKey, type, mergedOptions, designType);
+      applyAdapterProp(target, propertyKey, type, mergedOptions);
+    };
+  };
+}
+__name(createFieldDecorator, "createFieldDecorator");
+function emitLegacyPropMetadata(target, propertyKey, type, options) {
+  const propOptions = mapFieldTypeToProp(type, options);
+  const existingProps = Reflect.getMetadata(PROP_METADATA_KEY, target) ?? [];
+  const filteredProps = existingProps.filter((p) => p.propertyKey !== propertyKey);
+  Reflect.defineMetadata(PROP_METADATA_KEY, [
+    ...filteredProps,
+    {
+      propertyKey,
+      options: propOptions
+    }
+  ], target);
+}
+__name(emitLegacyPropMetadata, "emitLegacyPropMetadata");
+function emitLegacyUIMetadata(target, propertyKey, type, options, designType) {
+  const uiOptions = mapFieldTypeToUI(type, options);
+  const existingUI = Reflect.getMetadata(UI_METADATA_KEY, target) ?? [];
+  const filteredUI = existingUI.filter((u) => u.propertyKey !== propertyKey);
+  Reflect.defineMetadata(UI_METADATA_KEY, [
+    ...filteredUI,
+    {
+      propertyKey,
+      options: {
+        ...uiOptions,
+        designType
+      }
+    }
+  ], target);
+}
+__name(emitLegacyUIMetadata, "emitLegacyUIMetadata");
+function applyAdapterProp(target, propertyKey, type, options) {
+  try {
+    const adapter = detectDatabaseAdapter();
+    const propOptions = mapFieldTypeToProp(type, options);
+    const { Prop: Prop2 } = __require(`@magnet-cms/adapter-db-${adapter}`);
+    Prop2(propOptions)(target, propertyKey);
+  } catch {
+  }
+}
+__name(applyAdapterProp, "applyAdapterProp");
+function getFieldMetadata(target) {
+  return Reflect.getMetadata(FIELD_METADATA_KEY, target) ?? [];
+}
+__name(getFieldMetadata, "getFieldMetadata");
+function getFieldMetadataForProperty(target, propertyKey) {
+  const fields = getFieldMetadata(target);
+  return fields.find((f) => f.propertyKey === propertyKey);
+}
+__name(getFieldMetadataForProperty, "getFieldMetadataForProperty");
+
+// src/types/field.types.ts
+function isFieldMetadata(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const metadata = value;
+  return typeof metadata.type === "string" && typeof metadata.options === "object" && metadata.options !== null && "propertyKey" in metadata;
+}
+__name(isFieldMetadata, "isFieldMetadata");
+function isValidFieldType(type) {
+  const validTypes = [
+    "text",
+    "number",
+    "boolean",
+    "date",
+    "datetime",
+    "richtext",
+    "markdown",
+    "code",
+    "json",
+    "select",
+    "enum",
+    "tags",
+    "image",
+    "file",
+    "gallery",
+    "slug",
+    "email",
+    "url",
+    "phone",
+    "address",
+    "color",
+    "object",
+    "array",
+    "blocks",
+    "relationship",
+    "textarea"
+  ];
+  return typeof type === "string" && validTypes.includes(type);
+}
+__name(isValidFieldType, "isValidFieldType");
+
+// src/decorators/field/index.ts
+var Field = {
+  // ============================================
+  // PRIMITIVES
+  // ============================================
+  /**
+  * Text field - single line text input
+  *
+  * @example
+  * ```typescript
+  * @Field.Text({ required: true, maxLength: 200 })
+  * title: string
+  * ```
+  */
+  Text: createFieldDecorator("text"),
+  /**
+  * Number field - numeric input
+  *
+  * @example
+  * ```typescript
+  * @Field.Number({ min: 0, max: 100, integer: true })
+  * quantity: number
+  * ```
+  */
+  Number: createFieldDecorator("number"),
+  /**
+  * Boolean field - true/false toggle
+  *
+  * @example
+  * ```typescript
+  * @Field.Boolean({ default: false, style: 'switch' })
+  * isPublished: boolean
+  * ```
+  */
+  Boolean: createFieldDecorator("boolean", {
+    style: "switch"
+  }),
+  /**
+  * Date field - date picker (without time)
+  *
+  * @example
+  * ```typescript
+  * @Field.Date({ min: '2024-01-01' })
+  * publishDate: Date
+  * ```
+  */
+  Date: createFieldDecorator("date"),
+  /**
+  * DateTime field - date and time picker
+  *
+  * @example
+  * ```typescript
+  * @Field.DateTime({ timezone: 'UTC' })
+  * scheduledAt: Date
+  * ```
+  */
+  DateTime: createFieldDecorator("datetime"),
+  // ============================================
+  // RICH CONTENT
+  // ============================================
+  /**
+  * RichText field - WYSIWYG editor
+  *
+  * @example
+  * ```typescript
+  * @Field.RichText({ toolbar: 'full' })
+  * content: string
+  * ```
+  */
+  RichText: createFieldDecorator("richtext", {
+    toolbar: "standard"
+  }),
+  /**
+  * Markdown field - markdown editor with preview
+  *
+  * @example
+  * ```typescript
+  * @Field.Markdown({ preview: true })
+  * description: string
+  * ```
+  */
+  Markdown: createFieldDecorator("markdown", {
+    preview: true
+  }),
+  /**
+  * Code field - code editor with syntax highlighting
+  *
+  * @example
+  * ```typescript
+  * @Field.Code({ language: 'typescript' })
+  * snippet: string
+  * ```
+  */
+  Code: createFieldDecorator("code"),
+  /**
+  * JSON field - JSON editor
+  *
+  * @example
+  * ```typescript
+  * @Field.JSON()
+  * metadata: Record<string, unknown>
+  * ```
+  */
+  JSON: createFieldDecorator("json"),
+  /**
+  * Textarea field - multi-line text input
+  *
+  * @example
+  * ```typescript
+  * @Field.Textarea({ rows: 5 })
+  * summary: string
+  * ```
+  */
+  Textarea: createFieldDecorator("textarea"),
+  // ============================================
+  // SELECTION
+  // ============================================
+  /**
+  * Select field - dropdown selection
+  *
+  * @example
+  * ```typescript
+  * @Field.Select({
+  *   options: [
+  *     { label: 'Draft', value: 'draft' },
+  *     { label: 'Published', value: 'published' }
+  *   ],
+  *   default: 'draft'
+  * })
+  * status: string
+  * ```
+  */
+  Select: /* @__PURE__ */ __name((options) => createFieldDecorator("select")(options), "Select"),
+  /**
+  * Enum field - dropdown from TypeScript enum
+  *
+  * @example
+  * ```typescript
+  * enum Status { Draft = 'draft', Published = 'published' }
+  *
+  * @Field.Enum({ enum: Status, default: Status.Draft })
+  * status: Status
+  * ```
+  */
+  Enum: /* @__PURE__ */ __name((options) => createFieldDecorator("enum")(options), "Enum"),
+  /**
+  * Tags field - multi-value tag input
+  *
+  * @example
+  * ```typescript
+  * @Field.Tags({ suggestions: ['tech', 'news'], maxTags: 5 })
+  * tags: string[]
+  * ```
+  */
+  Tags: createFieldDecorator("tags"),
+  // ============================================
+  // MEDIA
+  // ============================================
+  /**
+  * Image field - single image upload
+  *
+  * @example
+  * ```typescript
+  * @Field.Image({ folder: 'covers', formats: ['jpg', 'png', 'webp'] })
+  * coverImage: string
+  * ```
+  */
+  Image: createFieldDecorator("image"),
+  /**
+  * File field - single file upload
+  *
+  * @example
+  * ```typescript
+  * @Field.File({ folder: 'documents', accept: ['application/pdf'] })
+  * attachment: string
+  * ```
+  */
+  File: createFieldDecorator("file"),
+  /**
+  * Gallery field - multiple image upload
+  *
+  * @example
+  * ```typescript
+  * @Field.Gallery({ maxItems: 10 })
+  * images: string[]
+  * ```
+  */
+  Gallery: createFieldDecorator("gallery"),
+  // ============================================
+  // SPECIAL
+  // ============================================
+  /**
+  * Slug field - auto-generated URL-friendly string
+  *
+  * @example
+  * ```typescript
+  * @Field.Slug({ from: 'title', unique: true })
+  * slug: string
+  * ```
+  */
+  Slug: createFieldDecorator("slug"),
+  /**
+  * Email field - email input with validation pattern
+  *
+  * @example
+  * ```typescript
+  * @Field.Email({ required: true })
+  * @Field.Validators(IsEmail())
+  * email: string
+  * ```
+  */
+  Email: createFieldDecorator("email", {
+    pattern: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$"
+  }),
+  /**
+  * URL field - URL input
+  *
+  * @example
+  * ```typescript
+  * @Field.URL({ protocols: ['https'] })
+  * @Field.Validators(IsUrl())
+  * website: string
+  * ```
+  */
+  URL: createFieldDecorator("url"),
+  /**
+  * Phone field - phone number input
+  *
+  * @example
+  * ```typescript
+  * @Field.Phone({ defaultCountry: 'US' })
+  * phone: string
+  * ```
+  */
+  Phone: createFieldDecorator("phone"),
+  /**
+  * Address field - address input with optional geocoding
+  *
+  * @example
+  * ```typescript
+  * @Field.Address({ provider: 'google' })
+  * address: string
+  * ```
+  */
+  Address: createFieldDecorator("address"),
+  /**
+  * Color field - color picker
+  *
+  * @example
+  * ```typescript
+  * @Field.Color({ format: 'hex', presets: ['#ff0000', '#00ff00'] })
+  * brandColor: string
+  * ```
+  */
+  Color: createFieldDecorator("color", {
+    format: "hex"
+  }),
+  // ============================================
+  // COMPOSITION
+  // ============================================
+  /**
+  * Object field - nested object structure
+  *
+  * @example
+  * ```typescript
+  * @Field.Object()
+  * metadata: { key: string; value: string }
+  * ```
+  */
+  Object: createFieldDecorator("object"),
+  /**
+  * Array field - array of items
+  *
+  * @example
+  * ```typescript
+  * @Field.Array({ of: { type: 'text' }, maxItems: 10 })
+  * items: string[]
+  * ```
+  */
+  Array: /* @__PURE__ */ __name((options) => createFieldDecorator("array")(options), "Array"),
+  /**
+  * Blocks field - flexible content blocks
+  *
+  * @example
+  * ```typescript
+  * @Field.Blocks({ types: ['paragraph', 'image', 'quote'] })
+  * content: Block[]
+  * ```
+  */
+  Blocks: createFieldDecorator("blocks"),
+  /**
+  * Relationship field - reference to another schema
+  *
+  * @example
+  * ```typescript
+  * @Field.Relationship({ ref: 'users', multiple: false })
+  * author: string
+  *
+  * @Field.Relationship({ ref: 'categories', multiple: true })
+  * categories: string[]
+  * ```
+  */
+  Relationship: createFieldDecorator("relationship"),
+  // ============================================
+  // VALIDATION
+  // ============================================
+  /**
+  * Validators - apply class-validator decorators
+  *
+  * This is an alias for the existing @Validators decorator,
+  * keeping validation explicit and using familiar class-validator syntax.
+  *
+  * @example
+  * ```typescript
+  * @Field.Text({ required: true })
+  * @Field.Validators(IsString(), Length(1, 200), IsNotEmpty())
+  * title: string
+  * ```
+  */
+  Validators
+};
+function RequirePermission(options) {
+  return (target, propertyKey, descriptor) => {
+    common.SetMetadata(PERMISSION_METADATA_KEY, options)(target, propertyKey, descriptor);
+    return descriptor;
+  };
+}
+__name(RequirePermission, "RequirePermission");
+function HasPermission(permission) {
+  return (target, propertyKey, descriptor) => {
+    const options = {
+      id: permission,
+      name: permission.split(".").pop() ?? permission,
+      description: `Requires ${permission} permission`
+    };
+    common.SetMetadata(PERMISSION_METADATA_KEY, options)(target, propertyKey, descriptor);
+    return descriptor;
+  };
+}
+__name(HasPermission, "HasPermission");
+function PermissionMeta(options) {
+  return (target, propertyKey, descriptor) => {
+    common.SetMetadata(PERMISSION_OPTIONS_METADATA_KEY, options)(target, propertyKey, descriptor);
+    return descriptor;
+  };
+}
+__name(PermissionMeta, "PermissionMeta");
+function getPermissionMetadata(target, propertyKey) {
+  return Reflect.getMetadata(PERMISSION_METADATA_KEY, target, propertyKey);
+}
+__name(getPermissionMetadata, "getPermissionMetadata");
+function hasPermissionDecorator(target, propertyKey) {
+  return Reflect.hasMetadata(PERMISSION_METADATA_KEY, target, propertyKey);
+}
+__name(hasPermissionDecorator, "hasPermissionDecorator");
+
 // src/decorators/resolver/resolver.decorator.ts
 function Resolver(optionsOrFn) {
   return (target) => {
@@ -83,59 +1021,36 @@ function Resolve(optionsOrFn) {
   };
 }
 __name(Resolve, "Resolve");
-var cachedAdapter = null;
-function isPackageInstalled(packageName) {
-  try {
-    return fs.existsSync(path.join(__require.resolve(packageName), "../../"));
-  } catch {
-    return false;
-  }
-}
-__name(isPackageInstalled, "isPackageInstalled");
-function detectDatabaseAdapter(dbConfig) {
-  if (dbConfig) {
-    if ("connectionString" in dbConfig || "dialect" in dbConfig) {
-      cachedAdapter = "drizzle";
-      return cachedAdapter;
-    }
-    if ("uri" in dbConfig) {
-      cachedAdapter = "mongoose";
-      return cachedAdapter;
+
+// src/decorators/schema/extend-user.decorator.ts
+function ExtendUser(options = {}) {
+  const mergedOptions = {
+    timestamps: true,
+    ...options
+  };
+  return (target) => {
+    Reflect.defineMetadata(EXTEND_USER_METADATA_KEY, mergedOptions, target);
+    Reflect.defineMetadata(SCHEMA_METADATA_KEY, true, target);
+    try {
+      const adapter = detectDatabaseAdapter();
+      const { Schema: Schema2 } = __require(`@magnet-cms/adapter-db-${adapter}`);
+      Schema2({
+        collection: "users",
+        timestamps: mergedOptions.timestamps
+      })(target);
+    } catch {
     }
-  }
-  if (cachedAdapter) return cachedAdapter;
-  if (isPackageInstalled("@magnet-cms/adapter-mongoose")) {
-    cachedAdapter = "mongoose";
-  } else if (isPackageInstalled("@magnet-cms/adapter-drizzle")) {
-    cachedAdapter = "drizzle";
-  } else {
-    throw new Error("\u274C No supported database adapter found. Install @magnet-cms/adapter-mongoose or @magnet-cms/adapter-drizzle.");
-  }
-  return cachedAdapter;
+  };
 }
-__name(detectDatabaseAdapter, "detectDatabaseAdapter");
-function setDatabaseAdapter(adapter) {
-  cachedAdapter = adapter;
+__name(ExtendUser, "ExtendUser");
+function isUserExtension(target) {
+  return Reflect.hasMetadata(EXTEND_USER_METADATA_KEY, target);
 }
-__name(setDatabaseAdapter, "setDatabaseAdapter");
-function clearAdapterCache() {
-  cachedAdapter = null;
+__name(isUserExtension, "isUserExtension");
+function getExtendUserOptions(target) {
+  return Reflect.getMetadata(EXTEND_USER_METADATA_KEY, target);
 }
-__name(clearAdapterCache, "clearAdapterCache");
-
-// src/utils/get-model-token.util.ts
-function getModelToken(schema) {
-  return `Magnet${schema.name}Model`;
-}
-__name(getModelToken, "getModelToken");
-
-// src/utils/get-schema-token.util.ts
-var getSchemaToken = /* @__PURE__ */ __name((schema) => {
-  return `${schema.name}Schema`;
-}, "getSchemaToken");
-var getSettingToken = /* @__PURE__ */ __name((setting) => {
-  return `${setting.name}Setting`;
-}, "getSettingToken");
+__name(getExtendUserOptions, "getExtendUserOptions");
 
 // src/decorators/schema/prop.decorator.ts
 function Prop(options) {
@@ -149,7 +1064,7 @@ function Prop(options) {
         options
       }
     ], target);
-    const { Prop: Prop2 } = __require(`@magnet-cms/adapter-${adapter}`);
+    const { Prop: Prop2 } = __require(`@magnet-cms/adapter-db-${adapter}`);
     return Prop2(options)(target, propertyKey);
   };
 }
@@ -158,7 +1073,8 @@ __name(Prop, "Prop");
 // src/decorators/schema/schema.decorator.ts
 var defaultSchemaOptions = {
   versioning: true,
-  i18n: true
+  i18n: true,
+  visible: true
 };
 function Schema(options = {}) {
   return (target) => {
@@ -169,7 +1085,7 @@ function Schema(options = {}) {
     };
     Reflect.defineMetadata(SCHEMA_METADATA_KEY, true, target);
     Reflect.defineMetadata(SCHEMA_OPTIONS_METADATA_KEY, mergedOptions, target);
-    const { Schema: Schema2 } = __require(`@magnet-cms/adapter-${adapter}`);
+    const { Schema: Schema2 } = __require(`@magnet-cms/adapter-db-${adapter}`);
     return Schema2()(target);
   };
 }
@@ -187,6 +1103,81 @@ function Setting() {
 }
 __name(Setting, "Setting");
 
+// src/decorators/schema/settings.decorator.ts
+function Settings(options) {
+  return (target) => {
+    Reflect.defineMetadata(SETTING_METADATA_KEY, true, target);
+    Reflect.defineMetadata(SETTINGS_OPTIONS_METADATA_KEY, options, target);
+  };
+}
+__name(Settings, "Settings");
+function getSettingsOptions(target) {
+  return Reflect.getMetadata(SETTINGS_OPTIONS_METADATA_KEY, target);
+}
+__name(getSettingsOptions, "getSettingsOptions");
+function getSettingFields(target) {
+  return Reflect.getMetadata(SETTING_FIELD_METADATA_KEY, target) ?? [];
+}
+__name(getSettingFields, "getSettingFields");
+function createSettingFieldDecorator(type, defaultOptions = {}) {
+  return (options) => {
+    const mergedOptions = {
+      ...defaultOptions,
+      ...options
+    };
+    return (target, propertyKey) => {
+      const metadata = {
+        type,
+        options: mergedOptions,
+        propertyKey
+      };
+      const existingFields = Reflect.getMetadata(SETTING_FIELD_METADATA_KEY, target.constructor) ?? [];
+      const filteredFields = existingFields.filter((f) => f.propertyKey !== propertyKey);
+      Reflect.defineMetadata(SETTING_FIELD_METADATA_KEY, [
+        ...filteredFields,
+        metadata
+      ], target.constructor);
+    };
+  };
+}
+__name(createSettingFieldDecorator, "createSettingFieldDecorator");
+var SettingField = {
+  /**
+  * Text setting field
+  */
+  Text: createSettingFieldDecorator("text"),
+  /**
+  * Number setting field
+  */
+  Number: createSettingFieldDecorator("number"),
+  /**
+  * Boolean setting field (toggle/switch)
+  */
+  Boolean: createSettingFieldDecorator("boolean"),
+  /**
+  * Select setting field (dropdown)
+  */
+  Select: createSettingFieldDecorator("select"),
+  /**
+  * Secret setting field (encrypted, masked in UI)
+  */
+  Secret: createSettingFieldDecorator("secret", {
+    masked: true
+  }),
+  /**
+  * Image setting field
+  */
+  Image: createSettingFieldDecorator("image"),
+  /**
+  * JSON setting field
+  */
+  JSON: createSettingFieldDecorator("json"),
+  /**
+  * Textarea setting field (multi-line text)
+  */
+  Textarea: createSettingFieldDecorator("textarea")
+};
+
 // src/decorators/schema/ui.decorator.ts
 function UI(options) {
   return (target, propertyKey) => {
@@ -205,9 +1196,6 @@ function UI(options) {
   };
 }
 __name(UI, "UI");
-var Validators = /* @__PURE__ */ __name((...validators) => {
-  return common.applyDecorators(...validators);
-}, "Validators");
 
 // src/decorators/schema/version.decorator.ts
 var VERSION_METADATA_KEY = "version:metadata";
@@ -225,12 +1213,643 @@ function InjectModel(model) {
     if (propertyKey !== void 0) {
       Reflect.defineMetadata(INJECT_MODEL, model, target, propertyKey);
     }
-    const { InjectModel: InjectModel2 } = __require(`@magnet-cms/adapter-${adapter}`);
+    const { InjectModel: InjectModel2 } = __require(`@magnet-cms/adapter-db-${adapter}`);
     return InjectModel2(model)(target, propertyKey, parameterIndex);
   };
 }
 __name(InjectModel, "InjectModel");
 
+// src/errors/base.error.ts
+var ErrorCode = /* @__PURE__ */ function(ErrorCode2) {
+  ErrorCode2[ErrorCode2["VALIDATION_FAILED"] = 1e3] = "VALIDATION_FAILED";
+  ErrorCode2[ErrorCode2["REQUIRED_FIELD_MISSING"] = 1001] = "REQUIRED_FIELD_MISSING";
+  ErrorCode2[ErrorCode2["INVALID_FORMAT"] = 1002] = "INVALID_FORMAT";
+  ErrorCode2[ErrorCode2["VALUE_OUT_OF_RANGE"] = 1003] = "VALUE_OUT_OF_RANGE";
+  ErrorCode2[ErrorCode2["UNIQUE_CONSTRAINT_VIOLATION"] = 1004] = "UNIQUE_CONSTRAINT_VIOLATION";
+  ErrorCode2[ErrorCode2["AUTHENTICATION_REQUIRED"] = 2e3] = "AUTHENTICATION_REQUIRED";
+  ErrorCode2[ErrorCode2["INVALID_CREDENTIALS"] = 2001] = "INVALID_CREDENTIALS";
+  ErrorCode2[ErrorCode2["TOKEN_EXPIRED"] = 2002] = "TOKEN_EXPIRED";
+  ErrorCode2[ErrorCode2["TOKEN_INVALID"] = 2003] = "TOKEN_INVALID";
+  ErrorCode2[ErrorCode2["ACCOUNT_LOCKED"] = 2004] = "ACCOUNT_LOCKED";
+  ErrorCode2[ErrorCode2["EMAIL_NOT_VERIFIED"] = 2005] = "EMAIL_NOT_VERIFIED";
+  ErrorCode2[ErrorCode2["PERMISSION_DENIED"] = 3e3] = "PERMISSION_DENIED";
+  ErrorCode2[ErrorCode2["INSUFFICIENT_PERMISSIONS"] = 3001] = "INSUFFICIENT_PERMISSIONS";
+  ErrorCode2[ErrorCode2["ROLE_NOT_FOUND"] = 3002] = "ROLE_NOT_FOUND";
+  ErrorCode2[ErrorCode2["PERMISSION_NOT_FOUND"] = 3003] = "PERMISSION_NOT_FOUND";
+  ErrorCode2[ErrorCode2["RESOURCE_NOT_FOUND"] = 4e3] = "RESOURCE_NOT_FOUND";
+  ErrorCode2[ErrorCode2["SCHEMA_NOT_FOUND"] = 4001] = "SCHEMA_NOT_FOUND";
+  ErrorCode2[ErrorCode2["DOCUMENT_NOT_FOUND"] = 4002] = "DOCUMENT_NOT_FOUND";
+  ErrorCode2[ErrorCode2["USER_NOT_FOUND"] = 4003] = "USER_NOT_FOUND";
+  ErrorCode2[ErrorCode2["FILE_NOT_FOUND"] = 4004] = "FILE_NOT_FOUND";
+  ErrorCode2[ErrorCode2["VERSION_NOT_FOUND"] = 4005] = "VERSION_NOT_FOUND";
+  ErrorCode2[ErrorCode2["DATABASE_ERROR"] = 5e3] = "DATABASE_ERROR";
+  ErrorCode2[ErrorCode2["CONNECTION_FAILED"] = 5001] = "CONNECTION_FAILED";
+  ErrorCode2[ErrorCode2["QUERY_FAILED"] = 5002] = "QUERY_FAILED";
+  ErrorCode2[ErrorCode2["TRANSACTION_FAILED"] = 5003] = "TRANSACTION_FAILED";
+  ErrorCode2[ErrorCode2["DUPLICATE_KEY"] = 5004] = "DUPLICATE_KEY";
+  ErrorCode2[ErrorCode2["PLUGIN_ERROR"] = 6e3] = "PLUGIN_ERROR";
+  ErrorCode2[ErrorCode2["PLUGIN_NOT_FOUND"] = 6001] = "PLUGIN_NOT_FOUND";
+  ErrorCode2[ErrorCode2["PLUGIN_INITIALIZATION_FAILED"] = 6002] = "PLUGIN_INITIALIZATION_FAILED";
+  ErrorCode2[ErrorCode2["HOOK_EXECUTION_FAILED"] = 6003] = "HOOK_EXECUTION_FAILED";
+  ErrorCode2[ErrorCode2["EXTERNAL_SERVICE_ERROR"] = 7e3] = "EXTERNAL_SERVICE_ERROR";
+  ErrorCode2[ErrorCode2["STORAGE_ERROR"] = 7001] = "STORAGE_ERROR";
+  ErrorCode2[ErrorCode2["EMAIL_SERVICE_ERROR"] = 7002] = "EMAIL_SERVICE_ERROR";
+  ErrorCode2[ErrorCode2["WEBHOOK_DELIVERY_FAILED"] = 7003] = "WEBHOOK_DELIVERY_FAILED";
+  ErrorCode2[ErrorCode2["INTERNAL_ERROR"] = 9e3] = "INTERNAL_ERROR";
+  ErrorCode2[ErrorCode2["CONFIGURATION_ERROR"] = 9001] = "CONFIGURATION_ERROR";
+  ErrorCode2[ErrorCode2["UNEXPECTED_ERROR"] = 9999] = "UNEXPECTED_ERROR";
+  return ErrorCode2;
+}({});
+var MagnetError = class extends Error {
+  static {
+    __name(this, "MagnetError");
+  }
+  timestamp;
+  metadata;
+  constructor(message, metadata = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.timestamp = /* @__PURE__ */ new Date();
+    this.metadata = metadata;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+  * Convert to API response format
+  */
+  toResponse() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        name: this.name,
+        timestamp: this.timestamp.toISOString(),
+        metadata: this.metadata
+      }
+    };
+  }
+  /**
+  * Convert to JSON for logging
+  */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      httpStatus: this.httpStatus,
+      timestamp: this.timestamp.toISOString(),
+      metadata: this.metadata,
+      stack: this.stack
+    };
+  }
+};
+
+// src/errors/validation.error.ts
+var ValidationError = class _ValidationError extends MagnetError {
+  static {
+    __name(this, "ValidationError");
+  }
+  code = ErrorCode.VALIDATION_FAILED;
+  httpStatus = 400;
+  details;
+  constructor(message, details, metadata) {
+    super(message, metadata);
+    this.details = details;
+  }
+  /**
+  * Create ValidationError from class-validator errors
+  */
+  static fromClassValidator(errors) {
+    const details = errors.flatMap((error) => Object.entries(error.constraints ?? {}).map(([constraint, message]) => ({
+      field: error.property,
+      message,
+      constraint,
+      value: error.value
+    })));
+    return new _ValidationError(`Validation failed for ${details.length} field(s)`, details);
+  }
+  toResponse() {
+    return {
+      error: {
+        ...super.toResponse().error,
+        details: this.details
+      }
+    };
+  }
+};
+var RequiredFieldError = class extends MagnetError {
+  static {
+    __name(this, "RequiredFieldError");
+  }
+  code = ErrorCode.REQUIRED_FIELD_MISSING;
+  httpStatus = 400;
+  constructor(field, metadata) {
+    super(`Required field '${field}' is missing`, {
+      ...metadata,
+      field
+    });
+  }
+};
+var InvalidFormatError = class extends MagnetError {
+  static {
+    __name(this, "InvalidFormatError");
+  }
+  code = ErrorCode.INVALID_FORMAT;
+  httpStatus = 400;
+  constructor(field, expectedFormat, metadata) {
+    super(`Field '${field}' has invalid format. Expected: ${expectedFormat}`, {
+      ...metadata,
+      field
+    });
+  }
+};
+var ValueOutOfRangeError = class extends MagnetError {
+  static {
+    __name(this, "ValueOutOfRangeError");
+  }
+  code = ErrorCode.VALUE_OUT_OF_RANGE;
+  httpStatus = 400;
+  constructor(field, min, max, metadata) {
+    const rangeMsg = min !== void 0 && max !== void 0 ? `between ${min} and ${max}` : min !== void 0 ? `at least ${min}` : max !== void 0 ? `at most ${max}` : "within valid range";
+    super(`Field '${field}' must be ${rangeMsg}`, {
+      ...metadata,
+      field
+    });
+  }
+};
+
+// src/errors/auth.error.ts
+var AuthenticationRequiredError = class extends MagnetError {
+  static {
+    __name(this, "AuthenticationRequiredError");
+  }
+  code = ErrorCode.AUTHENTICATION_REQUIRED;
+  httpStatus = 401;
+  constructor(message = "Authentication required", metadata) {
+    super(message, metadata);
+  }
+};
+var InvalidCredentialsError = class extends MagnetError {
+  static {
+    __name(this, "InvalidCredentialsError");
+  }
+  code = ErrorCode.INVALID_CREDENTIALS;
+  httpStatus = 401;
+  constructor(message = "Invalid email or password", metadata) {
+    super(message, metadata);
+  }
+};
+var TokenExpiredError = class extends MagnetError {
+  static {
+    __name(this, "TokenExpiredError");
+  }
+  code = ErrorCode.TOKEN_EXPIRED;
+  httpStatus = 401;
+  constructor(message = "Token has expired", metadata) {
+    super(message, metadata);
+  }
+};
+var TokenInvalidError = class extends MagnetError {
+  static {
+    __name(this, "TokenInvalidError");
+  }
+  code = ErrorCode.TOKEN_INVALID;
+  httpStatus = 401;
+  constructor(message = "Token is invalid", metadata) {
+    super(message, metadata);
+  }
+};
+var AccountLockedError = class extends MagnetError {
+  static {
+    __name(this, "AccountLockedError");
+  }
+  code = ErrorCode.ACCOUNT_LOCKED;
+  httpStatus = 423;
+  unlockAt;
+  constructor(message = "Account is temporarily locked", unlockAt, metadata) {
+    super(message, metadata);
+    this.unlockAt = unlockAt;
+  }
+};
+var EmailNotVerifiedError = class extends MagnetError {
+  static {
+    __name(this, "EmailNotVerifiedError");
+  }
+  code = ErrorCode.EMAIL_NOT_VERIFIED;
+  httpStatus = 403;
+  constructor(message = "Email address not verified", metadata) {
+    super(message, metadata);
+  }
+};
+var PermissionDeniedError = class extends MagnetError {
+  static {
+    __name(this, "PermissionDeniedError");
+  }
+  code = ErrorCode.PERMISSION_DENIED;
+  httpStatus = 403;
+  requiredPermission;
+  constructor(message = "You do not have permission to perform this action", requiredPermission, metadata) {
+    super(message, metadata);
+    this.requiredPermission = requiredPermission;
+  }
+};
+var InsufficientPermissionsError = class extends MagnetError {
+  static {
+    __name(this, "InsufficientPermissionsError");
+  }
+  code = ErrorCode.INSUFFICIENT_PERMISSIONS;
+  httpStatus = 403;
+  requiredPermissions;
+  constructor(requiredPermissions, metadata) {
+    super(`Insufficient permissions. Required: ${requiredPermissions.join(", ")}`, metadata);
+    this.requiredPermissions = requiredPermissions;
+  }
+};
+var RoleNotFoundError = class extends MagnetError {
+  static {
+    __name(this, "RoleNotFoundError");
+  }
+  code = ErrorCode.ROLE_NOT_FOUND;
+  httpStatus = 404;
+  constructor(roleName, metadata) {
+    super(`Role '${roleName}' not found`, metadata);
+  }
+};
+var PermissionNotFoundError = class extends MagnetError {
+  static {
+    __name(this, "PermissionNotFoundError");
+  }
+  code = ErrorCode.PERMISSION_NOT_FOUND;
+  httpStatus = 400;
+  invalidPermissionIds;
+  constructor(invalidPermissionIds, metadata) {
+    super(`Invalid permission(s): ${invalidPermissionIds.join(", ")}. These permissions are not registered in the system.`, {
+      ...metadata,
+      context: {
+        ...metadata?.context,
+        invalidPermissionIds
+      }
+    });
+    this.invalidPermissionIds = invalidPermissionIds;
+  }
+};
+
+// src/errors/resource.error.ts
+var ResourceNotFoundError = class extends MagnetError {
+  static {
+    __name(this, "ResourceNotFoundError");
+  }
+  code = ErrorCode.RESOURCE_NOT_FOUND;
+  httpStatus = 404;
+  constructor(resourceType, identifier, metadata) {
+    super(`${resourceType} with identifier '${identifier}' not found`, {
+      ...metadata,
+      resourceId: identifier
+    });
+  }
+};
+var SchemaNotFoundError = class extends MagnetError {
+  static {
+    __name(this, "SchemaNotFoundError");
+  }
+  code = ErrorCode.SCHEMA_NOT_FOUND;
+  httpStatus = 404;
+  constructor(schemaName, metadata) {
+    super(`Schema '${schemaName}' not found`, {
+      ...metadata,
+      schema: schemaName
+    });
+  }
+};
+var DocumentNotFoundError = class extends MagnetError {
+  static {
+    __name(this, "DocumentNotFoundError");
+  }
+  code = ErrorCode.DOCUMENT_NOT_FOUND;
+  httpStatus = 404;
+  constructor(schema, id, metadata) {
+    super(`Document '${id}' not found in ${schema}`, {
+      ...metadata,
+      schema,
+      resourceId: id
+    });
+  }
+};
+var UserNotFoundError = class extends MagnetError {
+  static {
+    __name(this, "UserNotFoundError");
+  }
+  code = ErrorCode.USER_NOT_FOUND;
+  httpStatus = 404;
+  constructor(identifier, metadata) {
+    super(`User '${identifier}' not found`, {
+      ...metadata,
+      resourceId: identifier
+    });
+  }
+};
+var FileNotFoundError = class extends MagnetError {
+  static {
+    __name(this, "FileNotFoundError");
+  }
+  code = ErrorCode.FILE_NOT_FOUND;
+  httpStatus = 404;
+  constructor(path, metadata) {
+    super(`File '${path}' not found`, {
+      ...metadata,
+      resourceId: path
+    });
+  }
+};
+var VersionNotFoundError = class extends MagnetError {
+  static {
+    __name(this, "VersionNotFoundError");
+  }
+  code = ErrorCode.VERSION_NOT_FOUND;
+  httpStatus = 404;
+  constructor(schema, documentId, versionId, metadata) {
+    super(`Version '${versionId}' not found for document '${documentId}' in ${schema}`, {
+      ...metadata,
+      schema,
+      resourceId: documentId,
+      context: {
+        versionId
+      }
+    });
+  }
+};
+
+// src/errors/database.error.ts
+var DatabaseError = class extends MagnetError {
+  static {
+    __name(this, "DatabaseError");
+  }
+  code = ErrorCode.DATABASE_ERROR;
+  httpStatus = 500;
+  originalError;
+  constructor(message, originalError, metadata) {
+    super(message, metadata);
+    this.originalError = originalError;
+  }
+};
+var ConnectionFailedError = class extends MagnetError {
+  static {
+    __name(this, "ConnectionFailedError");
+  }
+  code = ErrorCode.CONNECTION_FAILED;
+  httpStatus = 503;
+  constructor(message = "Database connection failed", metadata) {
+    super(message, metadata);
+  }
+};
+var QueryFailedError = class extends MagnetError {
+  static {
+    __name(this, "QueryFailedError");
+  }
+  code = ErrorCode.QUERY_FAILED;
+  httpStatus = 500;
+  query;
+  constructor(message, query, metadata) {
+    super(message, metadata);
+    this.query = query;
+  }
+};
+var TransactionFailedError = class extends MagnetError {
+  static {
+    __name(this, "TransactionFailedError");
+  }
+  code = ErrorCode.TRANSACTION_FAILED;
+  httpStatus = 500;
+  constructor(message = "Transaction failed", metadata) {
+    super(message, metadata);
+  }
+};
+var DuplicateKeyError = class extends MagnetError {
+  static {
+    __name(this, "DuplicateKeyError");
+  }
+  code = ErrorCode.DUPLICATE_KEY;
+  httpStatus = 409;
+  constructor(field, value, metadata) {
+    super(`A record with ${field} '${String(value)}' already exists`, {
+      ...metadata,
+      field
+    });
+  }
+};
+
+// src/errors/plugin.error.ts
+var PluginError = class extends MagnetError {
+  static {
+    __name(this, "PluginError");
+  }
+  code = ErrorCode.PLUGIN_ERROR;
+  httpStatus = 500;
+  constructor(pluginName, message, metadata) {
+    super(`Plugin '${pluginName}': ${message}`, metadata);
+  }
+};
+var PluginNotFoundError = class extends MagnetError {
+  static {
+    __name(this, "PluginNotFoundError");
+  }
+  code = ErrorCode.PLUGIN_NOT_FOUND;
+  httpStatus = 404;
+  constructor(pluginName, metadata) {
+    super(`Plugin '${pluginName}' not found`, metadata);
+  }
+};
+var PluginInitializationError = class extends MagnetError {
+  static {
+    __name(this, "PluginInitializationError");
+  }
+  code = ErrorCode.PLUGIN_INITIALIZATION_FAILED;
+  httpStatus = 500;
+  constructor(pluginName, reason, metadata) {
+    super(`Failed to initialize plugin '${pluginName}': ${reason}`, metadata);
+  }
+};
+var HookExecutionError = class extends MagnetError {
+  static {
+    __name(this, "HookExecutionError");
+  }
+  code = ErrorCode.HOOK_EXECUTION_FAILED;
+  httpStatus = 500;
+  constructor(hookName, pluginName, reason, metadata) {
+    super(`Hook '${hookName}' in plugin '${pluginName}' failed: ${reason}`, metadata);
+  }
+};
+
+// src/errors/external.error.ts
+var ExternalServiceError = class extends MagnetError {
+  static {
+    __name(this, "ExternalServiceError");
+  }
+  code = ErrorCode.EXTERNAL_SERVICE_ERROR;
+  httpStatus = 502;
+  constructor(serviceName, message, metadata) {
+    super(`External service '${serviceName}' error: ${message}`, metadata);
+  }
+};
+var StorageError = class extends MagnetError {
+  static {
+    __name(this, "StorageError");
+  }
+  code = ErrorCode.STORAGE_ERROR;
+  httpStatus = 502;
+  constructor(message, metadata) {
+    super(`Storage error: ${message}`, metadata);
+  }
+};
+var EmailServiceError = class extends MagnetError {
+  static {
+    __name(this, "EmailServiceError");
+  }
+  code = ErrorCode.EMAIL_SERVICE_ERROR;
+  httpStatus = 502;
+  constructor(message, metadata) {
+    super(`Email service error: ${message}`, metadata);
+  }
+};
+var WebhookDeliveryError = class extends MagnetError {
+  static {
+    __name(this, "WebhookDeliveryError");
+  }
+  code = ErrorCode.WEBHOOK_DELIVERY_FAILED;
+  httpStatus = 502;
+  webhookUrl;
+  statusCode;
+  constructor(webhookUrl, reason, statusCode, metadata) {
+    super(`Webhook delivery to '${webhookUrl}' failed: ${reason}`, metadata);
+    this.webhookUrl = webhookUrl;
+    this.statusCode = statusCode;
+  }
+};
+
+// src/errors/internal.error.ts
+var InternalError = class extends MagnetError {
+  static {
+    __name(this, "InternalError");
+  }
+  code = ErrorCode.INTERNAL_ERROR;
+  httpStatus = 500;
+  constructor(message = "An internal error occurred", metadata) {
+    super(message, metadata);
+  }
+};
+var ConfigurationError = class extends MagnetError {
+  static {
+    __name(this, "ConfigurationError");
+  }
+  code = ErrorCode.CONFIGURATION_ERROR;
+  httpStatus = 500;
+  constructor(message, metadata) {
+    super(`Configuration error: ${message}`, metadata);
+  }
+};
+var UnexpectedError = class extends MagnetError {
+  static {
+    __name(this, "UnexpectedError");
+  }
+  code = ErrorCode.UNEXPECTED_ERROR;
+  httpStatus = 500;
+  originalError;
+  constructor(message = "An unexpected error occurred", originalError, metadata) {
+    super(message, metadata);
+    this.originalError = originalError;
+  }
+};
+
+// src/errors/factory.ts
+function fromMongooseError(error, context) {
+  if (isCastError(error) && error.path === "_id") {
+    return new DocumentNotFoundError(context?.schema ?? "document", String(error.value), {
+      operation: context?.operation
+    });
+  }
+  if (isDuplicateKeyError(error)) {
+    const keyValue = error.keyValue;
+    const field = Object.keys(keyValue)[0] ?? "field";
+    const value = keyValue[field];
+    return new DuplicateKeyError(field, value, {
+      schema: context?.schema
+    });
+  }
+  if (isValidationError(error)) {
+    const details = Object.entries(error.errors).map(([field, err]) => {
+      const errorObj = err;
+      return {
+        field,
+        message: String(errorObj.message ?? "Validation failed")
+      };
+    });
+    return new ValidationError("Validation failed", details, {
+      schema: context?.schema
+    });
+  }
+  return new DatabaseError(error instanceof Error ? error.message : "Database operation failed", error, {
+    schema: context?.schema
+  });
+}
+__name(fromMongooseError, "fromMongooseError");
+function extractPostgresUniqueInfo(error) {
+  if (!error.detail) {
+    return null;
+  }
+  const match = error.detail.match(/Key \((\w+)\)=\(([^)]+)\)/);
+  const field = match?.[1];
+  const value = match?.[2];
+  if (field && value) {
+    return {
+      field,
+      value
+    };
+  }
+  return null;
+}
+__name(extractPostgresUniqueInfo, "extractPostgresUniqueInfo");
+function fromDrizzleError(error, context) {
+  if (isPostgresUniqueError(error)) {
+    const info = extractPostgresUniqueInfo(error);
+    if (info) {
+      return new DuplicateKeyError(info.field, info.value, {
+        schema: context?.schema
+      });
+    }
+  }
+  if (error instanceof Error && error.message.includes("unique constraint")) {
+    const match = error.message.match(/Key \((\w+)\)=\(([^)]+)\)/);
+    const field = match?.[1];
+    const value = match?.[2];
+    if (field && value) {
+      return new DuplicateKeyError(field, value, {
+        schema: context?.schema
+      });
+    }
+  }
+  if (error instanceof Error && error.message.includes("no result")) {
+    return new DocumentNotFoundError(context?.schema ?? "document", "unknown", {
+      operation: "read"
+    });
+  }
+  return new DatabaseError(error instanceof Error ? error.message : "Database operation failed", error, {
+    schema: context?.schema
+  });
+}
+__name(fromDrizzleError, "fromDrizzleError");
+function isMagnetError(error) {
+  return error instanceof MagnetError;
+}
+__name(isMagnetError, "isMagnetError");
+function wrapError(error, fallbackMessage = "An error occurred") {
+  if (isMagnetError(error)) {
+    return error;
+  }
+  return new DatabaseError(error instanceof Error ? error.message : fallbackMessage, error);
+}
+__name(wrapError, "wrapError");
+
 // src/exceptions/validation.exception.ts
 var ValidationException = class extends Error {
   static {
@@ -248,13 +1867,35 @@ var Model = class {
     __name(this, "Model");
   }
   /**
+  * Get current locale
+  */
+  getLocale() {
+    return "en";
+  }
+  /**
   * Set the version for subsequent operations
   * @param versionId The version ID or status ('draft', 'published', 'archived')
+  * @returns Same instance (chainable)
   */
   version(versionId) {
     return this;
   }
   /**
+  * Check if versioning is enabled for this model
+  */
+  isVersioningEnabled() {
+    return false;
+  }
+  /**
+  * Create a version snapshot of a document
+  * @param documentId The document ID
+  * @param data The data to version
+  * @returns Version record or null if versioning disabled
+  */
+  createVersion(documentId, data) {
+    return Promise.resolve(null);
+  }
+  /**
   * Find all versions of a document
   * @param documentId The document ID
   */
@@ -269,12 +1910,13 @@ var Model = class {
     return Promise.resolve(null);
   }
   /**
-  * Restore a version
+  * Restore a document to a specific version
   * @param versionId The version ID to restore
   */
   restoreVersion(versionId) {
     return Promise.resolve(null);
   }
+  // ============= Query Builder =============
   /**
   * Create a query builder for advanced queries with sorting, pagination, and operators.
   * The query builder inherits the current locale/version context.
@@ -291,15 +1933,29 @@ var Model = class {
   query() {
     throw new Error("QueryBuilder not implemented by this adapter");
   }
+  // ============= Native Access =============
   /**
   * Get access to the native database model/collection.
   * Use with caution - bypasses Magnet abstractions like locale and versioning.
   *
-  * @returns The underlying database model (e.g., Mongoose Model)
+  * @returns Typed native access object
   */
   native() {
     throw new Error("Native access not implemented by this adapter");
   }
+  // ============= Metadata =============
+  /**
+  * Get schema name
+  */
+  getSchemaName() {
+    throw new Error("getSchemaName not implemented by this adapter");
+  }
+  /**
+  * Get schema metadata
+  */
+  getMetadata() {
+    throw new Error("getMetadata not implemented by this adapter");
+  }
 };
 
 // src/model/mixed.model.ts
@@ -316,6 +1972,17 @@ var QueryBuilder = class {
   static {
     __name(this, "QueryBuilder");
   }
+  /**
+  * Exclude specific fields from results
+  * @param fields Array of field names to exclude
+  */
+  exclude(fields) {
+    const projection = {};
+    for (const field of fields) {
+      projection[field] = 0;
+    }
+    return this.select(projection);
+  }
 };
 
 // src/types/auth.types.ts
@@ -332,6 +1999,13 @@ var AuthStrategy = class {
   }
 };
 
+// src/types/email.types.ts
+var EmailAdapter = class {
+  static {
+    __name(this, "EmailAdapter");
+  }
+};
+
 // src/types/config.types.ts
 var MagnetModuleOptions = class {
   static {
@@ -347,17 +2021,54 @@ var MagnetModuleOptions = class {
   playground;
   storage;
   /**
+  * Email adapter configuration
+  * @example
+  * email: { adapter: 'nodemailer', nodemailer: { host: 'smtp.example.com', port: 587, auth: { user: 'user', pass: 'pass' } } }
+  */
+  email;
+  /**
   * Plugins to load with the Magnet module
   */
   plugins;
-  constructor({ db, jwt, auth, internationalization, playground, storage, plugins }) {
+  /**
+  * Admin panel configuration (enabled by default when omitted).
+  * @example
+  * // Explicit enable (same as omitting `admin`)
+  * admin: true
+  *
+  * // Custom path
+  * admin: { enabled: true, path: '/dashboard' }
+  *
+  * // Disable (for API-only mode)
+  * admin: false
+  */
+  admin;
+  /**
+  * RBAC (Role-Based Access Control) configuration
+  * @example
+  * rbac: { enabled: true, defaultRole: 'authenticated' }
+  */
+  rbac;
+  /**
+  * Vault configuration for encrypted secrets management.
+  * Uses the built-in DB adapter by default (requires VAULT_MASTER_KEY env var).
+  * @example
+  * vault: { adapter: 'db' }
+  * vault: { adapter: 'hashicorp', hashicorp: { url: 'https://vault.example.com:8200' } }
+  */
+  vault;
+  constructor({ db, jwt, auth, internationalization, playground, storage, email, plugins, admin, rbac, vault }) {
     this.db = db;
     this.jwt = jwt;
     this.auth = auth;
     this.internationalization = internationalization;
     this.playground = playground;
     this.storage = storage;
+    this.email = email;
     this.plugins = plugins;
+    this.admin = admin;
+    this.rbac = rbac;
+    this.vault = vault;
   }
 };
 
@@ -368,6 +2079,16 @@ var DatabaseAdapter = class {
   }
 };
 
+// src/types/settings.types.ts
+function isSettingFieldMetadata(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const metadata = value;
+  return typeof metadata.type === "string" && typeof metadata.options === "object" && metadata.options !== null && "propertyKey" in metadata;
+}
+__name(isSettingFieldMetadata, "isSettingFieldMetadata");
+
 // src/types/storage.types.ts
 var StorageAdapter = class {
   static {
@@ -375,41 +2096,158 @@ var StorageAdapter = class {
   }
 };
 
+// src/types/vault.types.ts
+var VaultAdapter = class {
+  static {
+    __name(this, "VaultAdapter");
+  }
+};
+
+// src/types/cache.types.ts
+var CacheAdapter = class {
+  static {
+    __name(this, "CacheAdapter");
+  }
+};
+
+exports.AccountLockedError = AccountLockedError;
 exports.AuthStrategy = AuthStrategy;
+exports.AuthenticationRequiredError = AuthenticationRequiredError;
 exports.BASE_SCHEMA_METADATA_KEY = BASE_SCHEMA_METADATA_KEY;
+exports.CacheAdapter = CacheAdapter;
+exports.ConfigurationError = ConfigurationError;
+exports.ConnectionFailedError = ConnectionFailedError;
 exports.DESIGN_META = DESIGN_META;
 exports.DESIGN_PARAM_TYPES = DESIGN_PARAM_TYPES;
 exports.DESIGN_RETURN_TYPE = DESIGN_RETURN_TYPE;
 exports.DESIGN_TYPE = DESIGN_TYPE;
 exports.DatabaseAdapter = DatabaseAdapter;
+exports.DatabaseError = DatabaseError;
+exports.DocumentNotFoundError = DocumentNotFoundError;
+exports.DuplicateKeyError = DuplicateKeyError;
+exports.EVENT_HANDLER_METADATA = EVENT_HANDLER_METADATA;
+exports.EXTEND_USER_METADATA_KEY = EXTEND_USER_METADATA_KEY;
+exports.EmailAdapter = EmailAdapter;
+exports.EmailNotVerifiedError = EmailNotVerifiedError;
+exports.EmailServiceError = EmailServiceError;
+exports.ErrorCode = ErrorCode;
+exports.ExtendUser = ExtendUser;
+exports.ExternalServiceError = ExternalServiceError;
+exports.FIELD_METADATA_KEY = FIELD_METADATA_KEY;
+exports.Field = Field;
+exports.FileNotFoundError = FileNotFoundError;
+exports.HasPermission = HasPermission;
+exports.HookExecutionError = HookExecutionError;
 exports.INJECT_MODEL = INJECT_MODEL;
 exports.InjectModel = InjectModel;
+exports.InsufficientPermissionsError = InsufficientPermissionsError;
+exports.InternalError = InternalError;
+exports.InvalidCredentialsError = InvalidCredentialsError;
+exports.InvalidFormatError = InvalidFormatError;
+exports.MagnetError = MagnetError;
 exports.MagnetModuleOptions = MagnetModuleOptions;
 exports.Mixed = Mixed;
 exports.Model = Model;
+exports.OnEvent = OnEvent;
+exports.PERMISSION_METADATA_KEY = PERMISSION_METADATA_KEY;
+exports.PERMISSION_OPTIONS_METADATA_KEY = PERMISSION_OPTIONS_METADATA_KEY;
 exports.PROP_METADATA_KEY = PROP_METADATA_KEY;
+exports.PermissionDeniedError = PermissionDeniedError;
+exports.PermissionMeta = PermissionMeta;
+exports.PermissionNotFoundError = PermissionNotFoundError;
+exports.PluginError = PluginError;
+exports.PluginInitializationError = PluginInitializationError;
+exports.PluginNotFoundError = PluginNotFoundError;
 exports.Prop = Prop;
 exports.QueryBuilder = QueryBuilder;
+exports.QueryFailedError = QueryFailedError;
+exports.RESOLVED_PERMISSION_KEY = RESOLVED_PERMISSION_KEY;
 exports.RESOLVER_METADATA_KEY = RESOLVER_METADATA_KEY;
 exports.RESOLVE_METADATA_KEY = RESOLVE_METADATA_KEY;
+exports.RequirePermission = RequirePermission;
+exports.RequiredFieldError = RequiredFieldError;
 exports.Resolve = Resolve;
 exports.Resolver = Resolver;
+exports.ResourceNotFoundError = ResourceNotFoundError;
+exports.RoleNotFoundError = RoleNotFoundError;
 exports.SCHEMA_METADATA_KEY = SCHEMA_METADATA_KEY;
 exports.SCHEMA_OPTIONS_METADATA_KEY = SCHEMA_OPTIONS_METADATA_KEY;
+exports.SETTINGS_OPTIONS_METADATA_KEY = SETTINGS_OPTIONS_METADATA_KEY;
+exports.SETTING_FIELD_METADATA_KEY = SETTING_FIELD_METADATA_KEY;
 exports.SETTING_METADATA_KEY = SETTING_METADATA_KEY;
 exports.Schema = Schema;
+exports.SchemaNotFoundError = SchemaNotFoundError;
 exports.Setting = Setting;
+exports.SettingField = SettingField;
+exports.Settings = Settings;
 exports.StorageAdapter = StorageAdapter;
+exports.StorageError = StorageError;
+exports.TokenExpiredError = TokenExpiredError;
+exports.TokenInvalidError = TokenInvalidError;
+exports.TransactionFailedError = TransactionFailedError;
 exports.UI = UI;
 exports.UI_METADATA_KEY = UI_METADATA_KEY;
+exports.UnexpectedError = UnexpectedError;
+exports.UserNotFoundError = UserNotFoundError;
 exports.VERSION_METADATA_KEY = VERSION_METADATA_KEY;
+exports.ValidationError = ValidationError;
 exports.ValidationException = ValidationException;
 exports.Validators = Validators;
+exports.ValueOutOfRangeError = ValueOutOfRangeError;
+exports.VaultAdapter = VaultAdapter;
 exports.Version = Version;
+exports.VersionNotFoundError = VersionNotFoundError;
+exports.WebhookDeliveryError = WebhookDeliveryError;
+exports.assert = assert;
+exports.assertDefined = assertDefined;
 exports.clearAdapterCache = clearAdapterCache;
+exports.clearDatabaseAdapterSingletonForFeature = clearDatabaseAdapterSingletonForFeature;
+exports.createFieldDecorator = createFieldDecorator;
 exports.detectDatabaseAdapter = detectDatabaseAdapter;
+exports.fromDrizzleError = fromDrizzleError;
+exports.fromMongooseError = fromMongooseError;
+exports.getAdapterToken = getAdapterToken;
+exports.getDatabaseAdapterSingletonForFeature = getDatabaseAdapterSingletonForFeature;
+exports.getDocumentId = getDocumentId;
+exports.getExtendUserOptions = getExtendUserOptions;
+exports.getFieldMetadata = getFieldMetadata;
+exports.getFieldMetadataForProperty = getFieldMetadataForProperty;
 exports.getModelToken = getModelToken;
+exports.getPermissionMetadata = getPermissionMetadata;
+exports.getRegisteredModel = getRegisteredModel;
 exports.getSchemaOptions = getSchemaOptions;
 exports.getSchemaToken = getSchemaToken;
+exports.getSettingFields = getSettingFields;
 exports.getSettingToken = getSettingToken;
+exports.getSettingsOptions = getSettingsOptions;
+exports.hasMethod = hasMethod;
+exports.hasPermissionDecorator = hasPermissionDecorator;
+exports.hasProperties = hasProperties;
+exports.hasProperty = hasProperty;
+exports.hasSetLocale = hasSetLocale;
+exports.hasToString = hasToString;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isCastError = isCastError;
+exports.isDocument = isDocument;
+exports.isDuplicateKeyError = isDuplicateKeyError;
+exports.isFieldMetadata = isFieldMetadata;
+exports.isFunction = isFunction;
+exports.isMagnetError = isMagnetError;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPostgresUniqueError = isPostgresUniqueError;
+exports.isSettingFieldMetadata = isSettingFieldMetadata;
+exports.isString = isString;
+exports.isStringArray = isStringArray;
+exports.isStringRecord = isStringRecord;
+exports.isUserExtension = isUserExtension;
+exports.isValidFieldType = isValidFieldType;
+exports.isValidationError = isValidationError;
+exports.isVersionDocument = isVersionDocument;
+exports.mapFieldTypeToProp = mapFieldTypeToProp;
+exports.mapFieldTypeToUI = mapFieldTypeToUI;
+exports.registerDatabaseAdapterSingletonForFeature = registerDatabaseAdapterSingletonForFeature;
+exports.registerModel = registerModel;
 exports.setDatabaseAdapter = setDatabaseAdapter;
+exports.wrapError = wrapError;