@rebasepro/types 0.11.1-canary.gfadf355 → 0.12.0

package/dist/types/admin_block.d.ts

@@ -49,6 +49,6 @@ export type AdminCollectionKey = typeof ADMIN_COLLECTION_KEYS[number];
  *
  * @group Models
  */
-export declare const ADMIN_PROPERTY_KEYS: readonly ["clearable", "columnWidth", "customProps", "disabled", "expanded", "Field", "Filter", "filterOperators", "hideFromCollection", "markdown", "minimalistView", "multiline", "Preview", "previewAsTag", "previewProperties", "readOnly", "spreadChildren", "urlPreview", "widget", "widthPercentage"];
+export declare const ADMIN_PROPERTY_KEYS: readonly ["canAddElements", "clearable", "columnWidth", "customProps", "disabled", "expanded", "Field", "Filter", "filterOperators", "fixedFilter", "hideFromCollection", "includeEntityLink", "includeId", "markdown", "minimalistView", "multiline", "Preview", "previewAsTag", "previewProperties", "readOnly", "sortable", "spreadChildren", "urlPreview", "widget", "widthPercentage"];
 /** A key of a property's `admin` block. @group Models */
 export type AdminPropertyKey = typeof ADMIN_PROPERTY_KEYS[number];

package/dist/types/api_keys.d.ts

@@ -1,15 +1,54 @@
-/** A single permission entry scoping an API key to a collection and its allowed operations. */
+/**
+ * Service API keys — machine-to-machine authentication for scripts, cron jobs
+ * and third-party integrations.
+ *
+ * The wire contract lives here because all three sides need it and used to
+ * declare it separately: `@rebasepro/server` implements the routes,
+ * `@rebasepro/client` calls them, and {@link ApiKeysAPI} types the SDK surface.
+ * The client's copy had already drifted — it never gained `admin`.
+ *
+ * The database row itself (`ApiKey`, which carries `key_hash`) stays in the
+ * server package: nothing off the server may see it.
+ */
+/**
+ * A single permission entry scoping an API key to a collection and set of
+ * operations.
+ *
+ * Use `"*"` as the collection value to grant access to all collections (and all
+ * custom functions). Custom functions are addressed with the `functions`
+ * namespace: `"functions"` grants every function, `"functions/<name>"` grants a
+ * single one.
+ *
+ * @group Models
+ */
 export interface ApiKeyPermission {
+    /** Collection slug, `"functions"`/`"functions/<name>"`, or `"*"` for everything. */
     collection: string;
+    /** Allowed operations on the collection. */
     operations: ("read" | "write" | "delete")[];
 }
-/** An API key with the secret portion masked (returned by list / get / update). */
+/**
+ * An API key with the secret portion masked — what list / get / update return.
+ * @group Models
+ */
 export interface ApiKeyMasked {
     id: string;
     name: string;
+    /** First 12 characters of the plaintext key, for display only. */
     key_prefix: string;
     permissions: ApiKeyPermission[];
+    /**
+     * When true, the key is granted the `admin` role: it passes the admin-gated
+     * routes (users, roles, cron, backups, logs, API keys) and the RLS
+     * `default_admin` policies. Non-admin keys carry only the `service` role —
+     * RLS grants them nothing unless a collection policy names that role.
+     */
     admin: boolean;
+    /**
+     * Requests per 15-minute window. `null` means "no per-key override" — the
+     * data rate limiter then applies its default API-key limit (1000/window
+     * unless configured otherwise), not unlimited.
+     */
     rate_limit: number | null;
     created_by: string;
     created_at: string;
@@ -18,26 +57,42 @@ export interface ApiKeyMasked {
     expires_at: string | null;
     revoked_at: string | null;
 }
-/** An API key including the full secret (returned only on creation). */
+/**
+ * Returned exactly once, when a key is created. The `key` field holds the full
+ * plaintext key — it is never stored or returned again.
+ * @group Models
+ */
 export interface ApiKeyWithSecret extends ApiKeyMasked {
+    /** Full plaintext API key (e.g. `rk_live_abc123...`). */
     key: string;
 }
-/** Payload for creating a new API key. */
+/**
+ * Payload for creating a new API key.
+ * @group Models
+ */
 export interface CreateApiKeyRequest {
     name: string;
     permissions: ApiKeyPermission[];
+    /** When true, grants the `admin` role. See {@link ApiKeyMasked.admin}. */
     admin?: boolean;
+    /** Requests per 15-minute window. Omit or `null` for the server default. */
     rate_limit?: number | null;
+    /** ISO-8601 expiration timestamp. Omit for no expiration. */
     expires_at?: string | null;
 }
-/** Payload for updating an existing API key. */
+/**
+ * Payload for updating an existing API key. Only the fields provided change.
+ * @group Models
+ */
 export interface UpdateApiKeyRequest {
     name?: string;
     permissions?: ApiKeyPermission[];
+    /** When true, grants the `admin` role. See {@link ApiKeyMasked.admin}. */
     admin?: boolean;
     rate_limit?: number | null;
     expires_at?: string | null;
 }
+/** @group Models */
 export interface ApiKeysAPI {
     listKeys(): Promise<{
         keys: ApiKeyMasked[];

package/dist/types/collections.d.ts

@@ -90,23 +90,26 @@ export interface BaseCollectionConfig<M extends Record<string, unknown> = Record
      */
     auth?: boolean | AuthCollectionConfig;
     /**
-     * Opt out of the framework's default Row Level Security policies.
-     *
-     * The schema generator automatically injects, for every collection, a
-     * baseline SELECT policy granting the trusted server context and the
-     * `admin` role read access (reads run under a restricted role, so RLS
-     * default-denies without it). For auth collections it additionally injects
-     * a self-read policy (`id = auth.uid()`) and an admin-only write gate
-     * (INSERT/UPDATE/DELETE require the `admin` role or the trusted server
-     * context), making privileged columns such as `roles` safe by default.
+     * Row-level authorization rules for this collection.
      *
-     * Author-defined `securityRules` are permissive and broaden access on top
-     * of these defaults. Set this flag to `true` to remove the defaults
-     * entirely and take full responsibility for the collection's RLS.
+     * Driver-agnostic on purpose, unlike `disableDefaultPolicies`, `table` and
+     * `relations`, which are declared on {@link PostgresCollectionConfig} only.
+     * The rules are a *contract* — who may read or write which rows — and each
+     * engine enforces it its own way:
      *
-     * @default false
+     * - **Postgres** compiles them to real `CREATE POLICY` statements and lets
+     *   the database enforce them (see {@link PostgresCollectionConfig.securityRules},
+     *   which narrows this with the raw-SQL details).
+     * - **MongoDB** translates them into a query filter it AND-s into every
+     *   read and write, honouring `access`, `ownerField`, `roles`, `mode` and
+     *   the `operation`/`operations` selectors, and making a best effort at raw
+     *   `using`/`withCheck` SQL.
+     * - **Firestore** does not implement them at all; its own rules language is
+     *   evaluated by Google, not from here. `supportsRLS` on
+     *   {@link DataSourceCapabilities} reports which engines generate policies,
+     *   which is not the same question as whether an engine honours a rule.
      */
-    disableDefaultPolicies?: boolean;
+    securityRules?: readonly SecurityRule[];
     /**
      * This interface defines all the callbacks that can be used when a entity
      * is being created, updated or deleted.
@@ -140,23 +143,6 @@ export interface BaseCollectionConfig<M extends Record<string, unknown> = Record
      * quietly worked. The second case is the reason for the escape hatch.
      */
     strictWrites?: boolean;
-    /**
-     * The database table name for this collection.
-     * Automatically set for PostgreSQL collections.
-     * For non-SQL backends, this may be undefined.
-     */
-    table?: string;
-    /**
-     * Relations defined for this collection.
-     * Populated at normalization time from inline relation properties
-     * or explicit relation definitions.
-     */
-    relations?: Relation[];
-    /**
-     * Security rules for this collection (Row Level Security).
-     * When defined, the backend enforces access control policies.
-     */
-    securityRules?: readonly SecurityRule[];
 }
 /**
  * A collection backed by PostgreSQL (or any SQL database).
@@ -205,6 +191,24 @@ export interface PostgresCollectionConfig<M extends Record<string, unknown> = Re
      * - `auth.jwt()`   — full JWT claims as JSONB
      */
     securityRules?: readonly SecurityRule[];
+    /**
+     * Opt out of the framework's default Row Level Security policies.
+     *
+     * The schema generator automatically injects, for every collection, a
+     * baseline SELECT policy granting the trusted server context and the
+     * `admin` role read access (reads run under a restricted role, so RLS
+     * default-denies without it). For auth collections it additionally injects
+     * a self-read policy (`id = auth.uid()`) and an admin-only write gate
+     * (INSERT/UPDATE/DELETE require the `admin` role or the trusted server
+     * context), making privileged columns such as `roles` safe by default.
+     *
+     * Author-defined `securityRules` are permissive and broaden access on top
+     * of these defaults. Set this flag to `true` to remove the defaults
+     * entirely and take full responsibility for the collection's RLS.
+     *
+     * @default false
+     */
+    disableDefaultPolicies?: boolean;
 }
 /**
  * A collection backed by Firebase / Firestore.
@@ -329,6 +333,27 @@ export type AnyCollectionConfig = CollectionConfig<any, any>;
  * @group Models
  */
 export declare function isPostgresCollectionConfig<C extends CollectionConfig<any, any>>(collection: C): collection is C & PostgresCollectionConfig<any, any>;
+/**
+ * Narrows to the SQL collection fields — `table`, `relations`,
+ * `disableDefaultPolicies` — by asking the engine's declared capabilities
+ * rather than by naming Postgres.
+ *
+ * The two halves of this already existed and were never joined. The engine
+ * split (`PostgresCollectionConfig` / `FirebaseCollectionConfig` /
+ * `MongoDBCollectionConfig`) said which fields belong to which engine at the
+ * type level; {@link DataSourceCapabilities} said the same thing at runtime,
+ * down to a `supportsRelations` flag. So call sites guarded on the capability
+ * and then read a field the base type had to declare for them — which is why
+ * those fields were on the base, and why a MongoDB collection could be written
+ * with a `table`.
+ *
+ * Prefer this over {@link isPostgresCollectionConfig} wherever the question is
+ * "does this collection live in a SQL table", so a custom SQL engine
+ * registered through `registerDataSourceCapabilities` is included.
+ *
+ * @group Models
+ */
+export declare function isRelationalCollectionConfig<C extends CollectionConfig<any, any>>(collection: C): collection is C & PostgresCollectionConfig<any, any>;
 /**
  * Type guard for Firebase / Firestore collections.
  * @group Models

package/dist/types/data_source.d.ts

@@ -27,6 +27,16 @@ export interface DataSourceCapabilities {
     supportsColumnTypes: boolean;
     /** Does this source support real-time listeners? */
     supportsRealtime: boolean;
+    /**
+     * Does this source store vectors natively?
+     *
+     * `VectorProperty` carries a `dimensions` and is pgvector-shaped. It was
+     * the one driver-specific property kind with no flag to gate it, so unlike
+     * every other field in this descriptor there was not even a runtime answer
+     * to appeal to — a Firestore collection could declare an embedding column
+     * and no driver would do anything with it.
+     */
+    supportsVectors: boolean;
     /**
      * Canonical filter operators this engine can execute.
      *

package/dist/types/history.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Entity change history — the shape a history entry has on the wire.
+ *
+ * This was declared three times: once in `@rebasepro/server-postgres`, once in
+ * `@rebasepro/server-mongo`, and once again in the admin's `useHistory` hook.
+ * The two driver copies disagreed on the one field that matters for a consumer,
+ * `updated_at`, which was a `string` in Postgres and a `Date` in MongoDB — so
+ * nothing could read history without first choosing a driver.
+ *
+ * The contract is the wire shape, and on the wire it is an ISO-8601 string.
+ * A driver whose stored document differs (MongoDB keeps a `Date` and an
+ * `ObjectId`) declares that storage row for itself and maps to this on the way
+ * out; it is not the shared type.
+ *
+ * @group Backend
+ */
+/**
+ * One recorded change to a row.
+ * @group Backend
+ */
+export interface EntityHistoryEntry {
+    id: string;
+    /** The table (Postgres) or collection (MongoDB) the row belongs to. */
+    table_name: string;
+    /** The row's id, as a string regardless of its native type. */
+    entity_id: string;
+    action: "create" | "update" | "delete";
+    /** Which fields changed. `null` for creates and deletes. */
+    changed_fields: string[] | null;
+    values: Record<string, unknown> | null;
+    previous_values: Record<string, unknown> | null;
+    updated_by: string | null;
+    /** ISO-8601. A driver storing a native date converts on read. */
+    updated_at: string;
+}
+/**
+ * Arguments to record one change.
+ * @group Backend
+ */
+export interface RecordHistoryParams {
+    tableName: string;
+    id: string;
+    action: "create" | "update" | "delete";
+    values?: Record<string, unknown> | null;
+    previousValues?: Record<string, unknown> | null;
+    updatedBy?: string | null;
+}
+/**
+ * How much history to keep. Pruning runs per row after each write.
+ * @group Backend
+ */
+export interface HistoryRetentionConfig {
+    /** Max entries per row. Oldest pruned first. Default 200. */
+    maxEntries: number;
+    /** Entries older than this many days are pruned. Default 90. */
+    ttlDays: number;
+}
+/** @group Backend */
+export interface FetchHistoryOptions {
+    limit?: number;
+    offset?: number;
+}

package/dist/types/index.d.ts

@@ -19,6 +19,8 @@ export * from "./component_ref";
 export * from "./auth_adapter";
 export * from "./database_adapter";
 export * from "./api_keys";
+export * from "./history";
+export * from "./postgres_introspection";
 export * from "./project_manifest";
 export * from "./collection_contract";
 export * from "./schema_version";

package/dist/types/postgres_introspection.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Shapes returned by Postgres introspection queries.
+ *
+ * These are **not** driver-agnostic and they are not a model of anything — each
+ * one is the projection of a specific `SELECT` against `information_schema` or
+ * `pg_policies`, which is why the fields are snake_cased and why `is_nullable`
+ * is a string rather than a boolean. They describe rows, not concepts.
+ *
+ * They were spread across three places that had nothing to do with each other:
+ * the `Table*` shapes sat in `websockets.ts`, next to the WebSocket frame types
+ * they share no relationship with, and `PostgresPolicy` was declared twice — in
+ * `@rebasepro/admin`'s RLS tab and again in `@rebasepro/studio`'s RLS editor,
+ * the second with a comment explaining it was inline "to avoid depending on
+ * @rebasepro/studio". Neither had to: this package is already a dependency of
+ * both.
+ *
+ * Producer: `@rebasepro/server-postgres`. Consumers: the collection editor, the
+ * studio schema browser, the RLS editors.
+ */
+/**
+ * A column, as `information_schema.columns` reports it.
+ * @group Models
+ */
+export interface TableColumnInfo {
+    column_name: string;
+    data_type: string;
+    udt_name: string;
+    /** `"YES"` or `"NO"` — `information_schema` reports this as text. */
+    is_nullable: string;
+    column_default: string | null;
+    character_maximum_length: number | null;
+    /** Enum values, populated for USER-DEFINED (enum) columns */
+    enum_values?: string[];
+}
+/** @group Models */
+export interface TableForeignKeyInfo {
+    column_name: string;
+    foreign_table_name: string;
+    foreign_column_name: string;
+}
+/** @group Models */
+export interface TableJunctionInfo {
+    junction_table_name: string;
+    source_column_name: string;
+    target_table_name: string;
+    target_column_name: string;
+}
+/**
+ * A policy as the *table metadata* query projects it.
+ *
+ * Distinct from {@link PostgresPolicy}, which is the RLS editor's fuller
+ * projection of `pg_policies` — this one carries only what the collection
+ * editor needs to show that a table is protected.
+ *
+ * @group Models
+ */
+export interface TablePolicyInfo {
+    policy_name: string;
+    roles: string[];
+    cmd: string;
+    qual?: string;
+    with_check?: string;
+}
+/** @group Models */
+export interface TableMetadata {
+    columns: TableColumnInfo[];
+    foreignKeys: TableForeignKeyInfo[];
+    junctions: TableJunctionInfo[];
+    policies: TablePolicyInfo[];
+}
+/**
+ * A row of `pg_policies`, as the RLS editors read it.
+ *
+ * Note the unseparated column names (`policyname`, `tablename`) — those are
+ * Postgres's, not ours. See {@link TablePolicyInfo} for the narrower projection
+ * the collection editor uses.
+ *
+ * @group Models
+ */
+export interface PostgresPolicy {
+    policyname: string;
+    tablename: string;
+    permissive: "PERMISSIVE" | "RESTRICTIVE";
+    roles: string[];
+    cmd: "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "ALL";
+    /** The `USING` clause. */
+    qual: string | null;
+    /** The `WITH CHECK` clause. */
+    with_check: string | null;
+    /**
+     * Whether this policy exists in the live database, in the collection's
+     * `securityRules`, or both. Computed by the editor, not by Postgres.
+     */
+    status?: "live" | "code_only" | "both";
+}

package/dist/types/properties.d.ts

@@ -1,6 +1,5 @@
 import type { Entity, EntityReference, EntityRelation, EntityValues, GeoPoint, Vector } from "./entities";
 import type { Relation, ResolvedRelation } from "./relations";
-import type { FilterValues } from "./collections";
 import type { ColorKey, ColorScheme } from "./chips";
 import type { AuthState } from "../controllers/auth_state";
 import type { AfterReadProps, BeforeSaveProps } from "./entity_callbacks";
@@ -35,15 +34,40 @@ export type Property = StringProperty | NumberProperty | BooleanProperty | DateP
 export type Properties = {
     [key: string]: Property;
 };
+/**
+ * `Omit` that survives a union.
+ *
+ * `Property` is a union discriminated on `type`, and a bare `Omit<Property, K>`
+ * collapses it into one object whose `type` is the union of every tag — so
+ * `property.type === "string"` stops narrowing and the concrete property types
+ * become unreachable. The `T extends unknown` clause makes it distribute, so
+ * each member is omitted from separately and keeps its own discriminant.
+ */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * The fields that describe a property's **column**, which only an engine with
+ * columns has.
+ *
+ * `columnType` names a Postgres type (`uuid`, `bigserial`, `jsonb`, `text[]`)
+ * and `columnName` overrides the snake_case derivation used to build a column
+ * name. `DataSourceCapabilities.supportsColumnTypes` already reported this at
+ * runtime — `false` for both document engines — while the types let a MongoDB
+ * property declare `columnType: "bigserial"`.
+ *
+ * They stay declared on the concrete property interfaces rather than moving,
+ * because that is where their per-type value unions live; what changes is that
+ * the document engines' property aliases omit them.
+ */
+type SqlColumnFields = "columnType" | "columnName";
 export type PostgresProperty = Exclude<Property, ReferenceProperty>;
 export type PostgresProperties = {
     [key: string]: PostgresProperty;
 };
-export type FirebaseProperty = Exclude<Property, RelationProperty>;
+export type FirebaseProperty = DistributiveOmit<Exclude<Property, RelationProperty | VectorProperty>, SqlColumnFields>;
 export type FirebaseProperties = {
     [key: string]: FirebaseProperty;
 };
-export type MongoProperty = Exclude<Property, RelationProperty>;
+export type MongoProperty = DistributiveOmit<Exclude<Property, RelationProperty | VectorProperty>, SqlColumnFields>;
 export type MongoProperties = {
     [key: string]: MongoProperty;
 };
@@ -398,19 +422,6 @@ export interface ReferenceProperty extends BaseProperty {
      * property.
      */
     path?: string;
-    /**
-     * Allow selection of entities that pass the given filter only.
-     * e.g. `fixedFilter: { age: [">=", 18] }`
-     */
-    fixedFilter?: FilterValues<string>;
-    /**
-     * Should the reference include the ID of the entity. Defaults to `true`
-     */
-    includeId?: boolean;
-    /**
-     * Should the reference include a link to the entity (open the entity details). Defaults to `true`
-     */
-    includeEntityLink?: boolean;
 }
 /**
  * A schema-level relationship between collections **within a single
@@ -469,24 +480,6 @@ export interface RelationProperty extends BaseProperty {
      * collection's `relations` array.
      */
     resolvedRelation?: ResolvedRelation;
-    /**
-     * Allow selection of entities that pass the given filter only.
-     * e.g. `fixedFilter: { age: [">=", 18] }`
-     */
-    fixedFilter?: FilterValues<string>;
-    /**
-     * Should the reference include the ID of the entity. Defaults to `true`
-     */
-    includeId?: boolean;
-    /**
-     * Should the reference include a link to the entity (open the entity details). Defaults to `true`
-     */
-    includeEntityLink?: boolean;
-    /**
-     * Choose the widget to use for selecting the relation.
-     * Defaults to `select`.
-     */
-    widget?: "select" | "dialog";
 }
 export interface ArrayProperty extends BaseProperty {
     type: "array";
@@ -549,16 +542,6 @@ export interface ArrayProperty extends BaseProperty {
      * Rules for validating this property
      */
     validation?: ArrayPropertyValidationSchema;
-    /**
-     * Can the elements in this array be reordered. Defaults to `true`.
-     * This prop has no effect if `disabled` is set to true.
-     */
-    sortable?: boolean;
-    /**
-     * Can the elements in this array be added. Defaults to `true`
-     * This prop has no effect if `disabled` is set to true.
-     */
-    canAddElements?: boolean;
 }
 export interface MapProperty extends BaseProperty {
     type: "map";
@@ -578,6 +561,12 @@ export interface MapProperty extends BaseProperty {
      * Order in which the properties are displayed.
      * If you are specifying your collection as code, the order is the same as the
      * one you define in `properties`, and you don't need to specify this prop.
+     *
+     * Stays on the property rather than moving to the `admin` block, unlike the
+     * rest of the map's presentation options: `sortProperties` in
+     * `@rebasepro/common` reads it recursively, and `@rebasepro/firebase` calls
+     * that when it builds collections. A core package cannot read the admin
+     * block — the field exists only once `@rebasepro/admin-types` is installed.
      */
     propertiesOrder?: string[];
     /**
@@ -586,13 +575,13 @@ export interface MapProperty extends BaseProperty {
      * will be considered valid, even if you set `required` in the properties.
      */
     validation?: PropertyValidationSchema;
-    /**
-     * Properties that are displayed when rendered as a preview
-     */
-    previewProperties?: string[];
     /**
      * Render this map as a key-value table that allows to use
      * arbitrary keys. You don't need to define the properties in this case.
+     *
+     * Core rather than admin despite the wording: it says the map has no
+     * declared shape, which is what the OpenAPI generator emits the schema
+     * from (`additionalProperties` instead of a property list).
      */
     keyValue?: boolean;
 }

package/dist/types/websockets.d.ts

@@ -115,40 +115,3 @@ export interface ChannelHistoryMessage extends WebSocketMessage {
      */
     latestSeq?: number;
 }
-/**
- * Column metadata returned by table introspection.
- */
-export interface TableColumnInfo {
-    column_name: string;
-    data_type: string;
-    udt_name: string;
-    is_nullable: string;
-    column_default: string | null;
-    character_maximum_length: number | null;
-    /** Enum values, populated for USER-DEFINED (enum) columns */
-    enum_values?: string[];
-}
-export interface TableForeignKeyInfo {
-    column_name: string;
-    foreign_table_name: string;
-    foreign_column_name: string;
-}
-export interface TableJunctionInfo {
-    junction_table_name: string;
-    source_column_name: string;
-    target_table_name: string;
-    target_column_name: string;
-}
-export interface TablePolicyInfo {
-    policy_name: string;
-    roles: string[];
-    cmd: string;
-    qual?: string;
-    with_check?: string;
-}
-export interface TableMetadata {
-    columns: TableColumnInfo[];
-    foreignKeys: TableForeignKeyInfo[];
-    junctions: TableJunctionInfo[];
-    policies: TablePolicyInfo[];
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/types",
   "type": "module",
-  "version": "0.11.1-canary.gfadf355",
+  "version": "0.12.0",
   "description": "Rebase type definitions — shared interfaces and controller types",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"

package/src/types/admin_block.ts

@@ -92,6 +92,7 @@ export type AdminCollectionKey = typeof ADMIN_COLLECTION_KEYS[number];
  * @group Models
  */
 export const ADMIN_PROPERTY_KEYS = [
+    "canAddElements",
     "clearable",
     "columnWidth",
     "customProps",
@@ -100,7 +101,10 @@ export const ADMIN_PROPERTY_KEYS = [
     "Field",
     "Filter",
     "filterOperators",
+    "fixedFilter",
     "hideFromCollection",
+    "includeEntityLink",
+    "includeId",
     "markdown",
     "minimalistView",
     "multiline",
@@ -108,6 +112,7 @@ export const ADMIN_PROPERTY_KEYS = [
     "previewAsTag",
     "previewProperties",
     "readOnly",
+    "sortable",
     "spreadChildren",
     "urlPreview",
     "widget",