@servicenow/sdk-build-plugins 2.0.1 → 2.1.1

package/dist/db/ColumnPlugins.d.ts

@@ -1,278 +1,740 @@
 import * as db from '@servicenow/sdk-core/runtime/db';
-import { EntityData } from '@servicenow/sdk-build-core';
+import { FluentDiagnostic, ObjectData } from '@servicenow/sdk-build-core';
 export declare const StringColumnPlugin: {
     readonly name: "stringColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>> & {
+                        readonly entityKind: "string";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const BooleanColumnPlugin: {
     readonly name: "booleanColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<boolean, db.Column<boolean, boolean>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<boolean, db.Column<boolean, boolean>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<boolean, db.Column<boolean, boolean>> & {
+                        readonly entityKind: "boolean";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const IntegerColumnPlugin: {
     readonly name: "integerColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<number, db.IntegerColumnType<db.Choices<number>, number, number, "none">>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<number, db.IntegerColumnType<db.Choices<number>, number, number, "none">>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<number, db.IntegerColumnType<db.Choices<number>, number, number, "none">> & {
+                        readonly entityKind: "integer";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const BasicImageColumnPlugin: {
     readonly name: "basicImageColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string>> & {
+                        readonly entityKind: "basicImage";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const ConditionsColumnPlugin: {
     readonly name: "conditionsColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string, db.Column<string, string>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string, db.Column<string, string>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string, db.Column<string, string>> & {
+                        readonly entityKind: "conditions";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const ChoiceColumnPlugin: {
     readonly name: "choiceColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string | number, db.ChoiceColumnType<db.Choices<string | number>, string | number, string | number, keyof Now.Internal.Tables, "none" | "dropdown_with_none" | "suggestion" | "dropdown_without_none">>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string | number, db.ChoiceColumnType<db.Choices<string | number>, string | number, string | number, keyof Now.Internal.Tables, "none" | "dropdown_with_none" | "suggestion" | "dropdown_without_none">>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string | number, db.ChoiceColumnType<db.Choices<string | number>, string | number, string | number, keyof Now.Internal.Tables, "none" | "dropdown_with_none" | "suggestion" | "dropdown_without_none">> & {
+                        readonly entityKind: "choice";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const DecimalColumnPlugin: {
     readonly name: "decimalColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<number, db.Column<number, number>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<number, db.Column<number, number>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<number, db.Column<number, number>> & {
+                        readonly entityKind: "decimal";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const DocumentIdColumnPlugin: {
     readonly name: "documentIdColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<db.Record, db.Column<db.Record, db.Record> & {
-                dependent?: db.TableNameColumnType;
-            }>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string | db.Record, db.Column<string | db.Record, string | db.Record> & {
+                        dependent?: db.TableNameColumnType;
+                    }>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string | db.Record, db.Column<string | db.Record, string | db.Record> & {
+                        dependent?: db.TableNameColumnType;
+                    }> & {
+                        readonly entityKind: "documentId";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const DomainIdColumnPlugin: {
     readonly name: "domainIdColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<db.Record<"domain"> | "global", db.Column<db.Record<"domain"> | "global", db.Record<"domain"> | "global">>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<db.Record<"domain"> | "global", db.Column<db.Record<"domain"> | "global", db.Record<"domain"> | "global">>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<db.Record<"domain"> | "global", db.Column<db.Record<"domain"> | "global", db.Record<"domain"> | "global">> & {
+                        readonly entityKind: "domainId";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const DomainPathColumnPlugin: {
     readonly name: "domainPathColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>> & {
+                        readonly entityKind: "domainPath";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const ListColumnPlugin: {
     readonly name: "listColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<db.Record<keyof Now.Internal.Tables>[], db.Column<db.Record<keyof Now.Internal.Tables>[], db.Record<keyof Now.Internal.Tables>[]> & {
-                referenceTable?: keyof Now.Internal.Tables;
-            }>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<db.Record<keyof Now.Internal.Tables>[], db.Column<db.Record<keyof Now.Internal.Tables>[], db.Record<keyof Now.Internal.Tables>[]> & {
+                        referenceTable?: keyof Now.Internal.Tables;
+                    }>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<db.Record<keyof Now.Internal.Tables>[], db.Column<db.Record<keyof Now.Internal.Tables>[], db.Record<keyof Now.Internal.Tables>[]> & {
+                        referenceTable?: keyof Now.Internal.Tables;
+                    }> & {
+                        readonly entityKind: "list";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const ReferenceColumnPlugin: {
     readonly name: "referenceColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string | db.Record<keyof Now.Internal.Tables>, db.ReferenceColumnType<keyof Now.Internal.Tables, string | db.Record<keyof Now.Internal.Tables>, string | db.Record<keyof Now.Internal.Tables>>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string | db.Record<keyof Now.Internal.Tables> | Now.Internal.ExplicitKey<keyof Now.Internal.Tables>, db.Column<string | db.Record<keyof Now.Internal.Tables> | Now.Internal.ExplicitKey<keyof Now.Internal.Tables>, string | db.Record<keyof Now.Internal.Tables> | Now.Internal.ExplicitKey<keyof Now.Internal.Tables>> & {
+                        referenceTable?: keyof Now.Internal.Tables;
+                        cascadeRule?: "none" | "delete_no_workflow" | "cascade" | "delete" | "restrict" | "clear";
+                    }>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string | db.Record<keyof Now.Internal.Tables> | Now.Internal.ExplicitKey<keyof Now.Internal.Tables>, db.Column<string | db.Record<keyof Now.Internal.Tables> | Now.Internal.ExplicitKey<keyof Now.Internal.Tables>, string | db.Record<keyof Now.Internal.Tables> | Now.Internal.ExplicitKey<keyof Now.Internal.Tables>> & {
+                        referenceTable?: keyof Now.Internal.Tables;
+                        cascadeRule?: "none" | "delete_no_workflow" | "cascade" | "delete" | "restrict" | "clear";
+                    }> & {
+                        readonly entityKind: "reference";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const RadioColumnPlugin: {
     readonly name: "radioColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string | number, db.RadioColumnType<db.Choices, string | number, string | number>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string | number, db.RadioColumnType<db.Choices, string | number, string | number>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string | number, db.RadioColumnType<db.Choices, string | number, string | number>> & {
+                        readonly entityKind: "radio";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const ScriptColumnPlugin: {
     readonly name: "scriptColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string | db.ScriptModule<Function>, db.Column<string | db.ScriptModule<Function>, string | db.ScriptModule<Function>> & {
-                signature?: Function;
-            }>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string | db.ScriptModule<Function>, db.Column<string | db.ScriptModule<Function>, string | db.ScriptModule<Function>> & {
+                        signature?: Function;
+                    }>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string | db.ScriptModule<Function>, db.Column<string | db.ScriptModule<Function>, string | db.ScriptModule<Function>> & {
+                        signature?: Function;
+                    }> & {
+                        readonly entityKind: "script";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const SystemClassNameColumnPlugin: {
     readonly name: "systemClassNameColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>> & {
+                        readonly entityKind: "systemClassName";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const TableNameColumnPlugin: {
     readonly name: "tableNameColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<keyof Now.Internal.Tables, db.TableNameColumnType<keyof Now.Internal.Tables, keyof Now.Internal.Tables>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<keyof Now.Internal.Tables, db.TableNameColumnType<keyof Now.Internal.Tables, keyof Now.Internal.Tables>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<keyof Now.Internal.Tables, db.TableNameColumnType<keyof Now.Internal.Tables, keyof Now.Internal.Tables>> & {
+                        readonly entityKind: "tableName";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const TranslatedFieldColumnPlugin: {
     readonly name: "translatedFieldColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>> & {
+                        readonly entityKind: "translatedField";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const TranslatedTextColumnPlugin: {
     readonly name: "translatedTextColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>> & {
+                        readonly entityKind: "translatedText";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const UserRolesColumnPlugin: {
     readonly name: "userRolesColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string | {
-                $id: string | number;
-                name: string;
-                assignable_by?: string | undefined;
-                can_delegate?: boolean | undefined;
-                description?: string | undefined;
-                elevated_privilege?: boolean | undefined;
-                grantable?: boolean | undefined;
-                contains_roles?: any[] | undefined;
-                scoped_admin?: boolean | undefined;
-            }, db.Column<string | {
-                $id: string | number;
-                name: string;
-                assignable_by?: string | undefined;
-                can_delegate?: boolean | undefined;
-                description?: string | undefined;
-                elevated_privilege?: boolean | undefined;
-                grantable?: boolean | undefined;
-                contains_roles?: any[] | undefined;
-                scoped_admin?: boolean | undefined;
-            }, string | {
-                $id: string | number;
-                name: string;
-                assignable_by?: string | undefined;
-                can_delegate?: boolean | undefined;
-                description?: string | undefined;
-                elevated_privilege?: boolean | undefined;
-                grantable?: boolean | undefined;
-                contains_roles?: any[] | undefined;
-                scoped_admin?: boolean | undefined;
-            }>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string | {
+                        $id: string | number;
+                        name: string;
+                        assignable_by?: string | undefined;
+                        can_delegate?: boolean | undefined;
+                        description?: string | undefined;
+                        elevated_privilege?: boolean | undefined;
+                        grantable?: boolean | undefined;
+                        contains_roles?: any[] | undefined;
+                        scoped_admin?: boolean | undefined;
+                    }, db.Column<string | {
+                        $id: string | number;
+                        name: string;
+                        assignable_by?: string | undefined;
+                        can_delegate?: boolean | undefined;
+                        description?: string | undefined;
+                        elevated_privilege?: boolean | undefined;
+                        grantable?: boolean | undefined;
+                        contains_roles?: any[] | undefined;
+                        scoped_admin?: boolean | undefined;
+                    }, string | {
+                        $id: string | number;
+                        name: string;
+                        assignable_by?: string | undefined;
+                        can_delegate?: boolean | undefined;
+                        description?: string | undefined;
+                        elevated_privilege?: boolean | undefined;
+                        grantable?: boolean | undefined;
+                        contains_roles?: any[] | undefined;
+                        scoped_admin?: boolean | undefined;
+                    }>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string | {
+                        $id: string | number;
+                        name: string;
+                        assignable_by?: string | undefined;
+                        can_delegate?: boolean | undefined;
+                        description?: string | undefined;
+                        elevated_privilege?: boolean | undefined;
+                        grantable?: boolean | undefined;
+                        contains_roles?: any[] | undefined;
+                        scoped_admin?: boolean | undefined;
+                    }, db.Column<string | {
+                        $id: string | number;
+                        name: string;
+                        assignable_by?: string | undefined;
+                        can_delegate?: boolean | undefined;
+                        description?: string | undefined;
+                        elevated_privilege?: boolean | undefined;
+                        grantable?: boolean | undefined;
+                        contains_roles?: any[] | undefined;
+                        scoped_admin?: boolean | undefined;
+                    }, string | {
+                        $id: string | number;
+                        name: string;
+                        assignable_by?: string | undefined;
+                        can_delegate?: boolean | undefined;
+                        description?: string | undefined;
+                        elevated_privilege?: boolean | undefined;
+                        grantable?: boolean | undefined;
+                        contains_roles?: any[] | undefined;
+                        scoped_admin?: boolean | undefined;
+                    }>> & {
+                        readonly entityKind: "userRoles";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const VersionColumnPlugin: {
     readonly name: "versionColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<`${bigint}.${bigint}.${bigint}`, db.Column<`${bigint}.${bigint}.${bigint}`, `${bigint}.${bigint}.${bigint}`>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<`${bigint}.${bigint}.${bigint}`, db.Column<`${bigint}.${bigint}.${bigint}`, `${bigint}.${bigint}.${bigint}`>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<`${bigint}.${bigint}.${bigint}`, db.Column<`${bigint}.${bigint}.${bigint}`, `${bigint}.${bigint}.${bigint}`>> & {
+                        readonly entityKind: "version";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const FieldNameColumnPlugin: {
     readonly name: "fieldNameColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string, db.StringColumnType<db.Choices<string>, "none", string, string, keyof Now.Internal.Tables>> & {
+                        readonly entityKind: "fieldName";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const DateColumnPlugin: {
     readonly name: "glide_dateColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<`${number}-${number}-${number}`, db.Column<`${number}-${number}-${number}`, `${number}-${number}-${number}`>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<`${number}-${number}-${number}`, db.Column<`${number}-${number}-${number}`, `${number}-${number}-${number}`>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<`${number}-${number}-${number}`, db.Column<`${number}-${number}-${number}`, `${number}-${number}-${number}`>> & {
+                        readonly entityKind: "glide_date";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const DateTimeColumnPlugin: {
     readonly name: "glide_date_timeColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>> & {
+                        readonly entityKind: "glide_date_time";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const CalendarDateTimeColumnPlugin: {
     readonly name: "calendar_date_timeColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>> & {
+                        readonly entityKind: "calendar_date_time";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const BasicDateTimeColumnPlugin: {
     readonly name: "datetimeColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>> & {
+                        readonly entityKind: "datetime";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const DueDateColumnPlugin: {
     readonly name: "due_dateColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<`${number}-${number}-${number} ${number}:${number}:${number}`, db.Column<`${number}-${number}-${number} ${number}:${number}:${number}`, `${number}-${number}-${number} ${number}:${number}:${number}`>> & {
+                        readonly entityKind: "due_date";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const IntegerDateColumnPlugin: {
     readonly name: "integer_dateColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<number, db.Column<number, number>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<number, db.Column<number, number>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<number, db.Column<number, number>> & {
+                        readonly entityKind: "integer_date";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const ScheduleDateTimeColumnPlugin: {
     readonly name: "schedule_date_timeColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string, db.Column<string, string>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string, db.Column<string, string>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string, db.Column<string, string>> & {
+                        readonly entityKind: "schedule_date_time";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const OtherDateColumnPlugin: {
     readonly name: "dateColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<`${number}-${number}-${number}`, db.Column<`${number}-${number}-${number}`, `${number}-${number}-${number}`>>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<`${number}-${number}-${number}`, db.Column<`${number}-${number}-${number}`, `${number}-${number}-${number}`>>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<`${number}-${number}-${number}`, db.Column<`${number}-${number}-${number}`, `${number}-${number}-${number}`>> & {
+                        readonly entityKind: "date";
+                    }>[];
+                };
+            };
         };
     };
 };
 export declare const GenericColumnPlugin: {
     readonly name: "genericColumn";
     readonly extractors: {
-        readonly entity: {
-            readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => import("@servicenow/sdk-build-core").ExtractionResult<EntityData<db.Typed<string | number, db.GenericColumnType<db.Choices<string | number>, string | number, string | number, "none">>>>;
+        readonly raw: {
+            readonly fluent: {
+                readonly CallExpression: (node: import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression>, context: import("@servicenow/sdk-build-core").Context) => {
+                    handled: false;
+                } | {
+                    handled: true;
+                    data: import("@servicenow/sdk-build-core").EntityData<db.Typed<string | number, db.GenericColumnType<db.Choices<string | number>, string | number, string | number, "none">>>[];
+                    diagnostics: FluentDiagnostic[];
+                } | {
+                    handled: true;
+                    diagnostics: FluentDiagnostic[];
+                    data: ObjectData<db.Typed<string | number, db.GenericColumnType<db.Choices<string | number>, string | number, string | number, "none">> & {
+                        readonly entityKind: "generic";
+                    }>[];
+                };
+            };
         };
     };
 };