@memberjunction/codegen-lib 6.1.4 → 6.2.0-edge.1

package/dist/Database/heal-schema-params.d.ts

@@ -12,19 +12,31 @@
  *   - `includeSchemas` as `@IncludedSchemaNames` when set
  */
 export interface HealSchemaRoutineParams {
-    values: string[];
-    names: string[];
+    Values: string[];
+    Names: string[];
 }
 /** Capture the config exclude list before `applyIncludeSchemaScope` mutates it. Idempotent. */
+export declare function SnapshotAuthoredExcludeSchemas(excludeSchemas: string[] | undefined): void;
+/** @deprecated Use {@link SnapshotAuthoredExcludeSchemas}. */
 export declare function snapshotAuthoredExcludeSchemas(excludeSchemas: string[] | undefined): void;
 /** Test-only: reset the snapshot between cases. */
+export declare function ResetAuthoredExcludeSnapshot(): void;
+/** @deprecated Use {@link ResetAuthoredExcludeSnapshot}. */
 export declare function resetAuthoredExcludeSnapshot(): void;
+export declare function GetAuthoredExcludeSchemas(fallback?: string[]): string[];
+/** @deprecated Use {@link GetAuthoredExcludeSchemas}. */
 export declare function getAuthoredExcludeSchemas(fallback?: string[]): string[];
 /**
  * Named-parameter lists for a heal SP call.
  * `@IncludedSchemaNames` is omitted when `includeSchemas` is empty so classic
  * MJ (no include list) keeps the historical EXEC shape.
  */
+export declare function BuildHealSchemaRoutineParams(options: {
+    authoredExclude: string[];
+    includeSchemas?: string[] | null;
+    entityIDs?: string[];
+}): HealSchemaRoutineParams;
+/** @deprecated Use {@link BuildHealSchemaRoutineParams}. */
 export declare function buildHealSchemaRoutineParams(options: {
     authoredExclude: string[];
     includeSchemas?: string[] | null;

package/dist/Database/heal-schema-params.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heal-schema-params.d.ts","sourceRoot":"","sources":["../../src/Database/heal-schema-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,uBAAuB;IACpC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;CACnB;AAID,+FAA+F;AAC/F,wBAAgB,8BAA8B,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,IAAI,CAIzF;AAED,mDAAmD;AACnD,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAKvE;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE;IAClD,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,GAAG,uBAAuB,CAiB1B"}
+{"version":3,"file":"heal-schema-params.d.ts","sourceRoot":"","sources":["../../src/Database/heal-schema-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,uBAAuB;IACpC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;CACnB;AAID,+FAA+F;AAC/F,wBAAgB,8BAA8B,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,IAAI,CAIzF;AAED,8DAA8D;AAC9D,wBAAgB,8BAA8B,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,IAAI,CAEzF;AAED,mDAAmD;AACnD,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,4DAA4D;AAC5D,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAKvE;AAED,yDAAyD;AACzD,wBAAgB,yBAAyB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAEvE;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE;IAClD,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,GAAG,uBAAuB,CAiB1B;AAED,4DAA4D;AAC5D,wBAAgB,4BAA4B,CAAC,OAAO,EAAE;IAClD,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,GAAG,uBAAuB,CAE1B"}

package/dist/Database/heal-schema-params.js

@@ -13,27 +13,39 @@
  */
 let authoredExcludeSchemas = null;
 /** Capture the config exclude list before `applyIncludeSchemaScope` mutates it. Idempotent. */
-export function snapshotAuthoredExcludeSchemas(excludeSchemas) {
+export function SnapshotAuthoredExcludeSchemas(excludeSchemas) {
     if (authoredExcludeSchemas === null) {
         authoredExcludeSchemas = [...(excludeSchemas ?? [])];
     }
 }
+/** @deprecated Use {@link SnapshotAuthoredExcludeSchemas}. */
+export function snapshotAuthoredExcludeSchemas(excludeSchemas) {
+    return SnapshotAuthoredExcludeSchemas(excludeSchemas);
+}
 /** Test-only: reset the snapshot between cases. */
-export function resetAuthoredExcludeSnapshot() {
+export function ResetAuthoredExcludeSnapshot() {
     authoredExcludeSchemas = null;
 }
-export function getAuthoredExcludeSchemas(fallback) {
+/** @deprecated Use {@link ResetAuthoredExcludeSnapshot}. */
+export function resetAuthoredExcludeSnapshot() {
+    return ResetAuthoredExcludeSnapshot();
+}
+export function GetAuthoredExcludeSchemas(fallback) {
     if (authoredExcludeSchemas !== null) {
         return authoredExcludeSchemas;
     }
     return [...(fallback ?? [])];
 }
+/** @deprecated Use {@link GetAuthoredExcludeSchemas}. */
+export function getAuthoredExcludeSchemas(fallback) {
+    return GetAuthoredExcludeSchemas(fallback);
+}
 /**
  * Named-parameter lists for a heal SP call.
  * `@IncludedSchemaNames` is omitted when `includeSchemas` is empty so classic
  * MJ (no include list) keeps the historical EXEC shape.
  */
-export function buildHealSchemaRoutineParams(options) {
+export function BuildHealSchemaRoutineParams(options) {
     const exclude = options.authoredExclude.join(',');
     const values = [`'${exclude}'`];
     const names = ['ExcludedSchemaNames'];
@@ -46,6 +58,10 @@ export function buildHealSchemaRoutineParams(options) {
         values.push(`'${include.join(',')}'`);
         names.push('IncludedSchemaNames');
     }
-    return { values, names };
+    return { Values: values, Names: names };
+}
+/** @deprecated Use {@link BuildHealSchemaRoutineParams}. */
+export function buildHealSchemaRoutineParams(options) {
+    return BuildHealSchemaRoutineParams(options);
 }
 //# sourceMappingURL=heal-schema-params.js.map

package/dist/Database/heal-schema-params.js.map

@@ -1 +1 @@
-{"version":3,"file":"heal-schema-params.js","sourceRoot":"","sources":["../../src/Database/heal-schema-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,IAAI,sBAAsB,GAAoB,IAAI,CAAC;AAEnD,+FAA+F;AAC/F,MAAM,UAAU,8BAA8B,CAAC,cAAoC;IAC/E,IAAI,sBAAsB,KAAK,IAAI,EAAE,CAAC;QAClC,sBAAsB,GAAG,CAAC,GAAG,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,CAAC;IACzD,CAAC;AACL,CAAC;AAED,mDAAmD;AACnD,MAAM,UAAU,4BAA4B;IACxC,sBAAsB,GAAG,IAAI,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,QAAmB;IACzD,IAAI,sBAAsB,KAAK,IAAI,EAAE,CAAC;QAClC,OAAO,sBAAsB,CAAC;IAClC,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,CAAC;AACjC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAAC,OAI5C;IACG,MAAM,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClD,MAAM,MAAM,GAAa,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAa,CAAC,qBAAqB,CAAC,CAAC;IAEhD,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAClE,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChD,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC5B,CAAC;IAED,MAAM,OAAO,GAAG,CAAC,OAAO,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAChG,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACtC,KAAK,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACtC,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;AAC7B,CAAC"}
+{"version":3,"file":"heal-schema-params.js","sourceRoot":"","sources":["../../src/Database/heal-schema-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,IAAI,sBAAsB,GAAoB,IAAI,CAAC;AAEnD,+FAA+F;AAC/F,MAAM,UAAU,8BAA8B,CAAC,cAAoC;IAC/E,IAAI,sBAAsB,KAAK,IAAI,EAAE,CAAC;QAClC,sBAAsB,GAAG,CAAC,GAAG,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,CAAC;IACzD,CAAC;AACL,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,8BAA8B,CAAC,cAAoC;IAC/E,OAAO,8BAA8B,CAAC,cAAc,CAAC,CAAC;AAC1D,CAAC;AAED,mDAAmD;AACnD,MAAM,UAAU,4BAA4B;IACxC,sBAAsB,GAAG,IAAI,CAAC;AAClC,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,4BAA4B;IACxC,OAAO,4BAA4B,EAAE,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,QAAmB;IACzD,IAAI,sBAAsB,KAAK,IAAI,EAAE,CAAC;QAClC,OAAO,sBAAsB,CAAC;IAClC,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,CAAC;AACjC,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,yBAAyB,CAAC,QAAmB;IACzD,OAAO,yBAAyB,CAAC,QAAQ,CAAC,CAAC;AAC/C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAAC,OAI5C;IACG,MAAM,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClD,MAAM,MAAM,GAAa,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAa,CAAC,qBAAqB,CAAC,CAAC;IAEhD,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAClE,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChD,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC5B,CAAC;IAED,MAAM,OAAO,GAAG,CAAC,OAAO,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAChG,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACtC,KAAK,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACtC,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AAC5C,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,4BAA4B,CAAC,OAI5C;IACG,OAAO,4BAA4B,CAAC,OAAO,CAAC,CAAC;AACjD,CAAC"}

package/dist/Database/manage-metadata.d.ts

@@ -7,7 +7,7 @@ import { EntityFieldExtendedType, EntityFieldInfo, EntityInfo, ExternalDataSourc
 import { SQLUtilityBase } from "./sql.js";
 import { AdvancedGeneration, SmartFieldIdentificationResult, FormLayoutResult, VirtualEntityDecorationResult } from "../Misc/advanced_generation.js";
 import { FieldChangeReason, EntityFieldSnapshotRow } from './entity-field-change-tracking.js';
-export { TRACKED_FIELD_COLUMNS, FieldChangeReason, DISPLAYNAME_REOPEN_REASONS, TYPE_REOPEN_REASONS, EntityFieldSnapshotRow, EntityFieldChange, diffEntityFieldSnapshots, } from './entity-field-change-tracking.js';
+export { TRACKED_FIELD_COLUMNS, FieldChangeReason, DISPLAYNAME_REOPEN_REASONS, TYPE_REOPEN_REASONS, EntityFieldSnapshotRow, EntityFieldChange, DiffEntityFieldSnapshots, diffEntityFieldSnapshots, } from './entity-field-change-tracking.js';
 export declare class ValidatorResult {
     entityName: string;
     fieldName?: string;
@@ -150,7 +150,12 @@ export interface OrganicKeyTransitiveViewConfig {
     Name: string;
     /** The schema to create the view in (defaults to the related entity's schema if not specified) */
     SchemaName?: string;
-    /** Raw SQL for the view body (the SELECT statement). CodeGen emits CREATE OR ALTER VIEW wrapping this. */
+    /**
+     * Raw SQL for the view body (the SELECT statement), written in the target platform's dialect.
+     * CodeGen wraps it in the platform's create-or-replace DDL (`CREATE OR ALTER VIEW` on SQL Server,
+     * `CREATE OR REPLACE VIEW` on PostgreSQL). On PostgreSQL the body is not auto-quoted, so
+     * mixed-case identifiers must be double-quoted.
+     */
     SQL: string;
 }
 /**
@@ -334,31 +339,63 @@ export declare class ManageMetadataBase {
     /**
      * Globally scoped list of entities that have been created during the metadata management process.
      */
+    static get NewEntityList(): string[];
+    static set NewEntityList(value: string[]);
+    /** @deprecated Use {@link NewEntityList}. */
     static get newEntityList(): string[];
+    /** @deprecated Use {@link NewEntityList}. */
     static set newEntityList(value: string[]);
     private static _modifiedEntityList;
     /**
      * Globally scoped list of entities that have been modified during the metadata management process.
      */
+    static get ModifiedEntityList(): string[];
+    static set ModifiedEntityList(value: string[]);
+    /** @deprecated Use {@link ModifiedEntityList}. */
     static get modifiedEntityList(): string[];
+    /** @deprecated Use {@link ModifiedEntityList}. */
     static set modifiedEntityList(value: string[]);
     private static _newFieldSet;
     private static _changedFields;
     private static _changedFieldReport;
     private static fieldKey;
+    static RegisterNewField(entityID: string, name: string): void;
+    /** @deprecated Use {@link RegisterNewField}. */
     static registerNewField(entityID: string, name: string): void;
+    static RegisterFieldChange(entityID: string, name: string, reasons: Iterable<FieldChangeReason>): void;
+    /** @deprecated Use {@link RegisterFieldChange}. */
     static registerFieldChange(entityID: string, name: string, reasons: Iterable<FieldChangeReason>): void;
+    static IsFieldNew(entityID: string, name: string): boolean;
+    /** @deprecated Use {@link IsFieldNew}. */
     static isFieldNew(entityID: string, name: string): boolean;
+    static FieldChangeReasons(entityID: string, name: string): ReadonlySet<FieldChangeReason>;
+    /** @deprecated Use {@link FieldChangeReasons}. */
     static fieldChangeReasons(entityID: string, name: string): ReadonlySet<FieldChangeReason>;
+    static IsDisplayNameReopened(entityID: string, name: string): boolean;
+    /** @deprecated Use {@link IsDisplayNameReopened}. */
     static isDisplayNameReopened(entityID: string, name: string): boolean;
+    static IsTypeReopened(entityID: string, name: string): boolean;
+    /** @deprecated Use {@link IsTypeReopened}. */
     static isTypeReopened(entityID: string, name: string): boolean;
+    static get NewFieldCount(): number;
+    /** @deprecated Use {@link NewFieldCount}. */
     static get newFieldCount(): number;
+    static get ChangedFieldCount(): number;
+    /** @deprecated Use {@link ChangedFieldCount}. */
     static get changedFieldCount(): number;
+    static get ChangedFieldReport(): ReadonlyArray<{
+        entityName: string;
+        fieldName: string;
+        reasons: FieldChangeReason[];
+    }>;
+    /** @deprecated Use {@link ChangedFieldReport}. */
     static get changedFieldReport(): ReadonlyArray<{
         entityName: string;
         fieldName: string;
         reasons: FieldChangeReason[];
     }>;
+    static ClearFieldTracking(): void;
+    /** @deprecated Use {@link ClearFieldTracking}. */
     static clearFieldTracking(): void;
     /**
      * Takes a snapshot of EntityField rows from vwEntityFields for diffing.
@@ -381,6 +418,8 @@ export declare class ManageMetadataBase {
      * the dead class keeps a live `@RegisterClass` registration on disk. The old monolith could
      * not drift this way: it was rewritten in full every run.
      */
+    static get DeletedEntitySchemaList(): string[];
+    /** @deprecated Use {@link DeletedEntitySchemaList}. */
     static get deletedEntitySchemaList(): string[];
     private static _entitiesRequiringViewRegen;
     /**
@@ -394,6 +433,8 @@ export declare class ManageMetadataBase {
     /**
      * Globally scoped list of validators that have been generated during the metadata management process.
      */
+    static get GeneratedValidators(): ValidatorResult[];
+    /** @deprecated Use {@link GeneratedValidators}. */
     static get generatedValidators(): ValidatorResult[];
     private static _softPKFKConfigCache;
     private static _softPKFKConfigPath;
@@ -409,12 +450,16 @@ export declare class ManageMetadataBase {
      * Deterministic + event-driven (no mtime/TOCTOU race). The CLI `Run()` path does not call this, so its
      * load-once-per-process behavior is unchanged.
      */
+    static InvalidateSoftPKFKConfigCache(): void;
+    /** @deprecated Use {@link InvalidateSoftPKFKConfigCache}. */
     static invalidateSoftPKFKConfigCache(): void;
     /**
      * Loads and caches the soft PK/FK configuration from the additionalSchemaInfo file.
      * Cached per process to avoid repeated I/O within a CodeGen run; the in-process (RSU) path calls
      * {@link invalidateSoftPKFKConfigCache} at the start of each run so a rewritten file is picked up.
      */
+    static GetSoftPKFKConfig(): Record<string, unknown> | null;
+    /** @deprecated Use {@link GetSoftPKFKConfig}. */
     static getSoftPKFKConfig(): Record<string, unknown> | null;
     /**
      * Extracts a flat array of table configs from the config file, handling both formats:
@@ -479,7 +524,19 @@ export declare class ManageMetadataBase {
         success: boolean;
         createdCount: number;
         updatedCount: number;
+        failedCount: number;
     }>;
+    /**
+     * Finds the entity an organic-key config names: by base table + schema, else by entity name.
+     * Returns `null` when neither matches.
+     */
+    private findOrganicKeyEntity;
+    /**
+     * Resolves every related entity of an organic key, in config order. Logs each one that doesn't
+     * resolve and returns `null` if any is missing, so the caller can skip the key before writing any
+     * of it.
+     */
+    private resolveOrganicKeyRelatedEntities;
     /**
      * Builds the entity lookup behind {@link processISARelationshipConfig}: match on Name first, else
      * on BaseTable, optionally constrained to a schema.
@@ -683,6 +740,8 @@ export declare class ManageMetadataBase {
      * @param pool - the ConnectionPool object to use for querying and updating the database
      * @returns
      */
+    ManageMetadata(pool: CodeGenConnection, currentUser: UserInfo): Promise<boolean>;
+    /** @deprecated Use {@link ManageMetadata}. */
     manageMetadata(pool: CodeGenConnection, currentUser: UserInfo): Promise<boolean>;
     /**
      * INTEGRITY CHECK — in a well-formed entity every base (non-virtual) field sequences BEFORE the
@@ -950,6 +1009,8 @@ export declare class ManageMetadataBase {
      * @param pool - database connection
      * @param excludeSchemas - schemas to exclude from FK field lookup
      */
+    CleanupStaleEntityRelationships(pool: CodeGenConnection, excludeSchemas: string[]): Promise<boolean>;
+    /** @deprecated Use {@link CleanupStaleEntityRelationships}. */
     cleanupStaleEntityRelationships(pool: CodeGenConnection, excludeSchemas: string[]): Promise<boolean>;
     /**
      * Removes stale One-To-Many EntityRelationship records whose RelatedEntityJoinField no longer
@@ -1002,6 +1063,8 @@ export declare class ManageMetadataBase {
      *   which is the typical "no schema changes since last run" case in Pass 2.
      *   `undefined` (default) preserves prior full-scan behavior.
      */
+    ManageEntityFields(pool: CodeGenConnection, excludeSchemas: string[], skipCreatedAtUpdatedAtDeletedAtFieldValidation: boolean, skipEntityFieldValues: boolean, currentUser: UserInfo, skipAdvancedGeneration: boolean, skipDeleteUnneededFields?: boolean, entityFilter?: string[]): Promise<boolean>;
+    /** @deprecated Use {@link ManageEntityFields}. */
     manageEntityFields(pool: CodeGenConnection, excludeSchemas: string[], skipCreatedAtUpdatedAtDeletedAtFieldValidation: boolean, skipEntityFieldValues: boolean, currentUser: UserInfo, skipAdvancedGeneration: boolean, skipDeleteUnneededFields?: boolean, entityFilter?: string[]): Promise<boolean>;
     /**
      * This method ensures that the __mj_DeletedAt field exists in each entity that has DeleteType=Soft. If the field does not exist, it is created.
@@ -1125,11 +1188,15 @@ export declare class ManageMetadataBase {
      * @param relatedEntityNameFieldMap
      * @returns
      */
+    UpdateEntityFieldRelatedEntityNameFieldMap(pool: CodeGenConnection, entityFieldID: string, relatedEntityNameFieldMap: string): Promise<boolean>;
+    /** @deprecated Use {@link UpdateEntityFieldRelatedEntityNameFieldMap}. */
     updateEntityFieldRelatedEntityNameFieldMap(pool: CodeGenConnection, entityFieldID: string, relatedEntityNameFieldMap: string): Promise<boolean>;
     protected updateExistingEntitiesFromSchema(pool: CodeGenConnection, excludeSchemas: string[]): Promise<boolean>;
     /**
      * Adds a list of entity names to the modified entity list if they're not already in there
      */
+    static AddNewEntitiesToModifiedList(entityNames: string[]): void;
+    /** @deprecated Use {@link AddNewEntitiesToModifiedList}. */
     static addNewEntitiesToModifiedList(entityNames: string[]): void;
     protected updateExistingEntityFieldsFromSchema(pool: CodeGenConnection, excludeSchemas: string[], entityIDs?: string[]): Promise<boolean>;
     /**
@@ -1170,6 +1237,8 @@ export declare class ManageMetadataBase {
      * @param pool
      * @param currentUser
      */
+    LoadGeneratedCode(pool: CodeGenConnection, currentUser: UserInfo): Promise<boolean>;
+    /** @deprecated Use {@link LoadGeneratedCode}. */
     loadGeneratedCode(pool: CodeGenConnection, currentUser: UserInfo): Promise<boolean>;
     private runValidationGeneration;
     /**
@@ -1182,7 +1251,66 @@ export declare class ManageMetadataBase {
      */
     protected generateValidatorFunctionFromCheckConstraint(data: any, allEntityFields: any[], currentUser: UserInfo, generateNewCode: boolean): Promise<ValidatorResult>;
     protected syncEntityFieldValues(ds: CodeGenConnection, entityFieldID: number, possibleValues: string[], allEntityFieldValues: any): Promise<boolean>;
+    /**
+     * Parses a column-level CHECK constraint into the list of values it permits, or returns null when the
+     * constraint is not a simple value list (a range, a `LEN()` predicate, a mixed condition, and so on).
+     *
+     * Both of the ways `IN (...)` is rendered by SQL Server are handled. String, date and GUID literals come
+     * back quoted — `([Status]='Active' OR [Status]='Inactive')` — but numeric and `bit` literals come back
+     * **unquoted and parenthesized**: `([Level]=(3) OR [Level]=(2) OR [Level]=(1))`. Matching only the quoted
+     * form left a numeric IN-list with no value list at all, and so no dropdown in Explorer either (#3978).
+     * PostgreSQL's `= ANY (ARRAY[...])` rendering is handled separately, by parsePgArrayConstraint.
+     *
+     * A single-value list is captured too: `CHECK (Status='Active')` — which is also how SQL Server renders
+     * `IN ('Active')` — permits exactly one value, which is a one-item list.
+     *
+     * This is a parser, not a policy: it reports what the constraint permits. WHICH fields get a value list
+     * out of that is decided after the fact, by valueListForField.
+     */
     protected parseCheckConstraintValues(constraintDefinition: string, fieldName: string, entityName: string): string[] | null;
+    /**
+     * The value list to actually store for a field, or null when a parsed list should NOT become
+     * EntityFieldValue rows (and so should not become a dropdown in Explorer either).
+     *
+     * Runs AFTER parsing rather than gating it, so each exclusion is no broader than its own reason and
+     * neither one can drop a list that was captured before #3978:
+     *
+     * - `bit`: `IN (0,1)` is vacuous — bit already permits exactly 0 and 1 — and `= 1` is a validator,
+     *   not a two-item dropdown over what renders as a checkbox. Every bit list is rendered unquoted, so
+     *   none of them was reachable before this change and nothing regresses.
+     * - a PRIMARY KEY carrying a SINGLE value: `CHECK (ID=1)` is the single-row-table guard MJ's own
+     *   sequence tables use — a structural invariant, not a set of values a user picks from. A
+     *   MULTI-value list on a primary key is left alone: `CHECK (Code IN ('US','CA'))` on a natural-key
+     *   PK is a real domain list, it was captured before this change, and CodeGen also runs over customer
+     *   schemas where natural-key primary keys are ordinary.
+     *
+     * A field whose metadata row was not found keeps whatever parsed, which is the pre-#3978 behaviour.
+     */
+    protected static valueListForField(field: {
+        Type?: string;
+        IsPrimaryKey?: boolean;
+    } | undefined, parsedValues: string[] | null): string[] | null;
+    /**
+     * Sorts a parsed value list in place, so the sequence a value gets is stable across databases and runs.
+     * An all-numeric list is compared as numbers (1, 2, 10); anything else keeps the default lexical order.
+     *
+     * Keyed off the VALUES, not the column type — so a string column whose list happens to be all-numeric
+     * (`CHECK (Code IN ('1','2','10'))` on nvarchar) would re-sequence too. Measured over every column CHECK
+     * constraint in a live 6.x database (MJ core + BizApps accounting/orders): of the 431 lists the previous
+     * parser already captured, ZERO re-sequence under this comparison. If one ever turns up and the churn is
+     * unwanted, gate `allNumeric` on the field being numeric as well.
+     */
+    protected static sortCheckConstraintValues(values: string[]): string[];
+    /**
+     * A numeric literal as SQL Server renders it inside a CHECK constraint: parenthesized, unquoted, and
+     * possibly signed, fractional or exponential — `(3)`, `(-1)`, `(1.00)`, `(2.5)`, `(1.0e+030)`.
+     */
+    private static readonly NUMERIC_CHECK_LITERAL;
+    /**
+     * Turns a matched numeric literal into the value to store: strips the wrapping parentheses, and the
+     * trailing point SQL Server adds to a large integral literal (`(12345678901234567890.)`).
+     */
+    private static normalizeNumericCheckLiteral;
     /**
      * Parses PostgreSQL ANY (ARRAY[...]) CHECK constraint syntax.
      * PG's pg_get_constraintdef() returns constraints like:
@@ -1444,6 +1572,11 @@ export declare class ManageMetadataBase {
      *                    earlier in this run (which are not in metadata yet)
      * @returns the free name and the suffix used to reach it ('' when the name was already free)
      */
+    ResolveUniqueEntityName(desiredName: string, schemaName: string, takenNames: string[]): {
+        name: string;
+        suffix: string;
+    };
+    /** @deprecated Use {@link ResolveUniqueEntityName}. */
     resolveUniqueEntityName(desiredName: string, schemaName: string, takenNames: string[]): {
         name: string;
         suffix: string;
@@ -1681,6 +1814,96 @@ export declare class ManageMetadataBase {
         newFieldNames: ReadonlySet<string>;
         typeReopenedNames: ReadonlySet<string>;
     }): void;
+    /**
+     * Build the two deterministic search-flag hygiene statements.
+     *
+     * These exist because the LLM-driven smart-field pipeline cannot be relied on to run at all:
+     * `AdvancedGeneration.enabled` reads `enableAdvancedGeneration ?? false`, so on a default
+     * configuration none of `applySearchableFieldUpdates` / `applyEntitySearchConfig` ever
+     * executes — while every new entity is still INSERTed with `AllowUserSearchAPI = 1`
+     * (see `createNewEntityInsertSQL`). The result is an entity flagged searchable with nothing
+     * searchable on it, which is not a harmless default: `UserSearchString` against such an entity
+     * is a documented no-op (MJ#4581/#4582), so the data provider ignores the term and returns the
+     * UNFILTERED table. Global search then fans out to it on every keystroke and discards every row.
+     *
+     * Both statements are deterministic, need no model, and are safe to run on every pass:
+     *
+     *  1. **Seed** — an entity with NO searchable field gets its name-like columns flagged
+     *     (`NAME_LIKE_FIELD_NAMES`: Name, Title, FirstName, LastName, …). Those are what a person
+     *     types into a search box, so they are the one defensible default. Only fires when the
+     *     entity has nothing flagged at all, so it fills a gap rather than overriding anyone —
+     *     including the LLM, which has already run by this point when it is enabled.
+     *
+     *     Note this keys on the field's NAME, not on `IsNameField`. That flag looks like the
+     *     obvious source and is the wrong one: measured against a real database, seeding from it
+     *     would flag 54 fields of which 41 are VIRTUAL — the denormalized FK display columns
+     *     CodeGen puts on views (`Action`, `Agent`, `Artifact`). Those are computed by JOIN, so a
+     *     LIKE against them cannot seek any index, and flagging them would push 49 junction
+     *     entities into the global-search fan-out with unindexable predicates — the exact cost
+     *     `search-guardrails.ts` exists to prevent. It also picked up identifiers (`RecordID`,
+     *     `Token`, `ExternalSystemRecordID`) and a `Description`, which `isNarrativeFieldName`
+     *     rejects on the LLM path. And it would still not have fixed `MJ: Employees`, whose only
+     *     `IsNameField` is the virtual `FirstLast`; keying on the name reaches its real
+     *     `FirstName` / `LastName` columns, which is what the reported bug needed.
+     *  2. **Clear** — an entity STILL left with no searchable field has `AllowUserSearchAPI` turned
+     *     off, so it drops out of the search fan-out instead of contributing noise.
+     *
+     * Both honor the `AutoUpdate*` opt-outs, which is how an operator pins a hand-made decision —
+     * and is exactly how the curated entries in `metadata/entities/.entity-search-exclusions.json`
+     * protect themselves (they set `AutoUpdateAllowUserSearchAPI` to false alongside the flag).
+     *
+     * Full-text-search entities are exempt from both. An FTS entity is searchable through its
+     * INDEX: `createViewUserSearchSQL` takes the full-text branch before it ever reads
+     * `IncludeInUserSearchAPI`, so those flags are dead metadata there and the entity is a
+     * perfectly valid search target without them.
+     *
+     * Written as `UPDATE ... WHERE <key> IN (subquery)` rather than `UPDATE ... FROM ... JOIN`,
+     * which is T-SQL-only. The subquery form is ANSI and runs unchanged on both platforms.
+     */
+    protected buildSearchFlagHygieneSQL(excludeSchemas: string[]): {
+        seedSQL: string;
+        clearSQL: string;
+        /** COUNT of the rows {@link seedSQL} would touch — see the compare-first note on the apply method. */
+        seedProbeSQL: string;
+        /** NAMES of the entities {@link clearSQL} would disable. Valid only AFTER the seed has run. */
+        clearProbeSQL: string;
+    };
+    /**
+     * Run the deterministic search-flag hygiene pass (see {@link buildSearchFlagHygieneSQL}).
+     *
+     * Runs OUTSIDE `applyAdvancedGeneration` and therefore regardless of whether advanced
+     * generation is enabled — which is the whole point, since it is off by default and an entity
+     * created under that default is exactly the one that needs this. Ordered after it so the
+     * model's choices, when it did run, are already in place and the seed only fills a real gap.
+     *
+     * COMPARE FIRST, then write — the T20 contract every-run config writers are held to (see
+     * `__tests__/idempotency/config-writers-compare-first.test.ts`). The two UPDATEs converge on
+     * their own, because the first pass makes `noSearchableField` false for every row it touches,
+     * so re-running them changes nothing. That is not sufficient: `LogSQLBatchAndExecute` writes
+     * whatever it is handed into the run's `CodeGen_Run_*.sql` capture whether or not a row moves,
+     * and the drift gate's warm-twice stage fails on ANY capture surviving a second run. Emitting
+     * unconditionally therefore reddened the gate on every PR while the data was perfectly
+     * idempotent — the data converged, the log did not. So each statement is emitted only when its
+     * own candidate probe finds work.
+     */
+    protected applySearchFlagHygiene(pool: CodeGenConnection, excludeSchemas: string[]): Promise<boolean>;
+    /**
+     * Row count for one of the search-flag hygiene probes (see {@link applySearchFlagHygiene}).
+     *
+     * Reads the first column of the first row positionally rather than by name, because the alias
+     * comes back cased differently across drivers. A probe that returns nothing is treated as no
+     * work, which is the safe direction: the statement is skipped rather than emitted blind.
+     */
+    private searchFlagHygieneCandidateCount;
+    /**
+     * Names of the entities the clear would disable (see {@link applySearchFlagHygiene}).
+     *
+     * Valid only AFTER the seed has run, since seeding changes which entities still have nothing
+     * searchable. Names rather than a count because this is the destructive half: the run output
+     * is the only place an operator can see which entities lost search, and getting it back is
+     * manual.
+     */
+    private searchFlagHygieneClearCandidates;
     /**
      * Returns true if the field is a sensible target for LIKE-based user search.
      * Mirrors the runtime guard in GenericDatabaseProvider.isTextSearchableType /
@@ -1836,7 +2059,7 @@ export declare class ManageMetadataBase {
      * @param isRecurringScript - if set to true tells the logger that the provided SQL represents a recurring script meaning it is something that is executed, generally, for all CodeGen runs. In these cases, the Config settings can result in omitting these recurring scripts from being logged because the configuration environment may have those recurring scripts already set to run after all run-specific migrations get run.
      * @returns - The result of the query execution.
      */
-    private LogSQLAndExecute;
+    private logSQLAndExecute;
     /**
      * Logs and executes a sequence of SQL statements as a single batch.
      *
@@ -1853,6 +2076,6 @@ export declare class ManageMetadataBase {
      * Empty / whitespace-only statements are filtered out. Returns
      * `undefined` (no execution) when nothing remains.
      */
-    private LogSQLBatchAndExecute;
+    private logSQLBatchAndExecute;
 }
 //# sourceMappingURL=manage-metadata.d.ts.map