@baseplate-dev/plugin-auth 2.0.1 → 2.0.3

package/dist/web/assets/__federation_shared_@baseplate-dev/{project-builder-lib-CGEZr0YI.js → project-builder-lib-BvG5Zcxb.js}

@@ -1,9 +1,71 @@
-import { c as createPluginSpec, m as mapValues, a as createEntityType, d as definitionSchema, D as DefinitionReferenceMarker, g as get, R as REF_ANNOTATIONS_MARKER_SYMBOL, b as createDefinitionSchemaParserContext, s as set$1, e as modelForeignRelationEntityType, f as modelLocalRelationEntityType, h as modelScalarFieldEntityType, i as modelTransformerEntityType, j as modelEntityType, k as modelEnumValueEntityType, l as featureEntityType, n as modelEnumEntityType, o as modelUniqueConstraintEntityType, p as createFeaturesSchema, M as ModelUtils, q as omit, r as cloneDeep } from '../model-merger-BLEOsCIp.js';
-export { I as DefinitionDiffArrayIncludesField, G as DefinitionDiffKeyedArrayField, H as DefinitionDiffReplacementField, u as DefinitionEntityType, F as FeatureUtils, L as applyDefinitionDiff, B as applyModelMergerDiff, C as applyModelMergerResultInPlace, E as createAndApplyModelMergerResults, K as createDefinitionDiff, J as createDefinitionDiffConfig, w as createFeatureSchema, t as createInitializedPluginSpec, y as createModelMergerResult, A as createModelMergerResults, z as doesModelMergerResultsHaveChanges, v as featureNameSchema, x as modelMergerDefinitionDiffConfig } from '../model-merger-BLEOsCIp.js';
-import { importShared } from '../__federation_fn_import-DReOsou_.js';
+import { c as createPluginSpec, m as mapValues, a as createEntityType, d as definitionSchema, D as DefinitionReferenceMarker, g as get, R as REF_ANNOTATIONS_MARKER_SYMBOL, b as createDefinitionSchemaParserContext, s as set$1, e as modelForeignRelationEntityType, f as modelLocalRelationEntityType, h as modelScalarFieldEntityType, i as modelTransformerEntityType, j as modelEntityType, k as modelEnumValueEntityType, l as featureEntityType, n as modelEnumEntityType, o as modelUniqueConstraintEntityType, p as createFeaturesSchema, M as ModelUtils, q as omit, r as cloneDeep } from '../model-merger-boZDknXa.js';
+export { I as DefinitionDiffArrayIncludesField, G as DefinitionDiffKeyedArrayField, H as DefinitionDiffReplacementField, u as DefinitionEntityType, F as FeatureUtils, L as applyDefinitionDiff, B as applyModelMergerDiff, C as applyModelMergerResultInPlace, E as createAndApplyModelMergerResults, K as createDefinitionDiff, J as createDefinitionDiffConfig, w as createFeatureSchema, t as createInitializedPluginSpec, y as createModelMergerResult, A as createModelMergerResults, z as doesModelMergerResultsHaveChanges, v as featureNameSchema, x as modelMergerDefinitionDiffConfig } from '../model-merger-boZDknXa.js';
+import { importShared } from '../__federation_fn_import-B_QMlAIe.js';
 import { i as isEqual } from '../isEqual-DAXqKRba.js';
 import { s as sortBy } from '../sortBy-BPH_zRB8.js';
 
+function createAdminCrudActionCompilerImplementation() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const actions = new Map();
+    return {
+        registerCompiler(action) {
+            if (actions.has(action.name)) {
+                throw new Error(`Admin CRUD action with name ${action.name} is already registered`);
+            }
+            actions.set(action.name, action);
+        },
+        getCompiler(name, builtInActions = []) {
+            const builtInAction = builtInActions.find((b) => b.name === name);
+            if (builtInAction) {
+                return builtInAction;
+            }
+            const action = actions.get(name);
+            if (!action) {
+                throw new Error(`Unable to find action with name ${name}`);
+            }
+            return action;
+        },
+    };
+}
+/**
+ * Spec for adding config component for plugin
+ */
+const adminCrudActionCompilerSpec = createPluginSpec('core/admin-crud-action-compiler', { defaultInitializer: createAdminCrudActionCompilerImplementation });
+
+function createAdminCrudColumnCompiler(input) {
+    return input;
+}
+function createAdminCrudColumnCompilerImplementation() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const columns = new Map();
+    return {
+        registerCompiler(column) {
+            if (columns.has(column.name)) {
+                throw new Error(`Admin CRUD column with name ${column.name} is already registered`);
+            }
+            columns.set(column.name, column);
+        },
+        getCompiler(type, builtInColumns = []) {
+            const builtInColumn = builtInColumns.find((b) => b.name === type);
+            if (builtInColumn) {
+                return builtInColumn;
+            }
+            const column = columns.get(type);
+            if (!column) {
+                throw new Error(`Unable to find column with type ${type}`);
+            }
+            return column;
+        },
+        getColumnCompilers() {
+            return columns;
+        },
+    };
+}
+/**
+ * Spec for adding column compilers
+ */
+const adminCrudColumnCompilerSpec = createPluginSpec('core/admin-crud-column-compiler', { defaultInitializer: createAdminCrudColumnCompilerImplementation });
+
 function createAdminCrudInputCompilerImplementation() {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const inputs = new Map();
@@ -254,45 +316,45 @@ function getManagedPluginsForPlugin(pluginStore, pluginKey) {
         .map((p) => p.metadata);
 }
 
-const {z: z$k} = await importShared('zod');
+const {z: z$o} = await importShared('zod');
 
 // matches semver
-const versionSchema = z$k.string().regex(/^(\d+\.\d+\.\d+)$/);
-const pluginSpecSupportSchema = z$k.object({
-    spec: z$k.string().min(1),
-    version: z$k.string().min(1),
+const versionSchema = z$o.string().regex(/^(\d+\.\d+\.\d+)$/);
+const pluginSpecSupportSchema = z$o.object({
+    spec: z$o.string().min(1),
+    version: z$o.string().min(1),
 });
-const pluginSpecDependencySchema = z$k.object({
-    spec: z$k.string(),
-    version: z$k.string(),
+const pluginSpecDependencySchema = z$o.object({
+    spec: z$o.string(),
+    version: z$o.string(),
 });
 /**
  * Schema for the plugin's metadata (plugin.json)
  */
-const pluginMetadataSchema = z$k.object({
+const pluginMetadataSchema = z$o.object({
     /**
      * The name of the plugin - must be lowercase and contain only letters, numbers, and hyphens
      */
-    name: z$k
+    name: z$o
         .string()
         .min(1)
         .regex(/^[a-z0-9-]+$/),
     /**
      * A list of directories with entrypoints in them. Defaults to ['.']
      */
-    moduleDirectories: z$k.array(z$k.string()).optional(),
+    moduleDirectories: z$o.array(z$o.string()).optional(),
     /**
      * The display name of the plugin
      */
-    displayName: z$k.string().min(1),
+    displayName: z$o.string().min(1),
     /**
      * The icon to display for the plugin as a pointer to the icon in the plugin's static folder
      */
-    icon: z$k.string().optional(),
+    icon: z$o.string().optional(),
     /**
      * A description of the plugin
      */
-    description: z$k.string(),
+    description: z$o.string(),
     /**
      * The fully qualified name of the plugin that manages this plugin,
      * e.g. "@baseplate-dev/plugin-auth:auth0" would be managed by the "@baseplate-dev/plugin-auth:auth" plugin.
@@ -300,7 +362,7 @@ const pluginMetadataSchema = z$k.object({
      * Managed plugins do not appear in the plugin list but are managed by the base plugin. If the base
      * plugin is disabled, the managed plugins will also be disabled.
      */
-    managedBy: z$k.string().optional(),
+    managedBy: z$o.string().optional(),
     /**
      * The version of the plugin using semver
      */
@@ -308,16 +370,16 @@ const pluginMetadataSchema = z$k.object({
     /**
      * Configuration for the specs that the plugin exports/depends on
      */
-    specs: z$k
+    specs: z$o
         .object({
         /**
          * The specs that the plugin exports
          */
-        exports: z$k.array(pluginSpecSupportSchema).optional(),
+        exports: z$o.array(pluginSpecSupportSchema).optional(),
         /**
          * The specs that the plugin depends on
          */
-        dependencies: z$k.array(pluginSpecDependencySchema).optional(),
+        dependencies: z$o.array(pluginSpecDependencySchema).optional(),
     })
         .optional(),
     /**
@@ -325,7 +387,7 @@ const pluginMetadataSchema = z$k.object({
      *
      * (It can be used once in the definition but cannot be added)
      */
-    hidden: z$k.boolean().optional(),
+    hidden: z$o.boolean().optional(),
 });
 
 var NOTHING = Symbol.for("immer-nothing");
@@ -1771,30 +1833,30 @@ function createAppEntryType(name) {
 
 const {CASE_VALIDATORS: CASE_VALIDATORS$1} = await importShared('@baseplate-dev/utils');
 
-const {z: z$j} = await importShared('zod');
+const {z: z$n} = await importShared('zod');
 const baseAppValidators = {
-    id: z$j.string().default(appEntityType.generateNewId()),
+    id: z$n.string().default(appEntityType.generateNewId()),
     name: CASE_VALIDATORS$1.KEBAB_CASE,
-    type: z$j.string(),
-    packageLocation: z$j
+    type: z$n.string(),
+    packageLocation: z$n
         .string()
         .regex(/^(?!.*(?:\/|\.\.)\/)(?!^\.\.$)(?!^\.$)(?:[\w\-.]+\/?)+[\w\-.]*|^$/, {
         message: 'Invalid package location. Must be a valid subdirectory.',
     })
         .optional(),
 };
-const baseAppSchema = z$j.object(baseAppValidators);
+const baseAppSchema = z$n.object(baseAppValidators);
 
-const {z: z$i} = await importShared('zod');
-const createBackendAppSchema = definitionSchema(() => z$i.object({
+const {z: z$m} = await importShared('zod');
+const createBackendAppSchema = definitionSchema(() => z$m.object({
     ...baseAppValidators,
-    type: z$i.literal('backend'),
-    enableStripe: z$i.boolean().optional(),
-    enableRedis: z$i.boolean().optional(),
-    enableBullQueue: z$i.boolean().optional(),
-    enablePostmark: z$i.boolean().optional(),
-    enableSubscriptions: z$i.boolean().optional(),
-    enableAxios: z$i.boolean().optional(),
+    type: z$m.literal('backend'),
+    enableStripe: z$m.boolean().optional(),
+    enableRedis: z$m.boolean().optional(),
+    enableBullQueue: z$m.boolean().optional(),
+    enablePostmark: z$m.boolean().optional(),
+    enableSubscriptions: z$m.boolean().optional(),
+    enableAxios: z$m.boolean().optional(),
 }));
 const backendAppEntryType = createAppEntryType('backend');
 
@@ -2012,8 +2074,12 @@ class DefinitionRefBuilder {
         }
         // Resolve the name: if getNameResolver is provided, use it to build the name resolver; otherwise,
         // use the default name resolver.
-        const getNameResolver = entity.getNameResolver ?? ((value) => get(value, 'name'));
+        const getNameResolver = entity.getNameResolver ??
+            ((value) => get(value, 'name'));
         const nameResolver = getNameResolver(stripRefMarkers(this.data));
+        if (!nameResolver) {
+            throw new Error(`No name resolver found for entity ${entity.type.name} at ${path.join('.')}`);
+        }
         // Base entity definition shared between regular entities and those with a name reference.
         const entityBase = {
             id,
@@ -2425,141 +2491,141 @@ const SCALAR_FIELD_TYPES = [
     'enum',
 ];
 
-const {z: z$h} = await importShared('zod');
-const oklchColor = z$h
+const {z: z$l} = await importShared('zod');
+const oklchColor = z$l
     .string()
     .regex(/^oklch\(\s*([\d.]+)\s+([\d.]+)\s+([\d.]+)(?:\s*\/\s*([\d.]+))?\s*\)$/, {
     message: 'OKLCH color must be of the format "oklch(l c h [/ a])" where l and c are between 0 and 1 and h is between 0 and 360 and a is between 0 and 100',
 });
-const themeColorSchema = z$h.record(z$h.enum(THEME_COLOR_KEYS), oklchColor);
-const paletteSchema = z$h
+const themeColorSchema = z$l.record(z$l.enum(THEME_COLOR_KEYS), oklchColor);
+const paletteSchema = z$l
     .object({
-    paletteName: z$h.string().min(1),
+    paletteName: z$l.string().min(1),
     customBase: oklchColor.nullish(),
-    shades: z$h.record(z$h.enum(PALETTE_SHADES), oklchColor),
+    shades: z$l.record(z$l.enum(PALETTE_SHADES), oklchColor),
 })
     .refine((data) => data.paletteName !== 'custom' || !!data.paletteName, {
     message: 'A custom base color is required if using a custom base palette',
     path: ['customBase'],
 });
-const palettesSchema = z$h.object({
+const palettesSchema = z$l.object({
     base: paletteSchema,
     primary: paletteSchema,
 });
-const createThemeSchema = definitionSchema(() => z$h.object({
-    palettes: z$h.object({
+const createThemeSchema = definitionSchema(() => z$l.object({
+    palettes: z$l.object({
         base: paletteSchema,
         primary: paletteSchema,
     }),
-    colors: z$h.object({
+    colors: z$l.object({
         light: themeColorSchema,
         dark: themeColorSchema,
     }),
 }));
 
-const {z: z$g} = await importShared('zod');
+const {z: z$k} = await importShared('zod');
 
 const VALIDATORS = {
-    PASCAL_CASE_STRING: z$g
+    PASCAL_CASE_STRING: z$k
         .string()
         .regex(/^[A-Z][a-zA-Z0-9]*$/, "Should be PascalCase, e.g. 'MyModel'"),
-    CAMEL_CASE_STRING: z$g
+    CAMEL_CASE_STRING: z$k
         .string()
         .regex(/^[a-z][a-zA-Z0-9]*$/, "Should be camelCase, e.g. 'myField'"),
-    CONSTANT_CASE_STRING: z$g
+    CONSTANT_CASE_STRING: z$k
         .string()
         .regex(/^[A-Z][A-Z0-9_]*$/, "Should be CONSTANT_CASE, e.g. 'MY_CONSTANT'"),
-    OPTIONAL_CONSTANT_CASE_STRING: z$g
+    OPTIONAL_CONSTANT_CASE_STRING: z$k
         .string()
         .regex(/^[A-Z][A-Z0-9_]*$/, "Should be CONSTANT_CASE, e.g. 'MY_CONSTANT'")
-        .or(z$g.literal(''))
+        .or(z$k.literal(''))
         .optional(),
 };
 
-const {z: z$f} = await importShared('zod');
-const createRoleArray = definitionSchema((ctx) => ctx.withDefault(z$f.array(ctx.withRef({
+const {z: z$j} = await importShared('zod');
+const createRoleArray = definitionSchema((ctx) => ctx.withDefault(z$j.array(ctx.withRef({
     type: authRoleEntityType,
     onDelete: 'DELETE',
 })), []));
-const createModelGraphqlSchema = definitionSchema((ctx) => z$f.object({
-    objectType: ctx.withDefault(z$f.object({
-        enabled: ctx.withDefault(z$f.boolean(), false),
-        fields: ctx.withDefault(z$f.array(ctx.withRef({
+const createModelGraphqlSchema = definitionSchema((ctx) => z$j.object({
+    objectType: ctx.withDefault(z$j.object({
+        enabled: ctx.withDefault(z$j.boolean(), false),
+        fields: ctx.withDefault(z$j.array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
         })), []),
-        localRelations: ctx.withDefault(z$f.array(ctx.withRef({
+        localRelations: ctx.withDefault(z$j.array(ctx.withRef({
             type: modelLocalRelationEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
         })), []),
-        foreignRelations: ctx.withDefault(z$f.array(ctx.withRef({
+        foreignRelations: ctx.withDefault(z$j.array(ctx.withRef({
             type: modelForeignRelationEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
         })), []),
     }), {}),
-    queries: ctx.withDefault(z$f.object({
-        get: ctx.withDefault(z$f.object({
-            enabled: ctx.withDefault(z$f.boolean(), false),
+    queries: ctx.withDefault(z$j.object({
+        get: ctx.withDefault(z$j.object({
+            enabled: ctx.withDefault(z$j.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        list: ctx.withDefault(z$f.object({
-            enabled: ctx.withDefault(z$f.boolean(), false),
+        list: ctx.withDefault(z$j.object({
+            enabled: ctx.withDefault(z$j.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
     }), {}),
-    mutations: ctx.withDefault(z$f.object({
-        create: ctx.withDefault(z$f.object({
-            enabled: ctx.withDefault(z$f.boolean(), false),
+    mutations: ctx.withDefault(z$j.object({
+        create: ctx.withDefault(z$j.object({
+            enabled: ctx.withDefault(z$j.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        update: ctx.withDefault(z$f.object({
-            enabled: ctx.withDefault(z$f.boolean(), false),
+        update: ctx.withDefault(z$j.object({
+            enabled: ctx.withDefault(z$j.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        delete: ctx.withDefault(z$f.object({
-            enabled: ctx.withDefault(z$f.boolean(), false),
+        delete: ctx.withDefault(z$j.object({
+            enabled: ctx.withDefault(z$j.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
     }), {}),
 }));
 
-const {z: z$e} = await importShared('zod');
+const {z: z$i} = await importShared('zod');
 
 const baseTransformerFields = {
-    id: z$e.string(),
-    type: z$e.string().min(1),
+    id: z$i.string(),
+    type: z$i.string().min(1),
 };
-const baseTransformerSchema = z$e.object(baseTransformerFields);
+const baseTransformerSchema = z$i.object(baseTransformerFields);
 function createModelTransformerType(payload) {
     return payload;
 }
 
-const {z: z$d} = await importShared('zod');
-const createPasswordTransformerSchema = definitionSchema((ctx) => ctx.withEnt(z$d.object({
+const {z: z$h} = await importShared('zod');
+const createPasswordTransformerSchema = definitionSchema((ctx) => ctx.withEnt(z$h.object({
     ...baseTransformerFields,
-    type: z$d.literal('password'),
+    type: z$h.literal('password'),
 }), {
     type: modelTransformerEntityType,
     parentPath: { context: 'model' },
     getNameResolver: () => 'password',
 }));
-const createEmbeddedRelationTransformerSchema = definitionSchema((ctx) => ctx.withRefBuilder(ctx.withEnt(z$d.object({
+const createEmbeddedRelationTransformerSchema = definitionSchema((ctx) => ctx.withRefBuilder(ctx.withEnt(z$h.object({
     ...baseTransformerFields,
     foreignRelationRef: ctx.withRef({
         type: modelForeignRelationEntityType,
         onDelete: 'DELETE_PARENT',
         parentPath: { context: 'model' },
     }),
-    type: z$d.literal('embeddedRelation'),
-    embeddedFieldNames: z$d.array(ctx.withRef({
+    type: z$h.literal('embeddedRelation'),
+    embeddedFieldNames: z$h.array(ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'embeddedModel' },
     })),
-    embeddedTransformerNames: z$d
+    embeddedTransformerNames: z$h
         .array(ctx.withRef({
         type: modelTransformerEntityType,
         onDelete: 'RESTRICT',
@@ -2639,46 +2705,46 @@ const createTransformerSchema = definitionSchema((ctx) => baseTransformerSchema.
     });
 }));
 
-const {z: z$c} = await importShared('zod');
-const createEnumValueSchema = definitionSchema((ctx) => ctx.withEnt(z$c.object({
-    id: z$c.string(),
-    name: z$c.string().min(1),
-    friendlyName: z$c.string().min(1),
+const {z: z$g} = await importShared('zod');
+const createEnumValueSchema = definitionSchema((ctx) => ctx.withEnt(z$g.object({
+    id: z$g.string(),
+    name: z$g.string().min(1),
+    friendlyName: z$g.string().min(1),
 }), {
     type: modelEnumValueEntityType,
     parentPath: { context: 'enum' },
 }));
-const createEnumBaseSchema = definitionSchema((ctx) => z$c.object({
-    id: z$c.string(),
-    name: z$c.string().min(1),
+const createEnumBaseSchema = definitionSchema((ctx) => z$g.object({
+    id: z$g.string(),
+    name: z$g.string().min(1),
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    values: z$c.array(createEnumValueSchema(ctx)),
-    isExposed: z$c.boolean(),
+    values: z$g.array(createEnumValueSchema(ctx)),
+    isExposed: z$g.boolean(),
 }));
 const createEnumSchema = definitionSchema((ctx) => ctx.withEnt(createEnumBaseSchema(ctx), {
     type: modelEnumEntityType,
     addContext: 'enum',
 }));
 
-const {z: z$b} = await importShared('zod');
+const {z: z$f} = await importShared('zod');
 const createModelScalarFieldSchema = definitionSchema((ctx) => ctx
-    .withEnt(z$b.object({
-    id: z$b.string(),
+    .withEnt(z$f.object({
+    id: z$f.string(),
     name: VALIDATORS.CAMEL_CASE_STRING,
-    type: z$b.enum(SCALAR_FIELD_TYPES),
-    isOptional: z$b.boolean().default(false),
-    options: ctx.withRefBuilder(z$b
+    type: z$f.enum(SCALAR_FIELD_TYPES),
+    isOptional: z$f.boolean().default(false),
+    options: ctx.withRefBuilder(z$f
         .object({
         // string options
-        default: z$b.string().default(''),
+        default: z$f.string().default(''),
         // uuid options
-        genUuid: z$b.boolean().optional(),
+        genUuid: z$f.boolean().optional(),
         // date options
-        updatedAt: z$b.boolean().optional(),
-        defaultToNow: z$b.boolean().optional(),
+        updatedAt: z$f.boolean().optional(),
+        defaultToNow: z$f.boolean().optional(),
         // enum options
         enumRef: ctx
             .withRef({
@@ -2686,7 +2752,7 @@ const createModelScalarFieldSchema = definitionSchema((ctx) => ctx
             onDelete: 'RESTRICT',
         })
             .optional(),
-        defaultEnumValueRef: z$b.string().optional(),
+        defaultEnumValueRef: z$f.string().optional(),
     })
         .transform((val) => ({
         ...val,
@@ -2738,13 +2804,13 @@ const REFERENTIAL_ACTIONS = [
     'SetNull',
     'SetDefault',
 ];
-const createModelRelationFieldSchema = definitionSchema((ctx) => ctx.withRefBuilder(z$b.object({
-    id: z$b.string(),
-    foreignId: z$b
+const createModelRelationFieldSchema = definitionSchema((ctx) => ctx.withRefBuilder(z$f.object({
+    id: z$f.string(),
+    foreignId: z$f
         .string()
         .default(() => modelForeignRelationEntityType.generateNewId()),
     name: VALIDATORS.CAMEL_CASE_STRING,
-    references: z$b.array(z$b.object({
+    references: z$f.array(z$f.object({
         localRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
@@ -2756,10 +2822,10 @@ const createModelRelationFieldSchema = definitionSchema((ctx) => ctx.withRefBuil
             parentPath: { context: 'foreignModel' },
         }),
     })),
-    modelRef: z$b.string().min(1),
+    modelRef: z$f.string().min(1),
     foreignRelationName: VALIDATORS.CAMEL_CASE_STRING,
-    onDelete: z$b.enum(REFERENTIAL_ACTIONS).default('Cascade'),
-    onUpdate: z$b.enum(REFERENTIAL_ACTIONS).default('Restrict'),
+    onDelete: z$f.enum(REFERENTIAL_ACTIONS).default('Cascade'),
+    onUpdate: z$f.enum(REFERENTIAL_ACTIONS).default('Restrict'),
 }), (builder) => {
     builder.addReference({
         type: modelEntityType,
@@ -2778,9 +2844,9 @@ const createModelRelationFieldSchema = definitionSchema((ctx) => ctx.withRefBuil
         parentPath: 'modelRef',
     });
 }));
-const createModelUniqueConstraintSchema = definitionSchema((ctx) => ctx.withEnt(z$b.object({
-    id: z$b.string(),
-    fields: z$b.array(z$b.object({
+const createModelUniqueConstraintSchema = definitionSchema((ctx) => ctx.withEnt(z$f.object({
+    id: z$f.string(),
+    fields: z$f.array(z$f.object({
         fieldRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
@@ -2797,18 +2863,18 @@ const createModelUniqueConstraintSchema = definitionSchema((ctx) => ctx.withEnt(
         });
     },
 }));
-const createModelServiceSchema = definitionSchema((ctx) => z$b.object({
-    create: z$b
+const createModelServiceSchema = definitionSchema((ctx) => z$f.object({
+    create: z$f
         .object({
-        enabled: z$b.boolean().default(false),
-        fields: z$b
+        enabled: z$f.boolean().default(false),
+        fields: z$f
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
         }))
             .optional(),
-        transformerNames: z$b
+        transformerNames: z$f
             .array(ctx.withRef({
             type: modelTransformerEntityType,
             onDelete: 'DELETE',
@@ -2817,17 +2883,17 @@ const createModelServiceSchema = definitionSchema((ctx) => z$b.object({
             .optional(),
     })
         .default({ enabled: false }),
-    update: z$b
+    update: z$f
         .object({
-        enabled: z$b.boolean().default(false),
-        fields: z$b
+        enabled: z$f.boolean().default(false),
+        fields: z$f
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
         }))
             .optional(),
-        transformerNames: z$b
+        transformerNames: z$f
             .array(ctx.withRef({
             type: modelTransformerEntityType,
             onDelete: 'DELETE',
@@ -2836,33 +2902,33 @@ const createModelServiceSchema = definitionSchema((ctx) => z$b.object({
             .optional(),
     })
         .default({ enabled: false }),
-    delete: z$b
+    delete: z$f
         .object({
-        enabled: z$b.boolean().default(false),
+        enabled: z$f.boolean().default(false),
     })
         .default({
         enabled: false,
     }),
-    transformers: z$b.array(createTransformerSchema(ctx)).default([]),
+    transformers: z$f.array(createTransformerSchema(ctx)).default([]),
 }));
-const createModelBaseSchema = definitionSchema((ctx) => z$b.object({
-    id: z$b.string(),
+const createModelBaseSchema = definitionSchema((ctx) => z$f.object({
+    id: z$f.string(),
     name: VALIDATORS.PASCAL_CASE_STRING,
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    model: z$b.object({
-        fields: z$b.array(createModelScalarFieldSchema(ctx)),
-        relations: z$b.array(createModelRelationFieldSchema(ctx)).optional(),
-        primaryKeyFieldRefs: z$b
+    model: z$f.object({
+        fields: z$f.array(createModelScalarFieldSchema(ctx)),
+        relations: z$f.array(createModelRelationFieldSchema(ctx)).optional(),
+        primaryKeyFieldRefs: z$f
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
             parentPath: { context: 'model' },
         }))
             .min(1),
-        uniqueConstraints: z$b
+        uniqueConstraints: z$f
             .array(createModelUniqueConstraintSchema(ctx))
             .optional(),
     }),
@@ -2872,7 +2938,7 @@ const createModelBaseSchema = definitionSchema((ctx) => z$b.object({
         delete: { enabled: false },
         transformers: [],
     }),
-    graphql: createModelGraphqlSchema(ctx).optional(),
+    graphql: ctx.withDefault(createModelGraphqlSchema(ctx).optional(), {}),
 }));
 const createModelSchema = definitionSchema((ctx) => ctx.withEnt(createModelBaseSchema(ctx), {
     type: modelEntityType,
@@ -2882,21 +2948,212 @@ const createModelSchema = definitionSchema((ctx) => ctx.withEnt(createModelBaseS
 const adminSectionEntityType = createEntityType('admin-section', {
     parentType: appEntityType,
 });
+const adminCrudSectionColumnEntityType = createEntityType('admin-crud-section-column', {
+    parentType: adminSectionEntityType,
+});
 
-const {z: z$a} = await importShared('zod');
-const createBaseAdminSectionValidators = definitionSchema((ctx) => z$a.object({
-    id: z$a.string().default(adminSectionEntityType.generateNewId()),
-    name: z$a.string().min(1),
+const {z: z$e} = await importShared('zod');
+const createBaseAdminSectionValidators = definitionSchema((ctx) => z$e.object({
+    id: z$e.string().default(adminSectionEntityType.generateNewId()),
+    name: z$e.string().min(1),
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    icon: z$a.string().optional(),
-    type: z$a.string().min(1),
+    icon: z$e.string().optional(),
+    type: z$e.string().min(1),
+}));
+
+const {z: z$d} = await importShared('zod');
+const baseAdminCrudActionSchema = z$d.object({
+    id: z$d
+        .string()
+        .min(1)
+        .default(() => adminCrudActionEntityType.generateNewId()),
+    type: z$d.string().min(1),
+    position: z$d.enum(['inline', 'dropdown']).default('dropdown'),
+});
+function createAdminCrudActionType(payload) {
+    return payload;
+}
+const adminCrudActionEntityType = createEntityType('admin-crud-action', {
+    parentType: adminSectionEntityType,
+});
+
+const {z: z$c} = await importShared('zod');
+const createAdminCrudEditActionSchema = definitionSchema(() => baseAdminCrudActionSchema.extend({
+    type: z$c.literal('edit'),
+}));
+const adminCrudEditActionType = createAdminCrudActionType({
+    name: 'edit',
+    createSchema: createAdminCrudEditActionSchema,
+});
+const createAdminCrudDeleteActionSchema = definitionSchema(() => baseAdminCrudActionSchema.extend({
+    type: z$c.literal('delete'),
+}));
+const adminCrudDeleteActionType = createAdminCrudActionType({
+    name: 'delete',
+    createSchema: createAdminCrudDeleteActionSchema,
+});
+const BUILT_IN_ADMIN_CRUD_ACTIONS = [
+    adminCrudEditActionType,
+    adminCrudDeleteActionType,
+];
+
+function createAdminCrudActionImplementation() {
+    const adminCrudActions = new Map(BUILT_IN_ADMIN_CRUD_ACTIONS.map((action) => [action.name, action]));
+    return {
+        registerAdminCrudAction(action) {
+            if (adminCrudActions.has(action.name)) {
+                throw new Error(`Admin CRUD action with name ${action.name} is already registered`);
+            }
+            adminCrudActions.set(action.name, action);
+        },
+        getAdminCrudActions() {
+            return adminCrudActions;
+        },
+        getAdminCrudAction(name) {
+            const action = adminCrudActions.get(name);
+            if (!action) {
+                throw new Error(`Unable to find action with name ${name}`);
+            }
+            return action;
+        },
+    };
+}
+/**
+ * Spec for adding admin CRUD actions
+ */
+const adminCrudActionSpec = createPluginSpec('core/admin-crud-action', {
+    defaultInitializer: createAdminCrudActionImplementation,
+});
+
+const createAdminCrudActionSchema = definitionSchema((ctx) => ctx
+    .withEnt(baseAdminCrudActionSchema.passthrough(), {
+    type: adminCrudActionEntityType,
+    parentPath: {
+        context: 'admin-section',
+    },
+    getNameResolver: (value) => value.type,
+})
+    .transform((data, parseCtx) => {
+    const { type } = data;
+    const crudAction = ctx.plugins
+        .getPluginSpec(adminCrudActionSpec)
+        .getAdminCrudAction(type);
+    return crudAction
+        .createSchema(ctx)
+        .and(baseAdminCrudActionSchema)
+        .parse(data, {
+        path: parseCtx.path,
+    });
+}));
+
+const {z: z$b} = await importShared('zod');
+const baseAdminCrudColumnSchema = z$b.object({
+    id: z$b
+        .string()
+        .min(1)
+        .default(() => adminCrudColumnEntityType.generateNewId()),
+    type: z$b.string().min(1),
+    label: z$b.string().min(1),
+});
+function createAdminCrudColumnType(payload) {
+    return payload;
+}
+const adminCrudColumnEntityType = createEntityType('admin-crud-column', {
+    parentType: adminSectionEntityType,
+});
+
+const {z: z$a} = await importShared('zod');
+// Text Column
+const createAdminCrudTextColumnSchema = definitionSchema((ctx) => baseAdminCrudColumnSchema.extend({
+    type: z$a.literal('text'),
+    modelFieldRef: ctx.withRef({
+        type: modelScalarFieldEntityType,
+        onDelete: 'RESTRICT',
+        parentPath: { context: 'model' },
+    }),
+}));
+const adminCrudTextColumnType = createAdminCrudColumnType({
+    name: 'text',
+    createSchema: createAdminCrudTextColumnSchema,
+});
+// Foreign Column
+const createAdminCrudForeignColumnSchema = definitionSchema((ctx) => baseAdminCrudColumnSchema.extend({
+    type: z$a.literal('foreign'),
+    localRelationRef: ctx.withRef({
+        type: modelLocalRelationEntityType,
+        onDelete: 'RESTRICT',
+        parentPath: { context: 'model' },
+    }),
+    labelExpression: z$a.string().min(1),
+    valueExpression: z$a.string().min(1),
+}));
+const adminCrudForeignColumnType = createAdminCrudColumnType({
+    name: 'foreign',
+    createSchema: createAdminCrudForeignColumnSchema,
+});
+const BUILT_IN_ADMIN_CRUD_COLUMNS = [
+    adminCrudTextColumnType,
+    adminCrudForeignColumnType,
+];
+
+function createAdminCrudColumnImplementation() {
+    const adminCrudColumns = new Map(BUILT_IN_ADMIN_CRUD_COLUMNS.map((column) => [column.name, column]));
+    return {
+        registerAdminCrudColumn(column) {
+            if (adminCrudColumns.has(column.name)) {
+                throw new Error(`Admin CRUD column with name ${column.name} is already registered`);
+            }
+            adminCrudColumns.set(column.name, column);
+        },
+        getAdminCrudColumns() {
+            return adminCrudColumns;
+        },
+        getAdminCrudColumn(name) {
+            const column = adminCrudColumns.get(name);
+            if (!column) {
+                throw new Error(`Unable to find column with name ${name}`);
+            }
+            return column;
+        },
+    };
+}
+/**
+ * Spec for adding admin CRUD columns
+ */
+const adminCrudColumnSpec = createPluginSpec('core/admin-crud-column', {
+    defaultInitializer: createAdminCrudColumnImplementation,
+});
+
+const createAdminCrudColumnSchema = definitionSchema((ctx) => ctx
+    .withEnt(baseAdminCrudColumnSchema.passthrough(), {
+    type: adminCrudColumnEntityType,
+    parentPath: {
+        context: 'admin-section',
+    },
+    getNameResolver: (value) => value.type,
+})
+    .transform((data, parseCtx) => {
+    const { type } = data;
+    const crudColumn = ctx.plugins
+        .getPluginSpec(adminCrudColumnSpec)
+        .getAdminCrudColumn(type);
+    return crudColumn
+        .createSchema(ctx)
+        .and(baseAdminCrudColumnSchema)
+        .parse(data, {
+        path: parseCtx.path,
+    });
 }));
 
 const {z: z$9} = await importShared('zod');
 const baseAdminCrudInputSchema = z$9.object({
+    id: z$9
+        .string()
+        .min(1)
+        .default(() => adminCrudInputEntityType.generateNewId()),
     type: z$9.string().min(1),
     label: z$9.string().min(1),
 });
@@ -2906,9 +3163,12 @@ function createAdminCrudInputType(payload) {
 const adminCrudEmbeddedFormEntityType = createEntityType('admin-crud-embedded-form', {
     parentType: adminSectionEntityType,
 });
+const adminCrudInputEntityType = createEntityType('admin-crud-input', {
+    parentType: adminSectionEntityType,
+});
 
 const {z: z$8} = await importShared('zod');
-const createAdminCrudTextInputSchema = definitionSchema((ctx) => z$8.object({
+const createAdminCrudTextInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.extend({
     type: z$8.literal('text'),
     label: z$8.string().min(1),
     modelFieldRef: ctx.withRef({
@@ -2922,7 +3182,7 @@ const adminCrudTextInputType = createAdminCrudInputType({
     name: 'text',
     createSchema: createAdminCrudTextInputSchema,
 });
-const createAdminCrudForeignInputSchema = definitionSchema((ctx) => z$8.object({
+const createAdminCrudForeignInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.extend({
     type: z$8.literal('foreign'),
     label: z$8.string().min(1),
     localRelationRef: ctx.withRef({
@@ -2939,7 +3199,7 @@ const adminCrudForeignInputType = createAdminCrudInputType({
     name: 'foreign',
     createSchema: createAdminCrudForeignInputSchema,
 });
-const createAdminCrudEnumInputSchema = definitionSchema((ctx) => z$8.object({
+const createAdminCrudEnumInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.extend({
     type: z$8.literal('enum'),
     label: z$8.string().min(1),
     modelFieldRef: ctx.withRef({
@@ -2952,7 +3212,7 @@ const adminCrudEnumInputType = createAdminCrudInputType({
     name: 'enum',
     createSchema: createAdminCrudEnumInputSchema,
 });
-const createAdminCrudEmbeddedInputSchema = definitionSchema((ctx) => z$8.object({
+const createAdminCrudEmbeddedInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.extend({
     type: z$8.literal('embedded'),
     label: z$8.string().min(1),
     modelRelationRef: ctx.withRef({
@@ -2970,7 +3230,7 @@ const adminCrudEmbeddedInputType = createAdminCrudInputType({
     name: 'embedded',
     createSchema: createAdminCrudEmbeddedInputSchema,
 });
-const createAdminCrudEmbeddedLocalInputSchema = definitionSchema((ctx) => z$8.object({
+const createAdminCrudEmbeddedLocalInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.extend({
     type: z$8.literal('embeddedLocal'),
     label: z$8.string().min(1),
     localRelationRef: ctx.withRef({
@@ -2988,7 +3248,7 @@ const adminCrudEmbeddedLocalInputType = createAdminCrudInputType({
     name: 'embeddedLocal',
     createSchema: createAdminCrudEmbeddedLocalInputSchema,
 });
-const createAdminCrudPasswordInputSchema = definitionSchema(() => z$8.object({
+const createAdminCrudPasswordInputSchema = definitionSchema(() => baseAdminCrudInputSchema.extend({
     type: z$8.literal('password'),
     label: z$8.string().min(1),
 }));
@@ -3033,7 +3293,15 @@ const adminCrudInputSpec = createPluginSpec('core/admin-crud-input', {
     defaultInitializer: createAdminCrudInputImplementation,
 });
 
-const createAdminCrudInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.passthrough().transform((data, parseCtx) => {
+const createAdminCrudInputSchema = definitionSchema((ctx) => ctx
+    .withEnt(baseAdminCrudInputSchema.passthrough(), {
+    type: adminCrudInputEntityType,
+    parentPath: {
+        context: 'admin-section',
+    },
+    getNameResolver: (value) => value.id ?? '',
+})
+    .transform((data, parseCtx) => {
     const { type } = data;
     const crudInput = ctx.plugins
         .getPluginSpec(adminCrudInputSpec)
@@ -3047,35 +3315,6 @@ const createAdminCrudInputSchema = definitionSchema((ctx) => baseAdminCrudInputS
 }));
 
 const {z: z$7} = await importShared('zod');
-// Table Columns
-const createAdminCrudForeignDisplaySchema = definitionSchema((ctx) => z$7.object({
-    type: z$7.literal('foreign'),
-    localRelationRef: ctx.withRef({
-        type: modelLocalRelationEntityType,
-        onDelete: 'RESTRICT',
-        parentPath: { context: 'model' },
-    }),
-    labelExpression: z$7.string().min(1),
-    valueExpression: z$7.string().min(1),
-}));
-const createAdminCrudTextDisplaySchema = definitionSchema((ctx) => z$7.object({
-    type: z$7.literal('text'),
-    modelFieldRef: ctx.withRef({
-        type: modelScalarFieldEntityType,
-        onDelete: 'RESTRICT',
-        parentPath: { context: 'model' },
-    }),
-}));
-const createAdminCrudDisplaySchema = definitionSchema((ctx) => z$7.discriminatedUnion('type', [
-    createAdminCrudTextDisplaySchema(ctx),
-    createAdminCrudForeignDisplaySchema(ctx),
-]));
-// TODO: Improve this to be more dynamic in the future
-const adminCrudDisplayTypes = ['text', 'foreign'];
-const createAdminCrudTableColumnSchema = definitionSchema((ctx) => z$7.object({
-    label: z$7.string().min(1),
-    display: createAdminCrudDisplaySchema(ctx),
-}));
 // Embedded Crud
 const createAdminCrudEmbeddedObjectSchema = definitionSchema((ctx) => z$7.object({
     id: z$7.string().min(1),
@@ -3099,10 +3338,8 @@ const createAdminCrudEmbeddedListSchema = definitionSchema((ctx) => z$7.object({
     }),
     includeIdField: z$7.boolean().optional(),
     type: z$7.literal('list'),
-    // NOTE: These two fields need to be synced with crud section schema
-    // because the web app expects that (TODO)
     table: z$7.object({
-        columns: z$7.array(createAdminCrudTableColumnSchema(ctx)),
+        columns: z$7.array(createAdminCrudColumnSchema(ctx)),
     }),
     form: z$7.object({
         fields: z$7.array(createAdminCrudInputSchema(ctx)),
@@ -3125,9 +3362,21 @@ const createAdminCrudSectionSchema = definitionSchema((ctx) => ctx.withRefBuilde
         type: modelEntityType,
         onDelete: 'RESTRICT',
     }),
+    /* The field that will be used to display the name of the entity in the form */
+    nameFieldRef: ctx.withRef({
+        type: modelScalarFieldEntityType,
+        onDelete: 'RESTRICT',
+        parentPath: {
+            context: 'model',
+        },
+    }),
     disableCreate: ctx.withDefault(z$7.boolean(), false),
     table: z$7.object({
-        columns: z$7.array(createAdminCrudTableColumnSchema(ctx)),
+        columns: z$7.array(createAdminCrudColumnSchema(ctx)),
+        actions: ctx.withDefault(z$7.array(createAdminCrudActionSchema(ctx)), [
+            { type: 'edit', position: 'inline' },
+            { type: 'delete', position: 'dropdown' },
+        ]),
     }),
     form: z$7.object({
         fields: z$7.array(createAdminCrudInputSchema(ctx)),
@@ -3450,7 +3699,13 @@ const PluginUtils = {
 };
 
 const {z} = await importShared('zod');
-const COMMON_SPEC_IMPLEMENTATIONS = [pluginConfigSpec, modelTransformerSpec, adminCrudInputSpec];
+const COMMON_SPEC_IMPLEMENTATIONS = [
+    pluginConfigSpec,
+    modelTransformerSpec,
+    adminCrudInputSpec,
+    adminCrudActionSpec,
+    adminCrudColumnSpec,
+];
 /**
  * Creates a plugin implementation store from the project definition and plugin store,
  * initializing the set of plugins enabled in the project definition.
@@ -8751,6 +9006,132 @@ const migration017RenameAuthPlugin = createSchemaMigration({
     },
 });
 
+const migration018CrudNameFieldRef = createSchemaMigration({
+    version: 18,
+    name: 'crudNameFieldRef',
+    description: 'Add nameFieldRef to CRUD sections, defaulting to name, title, id, or first field',
+    migrate: (config) => {
+        if (!config.apps || !config.models) {
+            return config;
+        }
+        const apps = config.apps.map((app) => {
+            // Only process apps with adminApp and sections
+            if (!app.adminApp?.sections) {
+                return app;
+            }
+            const sections = app.adminApp.sections.map((section) => {
+                // Only process CRUD sections without nameFieldRef
+                if (section.type !== 'crud' || section.nameFieldRef) {
+                    return section;
+                }
+                // Find the model for this section
+                const model = config.models?.find((m) => m.name === section.modelRef);
+                if (!model?.model.fields || model.model.fields.length === 0) {
+                    throw new Error(`Model ${section.modelRef} has no fields`);
+                }
+                // Find field by priority: name, title, id, then first field
+                let selectedField = model.model.fields.find((f) => f.name === 'name');
+                selectedField ?? (selectedField = model.model.fields.find((f) => f.name === 'title'));
+                selectedField ?? (selectedField = model.model.fields.find((f) => f.name === 'id'));
+                selectedField ?? (selectedField = model.model.fields[0]);
+                return {
+                    ...section,
+                    nameFieldRef: selectedField.name,
+                };
+            });
+            return {
+                ...app,
+                adminApp: {
+                    ...app.adminApp,
+                    sections,
+                },
+            };
+        });
+        return {
+            ...config,
+            apps,
+        };
+    },
+});
+
+function migrateColumn(oldColumn) {
+    const { display, id, ...rest } = oldColumn;
+    return {
+        id: id?.replace('admin-crud-section-column', 'admin-crud-column'),
+        ...rest,
+        type: display.type,
+        ...(display.modelFieldRef && { modelFieldRef: display.modelFieldRef }),
+        ...(display.localRelationRef && {
+            localRelationRef: display.localRelationRef,
+        }),
+        ...(display.labelExpression && {
+            labelExpression: display.labelExpression,
+        }),
+        ...(display.valueExpression && {
+            valueExpression: display.valueExpression,
+        }),
+    };
+}
+function migrateColumns(columns) {
+    if (!columns || columns.length === 0) {
+        return [];
+    }
+    return columns.map(migrateColumn);
+}
+const migration019ColumnTypeBased = createSchemaMigration({
+    version: 19,
+    name: 'columnTypeBased',
+    description: 'Migrate admin CRUD columns from display-based to type-based structure',
+    migrate: (config) => {
+        if (!config.apps) {
+            return config;
+        }
+        const apps = config.apps.map((app) => {
+            // Only process apps with adminApp and sections
+            if (!app.adminApp?.sections) {
+                return app;
+            }
+            const sections = app.adminApp.sections.map((section) => {
+                const updatedSection = { ...section };
+                // Migrate main table columns
+                if (section.table?.columns) {
+                    updatedSection.table = {
+                        ...section.table,
+                        columns: migrateColumns(section.table.columns),
+                    };
+                }
+                // Migrate embedded form table columns
+                if (section.embeddedForms) {
+                    updatedSection.embeddedForms = section.embeddedForms.map((form) => {
+                        if (form.table?.columns) {
+                            return {
+                                ...form,
+                                table: {
+                                    ...form.table,
+                                    columns: migrateColumns(form.table.columns),
+                                },
+                            };
+                        }
+                        return form;
+                    });
+                }
+                return updatedSection;
+            });
+            return {
+                ...app,
+                adminApp: {
+                    ...app.adminApp,
+                    sections,
+                },
+            };
+        });
+        return {
+            ...config,
+            apps,
+        };
+    },
+});
+
 const SCHEMA_MIGRATIONS = [
     migration005PrimaryUniqueRefs,
     migration006IndividualServiceControllers,
@@ -8765,6 +9146,8 @@ const SCHEMA_MIGRATIONS = [
     migration015NullParentRefs,
     migration016WebAdminConfig,
     migration017RenameAuthPlugin,
+    migration018CrudNameFieldRef,
+    migration019ColumnTypeBased,
 ];
 function isMigrateableProjectDefinition(projectDefinition) {
     return (typeof projectDefinition === 'object' &&
@@ -9903,5 +10286,5 @@ function generateDefaultTheme() {
     };
 }
 
-export { AVAILABLE_FLAGS, AppUtils, BUILT_IN_ADMIN_CRUD_INPUTS, BUILT_IN_TRANSFORMERS, COLOR_PALETTES, DefinitionRefBuilder, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, PluginImplementationStore, PluginUtils, ProjectDefinitionContainer, REFERENTIAL_ACTIONS, SCALAR_FIELD_TYPES, SCHEMA_MIGRATIONS, SchemaMigrationError, THEME_COLORS, THEME_COLOR_KEYS, VALIDATORS, adminCrudDisplayTypes, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedInputType, adminCrudEmbeddedLocalInputType, adminCrudInputCompilerSpec, adminCrudInputSpec, adminSectionEntityType, appCompilerSpec, appEntityType, authConfigSpec, authModelConfigSpec, authRoleEntityType, backendAppEntryType, baseAdminCrudInputSchema, baseAppSchema, baseAppValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminAppSchema, createAdminCrudDisplaySchema, createAdminCrudEmbeddedFormSchema, createAdminCrudEmbeddedInputSchema, createAdminCrudEmbeddedListSchema, createAdminCrudEmbeddedLocalInputSchema, createAdminCrudEmbeddedObjectSchema, createAdminCrudEnumInputSchema, createAdminCrudForeignDisplaySchema, createAdminCrudForeignInputSchema, createAdminCrudInputCompilerImplementation, createAdminCrudInputImplementation, createAdminCrudInputSchema, createAdminCrudInputType, createAdminCrudPasswordInputSchema, createAdminCrudSectionSchema, createAdminCrudTableColumnSchema, createAdminCrudTextDisplaySchema, createAdminCrudTextInputSchema, createAppCompiler, createAppCompilerPlugin, createAppEntryType, createAppSchema, createBackendAppSchema, createBaseAdminSectionValidators, createDefinitionEntityNameResolver, createDefinitionSchemaParserContext, createEmbeddedRelationTransformerSchema, createEntityType, createEnumBaseSchema, createEnumSchema, createEnumValueSchema, createFeaturesSchema, createModelBaseSchema, createModelGraphqlSchema, createModelRelationFieldSchema, createModelScalarFieldSchema, createModelSchema, createModelServiceSchema, createModelTransformerCompilerImplementation, createModelTransformerImplementation, createModelTransformerType, createModelUniqueConstraintSchema, createPasswordTransformerSchema, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginImplementationStoreWithNewPlugins, createPluginSpec, createPluginWithConfigSchema, createPluginsSchema, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTemplateExtractorSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createThemeSchema, createTransformerSchema, createWebAdminSectionSchema, createWebAppSchema, createWebConfigImplementation, definitionSchema, deserializeSchemaWithTransformedReferences, extractDefinitionRefs, extractDefinitionRefsRecursive, featureEntityType, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, getManagedPluginsForPlugin, getPluginMetadataByKey, getPluginMetadataByKeyOrThrow, initializePlugins, isMigrateableProjectDefinition, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelLocalRelationEntityType, modelScalarFieldEntityType, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, oklchColor, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, pluginConfigSpec, pluginEntityType, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, themeColorSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webConfigSpec };
-//# sourceMappingURL=project-builder-lib-CGEZr0YI.js.map
+export { AVAILABLE_FLAGS, AppUtils, BUILT_IN_ADMIN_CRUD_ACTIONS, BUILT_IN_ADMIN_CRUD_COLUMNS, BUILT_IN_ADMIN_CRUD_INPUTS, BUILT_IN_TRANSFORMERS, COLOR_PALETTES, DefinitionRefBuilder, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, PluginImplementationStore, PluginUtils, ProjectDefinitionContainer, REFERENTIAL_ACTIONS, SCALAR_FIELD_TYPES, SCHEMA_MIGRATIONS, SchemaMigrationError, THEME_COLORS, THEME_COLOR_KEYS, VALIDATORS, adminCrudActionCompilerSpec, adminCrudActionEntityType, adminCrudActionSpec, adminCrudColumnCompilerSpec, adminCrudColumnEntityType, adminCrudColumnSpec, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedInputType, adminCrudEmbeddedLocalInputType, adminCrudInputCompilerSpec, adminCrudInputEntityType, adminCrudInputSpec, adminCrudSectionColumnEntityType, adminSectionEntityType, appCompilerSpec, appEntityType, authConfigSpec, authModelConfigSpec, authRoleEntityType, backendAppEntryType, baseAdminCrudActionSchema, baseAdminCrudColumnSchema, baseAdminCrudInputSchema, baseAppSchema, baseAppValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminAppSchema, createAdminCrudActionCompilerImplementation, createAdminCrudActionImplementation, createAdminCrudActionSchema, createAdminCrudActionType, createAdminCrudColumnCompiler, createAdminCrudColumnCompilerImplementation, createAdminCrudColumnImplementation, createAdminCrudColumnSchema, createAdminCrudColumnType, createAdminCrudDeleteActionSchema, createAdminCrudEditActionSchema, createAdminCrudEmbeddedFormSchema, createAdminCrudEmbeddedInputSchema, createAdminCrudEmbeddedListSchema, createAdminCrudEmbeddedLocalInputSchema, createAdminCrudEmbeddedObjectSchema, createAdminCrudEnumInputSchema, createAdminCrudForeignColumnSchema, createAdminCrudForeignInputSchema, createAdminCrudInputCompilerImplementation, createAdminCrudInputImplementation, createAdminCrudInputSchema, createAdminCrudInputType, createAdminCrudPasswordInputSchema, createAdminCrudSectionSchema, createAdminCrudTextColumnSchema, createAdminCrudTextInputSchema, createAppCompiler, createAppCompilerPlugin, createAppEntryType, createAppSchema, createBackendAppSchema, createBaseAdminSectionValidators, createDefinitionEntityNameResolver, createDefinitionSchemaParserContext, createEmbeddedRelationTransformerSchema, createEntityType, createEnumBaseSchema, createEnumSchema, createEnumValueSchema, createFeaturesSchema, createModelBaseSchema, createModelGraphqlSchema, createModelRelationFieldSchema, createModelScalarFieldSchema, createModelSchema, createModelServiceSchema, createModelTransformerCompilerImplementation, createModelTransformerImplementation, createModelTransformerType, createModelUniqueConstraintSchema, createPasswordTransformerSchema, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginImplementationStoreWithNewPlugins, createPluginSpec, createPluginWithConfigSchema, createPluginsSchema, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTemplateExtractorSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createThemeSchema, createTransformerSchema, createWebAdminSectionSchema, createWebAppSchema, createWebConfigImplementation, definitionSchema, deserializeSchemaWithTransformedReferences, extractDefinitionRefs, extractDefinitionRefsRecursive, featureEntityType, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, getManagedPluginsForPlugin, getPluginMetadataByKey, getPluginMetadataByKeyOrThrow, initializePlugins, isMigrateableProjectDefinition, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelLocalRelationEntityType, modelScalarFieldEntityType, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, oklchColor, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, pluginConfigSpec, pluginEntityType, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, themeColorSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webConfigSpec };
+//# sourceMappingURL=project-builder-lib-BvG5Zcxb.js.map