@servicenow/sdk-build-plugins 2.0.1

package/dist/db/TablePlugin.js

@@ -0,0 +1,1249 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamic_value_mapping = exports.ColumnSchemaBootstrapAttributes = exports.TableSchemaBootstrapAttributes = exports.Documentation = exports.TableSchemaBootstrap = exports.ColumnSchema = exports.TableSchemaFull = exports.callerAccess = void 0;
+exports.transformColumnData = transformColumnData;
+exports.SysNumber = SysNumber;
+exports.generateColumnExpression = generateColumnExpression;
+exports.createObjectExpression = createObjectExpression;
+exports.factoryCreateValue = factoryCreateValue;
+exports.getCallExpressionFromType = getCallExpressionFromType;
+const db_1 = require("@servicenow/sdk-core/runtime/db");
+const sdk_build_core_1 = require("@servicenow/sdk-build-core");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const lodash_1 = require("lodash");
+const zod_1 = require("zod");
+const RecordPlugin_1 = require("./RecordPlugin");
+const scriptUtils_1 = require("../scripts/scriptUtils");
+const ts_morph_1 = require("ts-morph");
+const sdk_project_1 = require("@servicenow/sdk-project");
+const ScriptTemplatePlugin_1 = require("../ScriptTemplatePlugin");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * The access levels are mapped to the following values on the platform
+ *
+ * - `none`: 0
+ * - `tracking`: 1
+ * - `restricted`: 2
+ *
+ */
+exports.callerAccess = ['none', 'tracking', 'restricted'];
+// Basic info needed for table references
+exports.TableSchemaFull = zod_1.z.object({
+    /** lowercase, one word name. Numbers, letters and underscores only */
+    name: zod_1.z.string(),
+    /** Object literal of column names with <type>Column() calls as values.
+     * Ex. { column_name_1: StringColumn({...args}), column_name_2: IntegerColumn({...args}), }
+     * Import column definitions from `@servicenow/sdk-core/db`
+     */
+    schema: zod_1.z.record(zod_1.z.record(zod_1.z.any())).default({}),
+    /** Table as a string, this table will inherit schema from extends table.
+     * Escape with `` (import from `@servicenow/sdk-core/global`)
+     * if table definition not present locally */
+    extends: zod_1.z.string().optional(),
+    /** Will match name if not provided, cannot exceed 80 characters */
+    label: zod_1.z.string().max(80, 'Cannot exceed 80 characters').optional(),
+    /** Must match column name */
+    display: zod_1.z.string().optional(),
+    // Controls
+    extensible: zod_1.z.boolean().optional().default(false),
+    live_feed: zod_1.z.boolean().optional().default(false),
+    /** sys_number to create auto prefixing. Specify as Object literal */
+    auto_number: zod_1.z
+        .object({
+        prefix: zod_1.z.string().default('pre').optional(),
+        number: zod_1.z.number().default(1000).optional(),
+        number_of_digits: zod_1.z.number().default(7).optional(),
+    })
+        .optional(),
+    // Application Access
+    accessible_from: zod_1.z
+        .union([zod_1.z.literal('package_private'), zod_1.z.literal('public')])
+        .optional()
+        .default('public'),
+    caller_access: zod_1.z.enum(exports.callerAccess).optional(),
+    /** Array of read, update, create, delete actions (['read', 'update',...])*/
+    actions: zod_1.z
+        .array(zod_1.z.union([zod_1.z.literal('read'), zod_1.z.literal('update'), zod_1.z.literal('delete'), zod_1.z.literal('create')]))
+        .optional(),
+    allow_web_service_access: zod_1.z.boolean().optional().default(false),
+    allow_new_fields: zod_1.z.boolean().optional().default(false),
+    allow_ui_actions: zod_1.z.boolean().optional().default(false),
+    allow_client_scripts: zod_1.z.boolean().optional().default(false),
+    // From sys_dictionary
+    audit: zod_1.z.boolean().optional().default(false),
+    read_only: zod_1.z.boolean().optional().default(false),
+    text_index: zod_1.z.boolean().optional().default(false),
+    /** Object literal of key value pairs corresponding to attributes */
+    attributes: zod_1.z.record(zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean()])).optional(),
+    /** Array of objects [{ { name: <columnName>, element: ...,}...}] */
+    index: zod_1.z
+        .array(zod_1.z.object({
+        name: zod_1.z.string(),
+        unique: zod_1.z.boolean(),
+        element: zod_1.z.string(),
+    }))
+        .optional(),
+});
+const componentTables = ['sys_dictionary', 'sys_choice', 'sys_documentation'];
+exports.ColumnSchema = zod_1.z.object({
+    entityKind: zod_1.z.string().optional(),
+    column_type: zod_1.z.string().optional(),
+    audit: zod_1.z.boolean().optional().default(false),
+    label: zod_1.z.string().optional(),
+    maxLength: zod_1.z.number().optional().default(40),
+    mandatory: zod_1.z.boolean().optional().default(false),
+    read_only: zod_1.z.boolean().optional().default(false),
+    default: zod_1.z.any().optional(),
+    attributes: zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.string(), zod_1.z.boolean(), zod_1.z.number()])).optional(),
+    referenceTable: zod_1.z.string().optional(),
+    dropdown: zod_1.z.enum(db_1.choiceDropdown).default('none').optional(),
+    choices: zod_1.z.record(zod_1.z.any()).or(zod_1.z.array(zod_1.z.any())).optional(),
+    choice_elements: zod_1.z.record(zod_1.z.any()).or(zod_1.z.array(zod_1.z.any())).optional(),
+    display: zod_1.z.boolean().default(false).optional(),
+    function_definition: zod_1.z.string().optional(),
+    dynamic_value_definitions: zod_1.z
+        .object({
+        type: zod_1.z.union([
+            zod_1.z.literal('dynamic_default'),
+            zod_1.z.literal('choices_from_other_table'),
+            zod_1.z.literal('calculated_value'),
+            zod_1.z.literal('dependent_field'),
+        ]),
+    })
+        .and(zod_1.z.any())
+        .optional(),
+});
+const BooleanFromString = zod_1.z
+    .string()
+    .transform((str) => str === 'true')
+    .or(zod_1.z.boolean())
+    .optional();
+const IntFromString = zod_1.z
+    .string()
+    .transform((str) => (0, lodash_1.parseInt)(str))
+    .or(zod_1.z.number())
+    .optional();
+// These fields transform from sys_db_object only, not bootstrap. (Except name, which is needed to match)
+const DBObjectIncomingAttributes = zod_1.z.object({
+    name: RecordPlugin_1.TextStringSchema.or(zod_1.z.string()).optional(),
+    read_access: RecordPlugin_1.TextBooleanSchema.or(BooleanFromString).optional().default(true),
+    create_access: RecordPlugin_1.TextBooleanSchema.or(BooleanFromString).optional().default(true),
+    update_access: RecordPlugin_1.TextBooleanSchema.or(BooleanFromString).optional().default(true),
+    delete_access: RecordPlugin_1.TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    ws_access: RecordPlugin_1.TextBooleanSchema.or(BooleanFromString).optional().default(true),
+    caller_access: RecordPlugin_1.TextNumberSchema.or(IntFromString)
+        .transform((val) => {
+        if (val) {
+            return exports.callerAccess[val];
+        }
+        return;
+    })
+        .optional(),
+    alter_access: RecordPlugin_1.TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    client_scripts_access: RecordPlugin_1.TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    actions_access: RecordPlugin_1.TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    //configuration_access: TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    is_extendable: RecordPlugin_1.TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    // live_feed_enabled: TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    access: RecordPlugin_1.TextStringSchema.or(zod_1.z.string()).optional(),
+});
+// Attributes in the element='collection' tag of bootstrap xml
+exports.TableSchemaBootstrap = zod_1.z.object({
+    name: zod_1.z.string(),
+    extends: zod_1.z.string().optional(),
+    label: zod_1.z.string().max(80, 'Cannot exceed 80 characters').optional(),
+    // Controls
+    extensible: zod_1.z.boolean().optional().default(false),
+    live_feed: zod_1.z.boolean().optional().default(false),
+    auto_number: zod_1.z
+        .object({
+        prefix: zod_1.z.string().default('pre').optional(),
+        number: zod_1.z.number().default(1000).optional(),
+        number_of_digits: zod_1.z.number().default(7).optional(),
+    })
+        .optional(),
+    number_ref: zod_1.z.any().optional(),
+    // Application Access
+    accessible_from: zod_1.z
+        .union([zod_1.z.literal('public'), zod_1.z.literal('package_private')])
+        .optional()
+        .default('public'),
+    caller_access: zod_1.z.enum(exports.callerAccess).default('none').optional(),
+    actions: zod_1.z
+        .array(zod_1.z.union([zod_1.z.literal('read'), zod_1.z.literal('update'), zod_1.z.literal('delete'), zod_1.z.literal('create')]))
+        .default(['read'])
+        .optional(),
+    allow_web_service_access: zod_1.z.boolean().optional().default(true),
+    allow_new_fields: zod_1.z.boolean().optional().default(false),
+    allow_ui_actions: zod_1.z.boolean().optional().default(false),
+    allow_client_scripts: zod_1.z.boolean().optional().default(false),
+    // From sys_dictionary
+    audit: zod_1.z.boolean().optional().default(false),
+    read_only: zod_1.z.boolean().optional().default(false),
+    text_index: zod_1.z.boolean().optional().default(false),
+    attributes: zod_1.z
+        .record(zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean()]))
+        .default({})
+        .optional(),
+});
+const TableSchemaBootstrapIncoming = exports.TableSchemaBootstrap.omit({ actions: true }).extend({
+    caller_access: zod_1.z
+        .union([zod_1.z.literal(0), zod_1.z.literal(1), zod_1.z.literal(2)])
+        .transform((val) => {
+        if (val) {
+            return exports.callerAccess[val];
+        }
+        return;
+    })
+        .optional(),
+    accessible_from: zod_1.z.union([zod_1.z.literal('public'), zod_1.z.literal('package_private')]).optional(),
+    extends: zod_1.z
+        .string()
+        .or(zod_1.z.object({ name: zod_1.z.string() }).transform((obj) => obj.name))
+        .optional(),
+    live_feed: zod_1.z.boolean().optional().default(false),
+    index: zod_1.z.any().optional(),
+    columns: zod_1.z.any().optional(),
+});
+// Everything in side <database> in boostrap.xml
+const BootstrapDatabaseElement = zod_1.z.object({
+    element: zod_1.z.record(zod_1.z.any()),
+});
+const DBObjectIncoming = zod_1.z.object({
+    '@_table': zod_1.z.literal('sys_db_object'),
+    sys_db_object: zod_1.z.record(zod_1.z.any()),
+});
+exports.Documentation = zod_1.z.object({
+    sys_documentation: zod_1.z.object({
+        element: RecordPlugin_1.TextStringSchema.optional(),
+        label: RecordPlugin_1.TextStringSchema.optional(),
+        language: RecordPlugin_1.TextStringSchema.optional(),
+        hint: RecordPlugin_1.TextStringSchema.optional(),
+        help: RecordPlugin_1.TextStringSchema.optional(),
+        name: RecordPlugin_1.TextStringSchema.optional(),
+        plural: RecordPlugin_1.TextStringSchema.optional(),
+        url: RecordPlugin_1.TextStringSchema.optional(),
+        url_target: RecordPlugin_1.TextStringSchema.optional(),
+    }),
+});
+// Attributes from element=table in bootstrap.xml
+exports.TableSchemaBootstrapAttributes = zod_1.z
+    .object({
+    '@_name': zod_1.z.string(),
+    '@_extends': zod_1.z.string().optional(),
+    '@_label': zod_1.z.string().optional(),
+    '@_max_length': zod_1.z.coerce.number().optional(),
+    // From sys_dictionary
+    '@_audit': BooleanFromString,
+    '@_read_only': BooleanFromString,
+    '@_text_index': BooleanFromString,
+    '@_client_scripts_access': BooleanFromString,
+    '@_ws_access': BooleanFromString,
+    '@_alter_access': BooleanFromString,
+    '@_create_access': BooleanFromString,
+    '@_delete_access': BooleanFromString,
+    '@_update_access': BooleanFromString,
+    '@_query_access': BooleanFromString,
+    '@_actions_access': BooleanFromString,
+    '@_read_access': BooleanFromString,
+    '@_is_extendable': BooleanFromString,
+    '@_caller_access': IntFromString,
+    '@_attributes': zod_1.z
+        .string()
+        .transform((values) => {
+        const ret = {};
+        if (values === '') {
+            return undefined;
+        }
+        const entries = values.split(',');
+        entries.forEach((attr) => {
+            const s = attr.split('=');
+            if (s.length === 2 && s[0] && s[1]) {
+                try {
+                    ret[s[0]] = JSON.parse(s[1]);
+                }
+                catch (err) {
+                    ret[s[0]] = s[1];
+                }
+            }
+        });
+        return ret;
+    })
+        .optional(),
+})
+    .catchall(zod_1.z.any());
+const IndexSchemaBootstrapAttributes = zod_1.z.object({
+    '@_name': zod_1.z.string(),
+    '@_unique': BooleanFromString,
+    element: zod_1.z.object({
+        '@_name': zod_1.z.string(),
+    }),
+});
+exports.ColumnSchemaBootstrapAttributes = exports.TableSchemaBootstrapAttributes.omit({ '@_extends': true })
+    .extend({
+    '@_choice': zod_1.z.coerce.number().optional(),
+    '@_active': BooleanFromString,
+    '@_mandatory': BooleanFromString,
+    '@_display': BooleanFromString,
+    '@_type': zod_1.z.string().optional(),
+    '@_use_dependent_field': BooleanFromString,
+    '@_use_dynamic_default': BooleanFromString,
+    '@_reference': zod_1.z.string().optional(),
+    '@_virtual': BooleanFromString,
+    '@_default': zod_1.z.string().optional(),
+    '@_calculation': zod_1.z.string().optional(),
+    '@_choice_field': zod_1.z.string().optional(),
+    '@_function_definition': zod_1.z.string().optional(),
+    choice: zod_1.z.object({ element: zod_1.z.array(zod_1.z.any()).or(zod_1.z.record(zod_1.z.any())).optional() }).optional(),
+})
+    .catchall(zod_1.z.any());
+const ChoiceSchema = zod_1.z.object({
+    label: zod_1.z.string().optional(),
+    value: zod_1.z.string().optional(),
+    sequence: zod_1.z.coerce.number().optional(),
+    dependent_value: zod_1.z.coerce.number().optional(),
+    hint: zod_1.z.string().optional(),
+    inactive: BooleanFromString.default(false).optional(),
+    inactive_on_update: BooleanFromString.default(false).optional(),
+    language: zod_1.z.string().optional(),
+});
+const ChoiceSchemaIncoming = ChoiceSchema.omit({ value: true });
+function isSNScope(scopeName) {
+    return scopeName.startsWith('sn') || scopeName.startsWith('now');
+}
+exports.default = (0, sdk_build_core_1.Plugin)({
+    name: 'Table',
+    ownedTables: {
+        sys_db_object: { diagnosticLevel: sdk_project_1.Diagnostic.Level.Warn },
+    },
+    extractors: {
+        entity: {
+            // TODO: Cast to `any` is temporary workaround for the circular nature of Table entities
+            CallExpression: (node, context) => {
+                const result = (0, sdk_build_core_1.extractCallExpression)(db_1.Table, 'table', node, context, (table) => table.name);
+                if (!result.handled || !(0 in result.data)) {
+                    return result;
+                }
+                const data = result.data[0];
+                const diagnostics = result.diagnostics;
+                const scopeName = context.app.config.scope;
+                const scopeRegex = new RegExp(`^${scopeName}_`);
+                const nameRegex = new RegExp(`^[a-z_][a-z0-9_]`);
+                const tableName = data.getProperty('name');
+                const scopeMatches = tableName.getValue().match(scopeRegex);
+                if (!scopeMatches) {
+                    const nameNode = tableName.getNode().asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral);
+                    if (nameNode.getParent().getKindName() !== 'AsExpression') {
+                        diagnostics.push(new sdk_build_core_1.FluentDiagnostic(tableName.getNode(), `'name' property must start with scope prefix '${scopeName}'`));
+                    }
+                }
+                const schema = data.getProperty('schema');
+                const schemaNode = schema.getNode().asKindOrThrow(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+                for (const columnName in schema.getValue()) {
+                    const columnNode = schemaNode.getPropertyOrThrow(columnName);
+                    if (!scopeMatches && !isSNScope(scopeName) && !columnName.match(scopeRegex)) {
+                        diagnostics.push(new sdk_build_core_1.FluentDiagnostic(columnNode, `Column name must be prefixed with scope '${scopeName}' if table name does not contain prefix`));
+                    }
+                    if (!columnName.match(nameRegex)) {
+                        diagnostics.push(new sdk_build_core_1.FluentDiagnostic(columnNode, `Column name must only contain lowercase letters, numbers, and underscores`));
+                    }
+                }
+                const declaration = node.getParentIfKind(ts_morph_1.SyntaxKind.VariableDeclaration);
+                if (!declaration ||
+                    !declaration.isExported() ||
+                    !declaration.isNamedExport() ||
+                    declaration.getName() !== tableName.getValue()) {
+                    diagnostics.push(new sdk_build_core_1.FluentDiagnostic(node, `Table definition should be exported as a named export with the name '${tableName.getValue()}'`, { level: sdk_project_1.Diagnostic.Level.Warn }));
+                }
+                return { handled: true, data: [data], diagnostics };
+            },
+        },
+        raw: {
+            FunctionDeclaration(node, context) {
+                const info = (0, scriptUtils_1.scriptInfo)(node, context, db_1.Table.name);
+                if (!info) {
+                    return { handled: false };
+                }
+                return { handled: true, diagnostics: [], data: [info] };
+            },
+            FunctionExpression(node, context) {
+                const info = (0, scriptUtils_1.scriptInfo)(node, context, db_1.Table.name);
+                if (!info) {
+                    return { handled: false };
+                }
+                return { handled: true, diagnostics: [], data: [info] };
+            },
+        },
+        xml(xml, context) {
+            const bootstrapData = {};
+            let dbObjectData = {};
+            const bootstrapDatabaseXML = BootstrapDatabaseElement.safeParse(xml.data['database']);
+            if (bootstrapDatabaseXML.success) {
+                const data = exports.TableSchemaBootstrapAttributes.parse(bootstrapDatabaseXML.data.element);
+                Object.entries(data).forEach(([key, value]) => {
+                    if (key.startsWith('@_')) {
+                        bootstrapData[key.substring(2)] = value;
+                    }
+                    else if (key === 'element') {
+                        //
+                    }
+                    else {
+                        bootstrapData[key] = value;
+                    }
+                });
+                context.handledXmls[xml.filePath] = 'handled';
+            }
+            const db_object_inc = DBObjectIncoming.safeParse(xml.data['record_update']);
+            if (db_object_inc.success) {
+                dbObjectData = DBObjectIncomingAttributes.parse(db_object_inc.data.sys_db_object);
+                context.handledXmls[xml.filePath] = 'handled';
+                return new sdk_build_core_1.XmlData(dbObjectData, xml.filePath, 'sys_db_object', db_object_inc.data.sys_db_object['@_action']);
+            }
+            else {
+                const record_update = xml.data['record_update'];
+                if (record_update) {
+                    const table = Object.keys(record_update)[0];
+                    if (!table || !componentTables.includes(table)) {
+                        return;
+                    }
+                    if (table === 'sys_documentation') {
+                        const data = exports.Documentation.parse(record_update[table]);
+                        return new sdk_build_core_1.XmlData({
+                            table: table,
+                            id: record_update[table][table]['sys_id']['#text'],
+                            data: data.sys_documentation,
+                        }, xml.filePath, 'record', record_update[table][table]['@_action']);
+                    }
+                    context.handledXmls[xml.filePath] = 'ignored';
+                    return;
+                }
+            }
+            // Columns and Indexes
+            const columns = [];
+            const idxElements = [];
+            if (bootstrapDatabaseXML.success && bootstrapDatabaseXML.data.element['element']) {
+                const element = bootstrapDatabaseXML.data.element['element'];
+                const elementsArray = (0, lodash_1.isArray)(element) ? element : [element];
+                columns.push(...zod_1.z.array(exports.ColumnSchemaBootstrapAttributes).parse(elementsArray));
+                columns.forEach((element) => {
+                    if (element.choice && !(0, lodash_1.isEmpty)(element.choice)) {
+                        element['choice_elements'] = {};
+                        const choices = (0, lodash_1.isArray)(element.choice.element)
+                            ? element.choice.element
+                            : [element.choice.element];
+                        choices.forEach((choice) => {
+                            const obj = removeAttributeTag(choice);
+                            const choiceData = ChoiceSchemaIncoming.parse(obj);
+                            if (!choiceData.label) {
+                                choiceData.label = obj.value;
+                            }
+                            element['choice_elements'][obj.value] = choiceData;
+                        });
+                    }
+                    element = removeAttributeTag(element);
+                });
+                bootstrapData['columns'] = columns.reduce((map, obj) => ((map[obj['name']] = obj), map), {});
+                let elements = bootstrapDatabaseXML.data.element['index'];
+                elements = (0, lodash_1.isArray)(elements) ? elements : [elements];
+                elements.forEach((element) => {
+                    const idxData = IndexSchemaBootstrapAttributes.safeParse(element);
+                    if (idxData.success) {
+                        idxElements.push({
+                            name: idxData.data['@_name'],
+                            element: idxData.data.element['@_name'],
+                            unique: idxData.data['@_unique'] ?? false,
+                        });
+                    }
+                });
+                bootstrapData['index'] = idxElements;
+            }
+            return new sdk_build_core_1.XmlData(bootstrapData, xml.filePath, 'bootstrap');
+        },
+    },
+    composers: {
+        entity: {
+            table(entity, context) {
+                const node = entity.getNode();
+                const data = entity.getValue();
+                const table = exports.TableSchemaFull.parse(data);
+                const composeData = compose(table);
+                composeData['columns'] = composeColumns(table.schema, context, table.display);
+                const entities = [];
+                if (table.auto_number) {
+                    const data = table.auto_number;
+                    const numberRecord = SysNumber(table.name, data.number_of_digits, data.number, data.prefix);
+                    const composedNumber = RecordPlugin_1.RecordPlugin.composers.entity.record(new sdk_build_core_1.EntityData('record', context.registerExplicitId(numberRecord.table, numberRecord.$id), sdk_build_core_1.ObjectData.fromObjectValue(numberRecord, node), node), context);
+                    entities.push(composedNumber);
+                    composeData['number_ref'] = composedNumber.guid;
+                }
+                composeData['index'] = table.index;
+                entities.push({
+                    kind: 'bootstrap',
+                    node,
+                    guid: composeData.name,
+                    data: { data: { bootstrapData: composeData, dbObjectData: composeData } },
+                });
+                return entities;
+            },
+        },
+        xml: {
+            bootstrap(xml) {
+                return {
+                    kind: xml.kind,
+                    guid: xml.data['name'],
+                    data: { data: { bootstrapData: xml.data } },
+                };
+            },
+            sys_db_object(xml) {
+                return {
+                    kind: 'bootstrap',
+                    guid: xml.data['name'],
+                    data: { data: { dbObjectData: xml.data } },
+                    action: xml.action,
+                };
+            },
+        },
+    },
+    generators: {
+        bootstrap(document, context) {
+            const parsedBoostrapData = TableSchemaBootstrapIncoming.safeParse(document.data.data.bootstrapData);
+            if (!parsedBoostrapData.success) {
+                return undefined;
+            }
+            return (0, sdk_build_core_1.linkDocument)(document, generateCallExpressionExportForDocument(context, {
+                sourceFile: (0, sdk_build_core_1.getOrCreateEntitySourceFile)(context, parsedBoostrapData.data.name),
+                moduleSpecifier: '@servicenow/sdk/core',
+                exportName: parsedBoostrapData.data.name,
+            }, db_1.Table, {}).getInitializerIfKindOrThrow(ts_morph_1.SyntaxKind.CallExpression));
+        },
+        record(document, context) {
+            if (document.data?.['table'] !== 'sys_documentation' &&
+                document.data?.['table'] !== 'ua_table_licensing_config') {
+                return;
+            }
+            return (0, sdk_build_core_1.linkDocument)(document, (0, sdk_build_core_1.generateCallExpression)(context, (0, sdk_build_core_1.getOrCreateEntitySourceFile)(context, `${document.data?.['data'].name}`), '@servicenow/sdk/core', db_1.Record, { $id: document.guid }));
+        },
+    },
+    serializers: {
+        bootstrap(document) {
+            const composedData = document.data.data;
+            const { columns, index, attributes, ...bootstrapData } = composedData.bootstrapData;
+            if (bootstrapData.live_feed) {
+                // live_feed needs to be a table sys_dictionary attribute so it can be synced to sys_db_object by a startup process
+                attributes['live_feed'] = true;
+            }
+            const builder = new sdk_build_core_1.XMLJsonBuilder('1.0');
+            const databaseObj = builder.createRoot('database', undefined, undefined);
+            const composedAttributes = composeAttributes(attributes);
+            const collectionObj = databaseObj.addJsonObj('element', undefined, { ...bootstrapData, attributes: composedAttributes });
+            for (const column of Object.values(columns)) {
+                const { choice_elements, attributes, ...parsedColumn } = column;
+                const columnAttributes = composeAttributes(attributes);
+                const elementObj = collectionObj.addJsonObj('element', undefined, {
+                    ...parsedColumn,
+                    attributes: columnAttributes,
+                });
+                buildChoices(column, elementObj);
+            }
+            buildIndexes(index, collectionObj);
+            const bootstrapXmlJson = new fast_xml_parser_1.XMLBuilder({
+                ignoreAttributes: false,
+                format: true,
+                suppressBooleanAttributes: false,
+                suppressEmptyNode: true,
+            }).build(builder.buildJsonObj());
+            return {
+                name: `${bootstrapData.name}.xml`,
+                directory: 'dictionary',
+                content: bootstrapXmlJson,
+                usedIds: [],
+            };
+        },
+    },
+    transformers: {
+        bootstrap: {
+            CallExpression(document) {
+                const expressionName = (0, sdk_build_core_1.getCallExpressionName)(document.node);
+                if (expressionName !== db_1.Table.name) {
+                    return false;
+                }
+                const [args] = document.node.getArguments();
+                if (!ts_morph_1.Node.isObjectLiteralExpression(args)) {
+                    return false;
+                }
+                if (document.action === 'DELETE') {
+                    (0, sdk_build_core_1.removeNode)(document.node);
+                    return true;
+                }
+                if (!document.changedData) {
+                    return true;
+                }
+                const composedData = document.changedData.data;
+                const xmlData = document.xmlData.data;
+                let bootstrap_data = {};
+                let db_data = {};
+                if (!(0, lodash_1.isEmpty)(composedData.bootstrapData)) {
+                    // sys_db_object or node without bootstrap.xml. Mark as handled and ignore
+                    bootstrap_data = TableSchemaBootstrapIncoming.partial().parse(composedData.bootstrapData);
+                }
+                if (!(0, lodash_1.isEmpty)(composedData.dbObjectData)) {
+                    db_data = DBObjectIncomingAttributes.partial().parse(composedData.dbObjectData);
+                }
+                const { auto_number, number_ref, extends: ext, index, columns, ...bootstrap_rest } = mapNames(bootstrap_data);
+                const { create_access, delete_access, update_access, read_access, caller_access, ...db_rest } = mapNames(db_data);
+                const rest = { ...bootstrap_rest, ...db_rest };
+                if (ext) {
+                    rest['extends'] = ext;
+                }
+                if (caller_access) {
+                    rest['caller_access'] = exports.callerAccess[caller_access];
+                }
+                if (!(0, lodash_1.isEmpty)(db_data)) {
+                    const actions = getActionsArray({ create_access, delete_access, update_access, read_access });
+                    if (actions.length > 0) {
+                        (0, sdk_build_core_1.writeCustomProperty)(args, 'actions', '[]', (0, sdk_build_core_1.stringify)(actions));
+                    }
+                    else {
+                        const actionsProp = (0, sdk_build_core_1.getOrCreatePropertyAssignment)(args, 'actions', '[]');
+                        actionsProp.remove();
+                    }
+                }
+                if (!rest.attributes) {
+                    delete rest.attributes;
+                }
+                if (xmlData.bootstrapData && xmlData.bootstrapData.index) {
+                    const indexProp = (0, sdk_build_core_1.getOrCreatePropertyAssignment)(args, 'index', '[]');
+                    indexProp.setInitializer((0, sdk_build_core_1.stringify)(xmlData.bootstrapData.index));
+                    if (xmlData.bootstrapData.index.length === 0) {
+                        indexProp.remove();
+                    }
+                }
+                (0, sdk_build_core_1.transformFunctionArguments)(document.node, db_1.Table, rest);
+                // Handle columns
+                const incomingColumns = xmlData.bootstrapData ? xmlData.bootstrapData.columns : undefined;
+                updateDisplayValue(document.node, columns, incomingColumns);
+                transformColumns(incomingColumns, args);
+                return true;
+            },
+        },
+    },
+    postProcessors: {
+        entities(entities, context) {
+            entities
+                .filter((entity) => entity.getKind() === 'table')
+                .forEach((table) => {
+                const tableName = table.getProperty('name').getValue();
+                const originalSourceFilePath = path.normalize(table.getNode().getSourceFile().getFilePath());
+                context.compiler.addTableInterfaceToGlobalDeclaration(originalSourceFilePath, tableName);
+            });
+        },
+    },
+});
+function generateCallExpressionExportForDocument(context, info, fn, ...args) {
+    const { sourceFile, moduleSpecifier } = info;
+    return (0, sdk_build_core_1.generateCallExpressionExport)(context, sourceFile, moduleSpecifier, info.exportName, fn, ...args);
+}
+function composeAttributes(attributes) {
+    if (!attributes) {
+        return '';
+    }
+    return Object.entries(attributes)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(',');
+}
+function updateDisplayValue(node, columns, incomingColumns) {
+    const display = Object.values(columns ?? {}).filter((col) => col.display);
+    if (display) {
+        const displayName = Object.values(incomingColumns ?? {}).find((c) => c.display);
+        if (displayName) {
+            (0, sdk_build_core_1.transformFunctionArguments)(node, db_1.Table, { display: displayName.name });
+        }
+    }
+}
+function composeColumns(columns, context, display) {
+    const composedColumns = {};
+    for (const [columnName, columnData] of Object.entries(columns)) {
+        const column = exports.ColumnSchema.parse(columnData);
+        const requiresDropdown = column.dynamic_value_definitions || column.choices;
+        const element = {
+            name: columnName,
+            type: column.entityKind === 'generic' ? column.column_type : column.entityKind,
+            attributes: column.attributes ?? undefined,
+            reference: column.referenceTable,
+            audit: column.audit,
+            label: column.label ?? columnName,
+            max_length: column.maxLength,
+            mandatory: column.mandatory,
+            read_only: column.read_only,
+            choice: db_1.choiceDropdown.indexOf(column.dropdown ?? requiresDropdown ? 'dropdown_with_none' : 'none'),
+            display: display ? display === columnName : false,
+            // dynamic values
+            virtual: column.dynamic_value_definitions?.type === 'calculated_value' ? true : undefined,
+            calculation: column.dynamic_value_definitions?.type === 'calculated_value'
+                ? getScriptInfo(column.dynamic_value_definitions['calculated_value'], context)
+                : undefined,
+            choice_table: column.dynamic_value_definitions?.type === 'choices_from_other_table'
+                ? column.dynamic_value_definitions.table
+                : undefined,
+            choice_field: column.dynamic_value_definitions?.type === 'choices_from_other_table'
+                ? column.dynamic_value_definitions.field
+                : undefined,
+            use_dependent_field: column.dynamic_value_definitions?.type === 'dependent_field' || undefined,
+            dependent: column.dynamic_value_definitions?.type === 'dependent_field'
+                ? column.dynamic_value_definitions['column_name']
+                : undefined,
+            use_dynamic_default: column.dynamic_value_definitions?.type === 'dynamic_default' || undefined,
+            default_value: column.dynamic_value_definitions?.type === 'dynamic_default'
+                ? getDynamicDefault(column.dynamic_value_definitions?.dynamic_default)
+                : undefined,
+            default: column.default,
+            function_definition: column.function_definition,
+            function_field: column.function_definition ? true : false,
+        };
+        if (column.choices) {
+            Object.keys(column.choices).forEach((key) => {
+                if ((0, lodash_1.isObject)(column.choices[key])) {
+                    column.choices[key] = { value: key, ...column.choices[key] };
+                }
+                else {
+                    column.choices[key] = { value: key, label: column.choices[key] };
+                }
+            });
+            element['choice_elements'] = zod_1.z.record(ChoiceSchema).parse(column.choices);
+        }
+        composedColumns[columnName] = element;
+    }
+    return composedColumns;
+}
+function compose(bootstrapData) {
+    if (bootstrapData.live_feed) {
+        bootstrapData.attributes = {
+            // live_feed needs to be a table sys_dictionary attribute so it can be synced to sys_db_object by a startup process
+            ...bootstrapData.attributes,
+            live_feed: true,
+        };
+    }
+    const composedData = {
+        // Generic data
+        name: bootstrapData.name,
+        type: 'collection',
+        extends: bootstrapData.extends,
+        label: bootstrapData.label ?? bootstrapData.name,
+        // Controls
+        is_extendable: bootstrapData.extensible,
+        text_index: bootstrapData.text_index,
+        read_only: bootstrapData.read_only,
+        audit: bootstrapData.audit,
+        access: bootstrapData.accessible_from,
+        caller_access: exports.callerAccess.indexOf(bootstrapData.caller_access ?? 'none'),
+        read_access: bootstrapData.actions?.includes('read'),
+        update_access: bootstrapData.actions?.includes('update'),
+        create_access: bootstrapData.actions?.includes('create'),
+        delete_access: bootstrapData.actions?.includes('delete'),
+        ws_access: bootstrapData.allow_web_service_access,
+        alter_access: bootstrapData.allow_new_fields,
+        actions_access: bootstrapData.allow_ui_actions,
+        client_scripts_access: bootstrapData.allow_client_scripts,
+        attributes: bootstrapData.attributes,
+    };
+    return composedData;
+}
+// API properties that are different in the bootstrap/sys_db_object file
+const property_name_mapping = {
+    client_scripts_access: 'allow_client_scripts',
+    alter_access: 'allow_new_fields',
+    actions_access: 'allow_ui_actions',
+    ws_access: 'allow_web_service_access',
+    is_extendable: 'extensible',
+    access: 'accessible_from',
+    live_feed_enabled: 'live_feed',
+};
+function mapNames(schema) {
+    Object.keys(schema).forEach((key) => {
+        if (property_name_mapping[key]) {
+            schema[property_name_mapping[key]] = schema[key];
+            delete schema[key];
+        }
+    });
+    return schema;
+}
+let schemaPosition = 4;
+function transformColumns(incoming_schema, args) {
+    const schemaProperty = (0, sdk_build_core_1.getOrCreatePropertyAssignment)(args, 'schema', '{}');
+    const schemaLiteral = schemaProperty.getChildrenOfKind(ts_morph_1.ts.SyntaxKind.ObjectLiteralExpression)[0];
+    if (!schemaLiteral) {
+        return;
+    }
+    const keys = Object.keys(incoming_schema ?? {});
+    if (keys.length === 0) {
+        return;
+    }
+    //TODO:: need to come up with a way to format script more accurately
+    schemaPosition = schemaLiteral.getSourceFile().getLineAndColumnAtPos(schemaLiteral.getStart()).column;
+    const assignments = [];
+    keys.forEach((key) => {
+        const data = incoming_schema[key];
+        const callExpFromType = getCallExpressionFromType(data.type);
+        const transformedColumn = transformColumnData(data, callExpFromType);
+        const callExp = generateColumnExpression(callExpFromType, {
+            ...transformedColumn,
+            choices: data.choice_elements,
+        });
+        assignments.push(ts_morph_1.ts.factory.createPropertyAssignment((0, sdk_build_core_1.createPropertyIdentifier)(data.name), callExp));
+    });
+    schemaLiteral.transform((traversal) => {
+        if (ts_morph_1.ts.isObjectLiteralExpression(traversal.currentNode)) {
+            return traversal.factory.updateObjectLiteralExpression(traversal.currentNode, assignments);
+        }
+        return traversal.currentNode;
+    });
+}
+function getActionsArray(data) {
+    const actions = [];
+    if (data.read_access) {
+        actions.push('read');
+    }
+    if (data.update_access) {
+        actions.push('update');
+    }
+    if (data.delete_access) {
+        actions.push('delete');
+    }
+    if (data.create_access) {
+        actions.push('create');
+    }
+    return actions;
+}
+function getDynamicDefault(val) {
+    return val.startsWith('javascript:') ? val : `javascript:${exports.dynamic_value_mapping[val]}`;
+}
+function buildIndexes(indexes = [], collection) {
+    indexes.forEach((index) => {
+        const indexElement = collection.addJsonObj('index', undefined, { name: index.name, unique: index.unique });
+        indexElement.addJsonObj('element', undefined, { name: index.element });
+    });
+}
+function buildChoices(column, element) {
+    if (!column.choice_elements) {
+        return;
+    }
+    const choices = element.addJsonObj('choice', undefined, undefined);
+    if (Array.isArray(column.choices) && column.choices.length > 0) {
+        // Formatted - choices: [1, 2, 3, 4]
+        for (const choice in column.choices) {
+            choices.addJsonObj('element', undefined, {
+                value: column.choices[choice],
+                label: column.choices[choice],
+            });
+        }
+    }
+    else {
+        // Formatted - choices: { 1: { label: 'label' }, 2: { lable: label 2}, ...}
+        Object.entries(column.choice_elements).forEach((value) => {
+            if ((0, lodash_1.isObject)(value[1])) {
+                choices.addJsonObj('element', undefined, {
+                    value: value[0],
+                    ...value[1],
+                });
+            }
+            else {
+                choices.addJsonObj('element', undefined, {
+                    value: value[1],
+                    label: value[0],
+                });
+            }
+        });
+    }
+}
+function transformColumnData(col, callExpFromType) {
+    const { type: internal_type, choice, name, virtual, display, choice_table, choice_field, use_dependent_field, dependent, calculation, use_dynamic_default, default_value, choice_elements, table, default: def, max_length, reference, function_field, ...column } = col;
+    if (max_length) {
+        column.maxLength = max_length;
+    }
+    if (internal_type && (callExpFromType.entityKind === 'generic' || callExpFromType.name === 'GenericColumn')) {
+        column.column_type = internal_type;
+    }
+    if (choice !== undefined) {
+        column.dropdown = db_1.choiceDropdown[choice];
+    }
+    if (reference) {
+        column.referenceTable = reference;
+    }
+    // Handle dynamic values
+    if (calculation) {
+        column.dynamic_value_definitions = {
+            type: 'calculated_value',
+            calculated_value: calculation,
+        };
+    }
+    else if (choice_table || choice_field) {
+        column.dynamic_value_definitions = {
+            type: 'choices_from_other_table',
+            table: choice_table,
+            field: choice_field,
+        };
+    }
+    else if (dependent) {
+        column.dynamic_value_definitions = {
+            type: 'dependent_field',
+            column_name: dependent,
+        };
+    }
+    else if (def) {
+        column.default = def;
+    }
+    else if (default_value) {
+        column.dynamic_value_definitions = {
+            type: 'dynamic_default',
+            dynamic_default: def,
+        };
+    }
+    if (column.label && column.label === name) {
+        delete column.label;
+    }
+    if ((0, lodash_1.isEmpty)(column.attributes)) {
+        delete column.attributes;
+    }
+    else if (isDefaultEdgeEncryptionAttribute(column.attributes)) {
+        delete column.attributes;
+    }
+    return column;
+}
+// The instance will sometimes add edge_encryption_enabled=true, this is a default so don't write it if it is the only one
+function isDefaultEdgeEncryptionAttribute(attributes) {
+    return (attributes &&
+        Object.entries(attributes).length === 1 &&
+        attributes.edge_encryption_enabled !== undefined &&
+        attributes.edge_encryption_enabled);
+}
+function getScriptInfo(scriptInfo, context) {
+    if ((0, lodash_1.isString)(scriptInfo)) {
+        return scriptInfo;
+    }
+    const { filePath, functionName, isDefault } = scriptInfo;
+    const script = (0, scriptUtils_1.buildScriptImport)(filePath, functionName, isDefault, context, (funcName) => `;${funcName}(current)`);
+    return script.replaceAll('\n', '');
+}
+function removeAttributeTag(obj) {
+    Object.entries(obj).forEach(([key, value]) => {
+        if (key.startsWith('@_')) {
+            obj[key.substring(2)] = value;
+            delete obj[key];
+        }
+    });
+    return obj;
+}
+function SysNumber(category, maximum_digits, number, prefix) {
+    return (0, db_1.Record)({
+        table: 'sys_number',
+        $id: `${category}_${prefix}`,
+        data: {
+            category,
+            maximum_digits: maximum_digits ?? 1000,
+            number: number ?? 7,
+            prefix: prefix ?? 'PRE',
+        },
+    });
+}
+// TODO should this reference sys_filter_option_dynamic instead?
+exports.dynamic_value_mapping = {
+    'Current Name': `current.name`,
+    'Next ECC Sequence Number': `GlideCounter.next('ecc:sequence');`,
+    'Get Module View': `var viewDefault='';if(current.device_type=='mobile') viewDefault='Mobile';else if(!current.application.nil() && current.application.device_type=='mobile' && current.device_type.nil()) viewDefault='Mobile';viewDefault`,
+    'Get Label Display Value': `gs.getDisplayValueFor(current.table, current.table_key, '')`,
+    'Get CMDB Item Category': `gs.include("CMDBItem");var item = new CMDBItem(current);item.setCategory();`,
+    'Parent Record Matcher Table': `if (typeof parent != "undefined") parent.matcher_table`,
+    'Next Cache Flush Number': `GlideCounter.next('sys_cache_flush');`,
+    'Get Next Number': `global.getNextObjNumber()`,
+    'Next Workflow Log Order Number': `GlideCounter.next('wf_log:order');`,
+    Subject: 'email.subject',
+    'Get Mobile Module View': `var viewDefault='';if(typeof parent != 'undefined')if(parent.device_type=='mobile') viewDefault='Mobile';viewDefault`,
+    'Parent Record Model Table': `if (typeof parent != "undefined") parent.model_table`,
+    'Get Label Table Display Value': `gs.getDisplayValueFor(current.table, current.table_key, 'sys_class_name')`,
+    'Parent Record Source Table': `if (typeof parent != "undefined") parent.source_table`,
+    'Get Next Padded Number': `global.getNextObjNumberPadded();`,
+    'My First Name': `gs.getUser().firstName`,
+    'My Last Name': `gs.getUser().lastName`,
+    'My Job Title': `gs.getUser().title`,
+};
+function generateColumnExpression(expression, args, argsSetIfDefined) {
+    const setArgs = { ...args };
+    if (argsSetIfDefined) {
+        Object.keys(argsSetIfDefined).forEach((key) => {
+            if (argsSetIfDefined[key] !== undefined) {
+                setArgs[key] = argsSetIfDefined[key];
+            }
+        });
+    }
+    return ts_morph_1.ts.factory.createCallExpression(ts_morph_1.ts.factory.createIdentifier(expression.name), undefined, [
+        createObjectExpression(setArgs),
+    ]);
+}
+function createObjectExpression(firstArg) {
+    return ts_morph_1.ts.factory.createObjectLiteralExpression(Object.entries(firstArg)
+        .filter(([_key, value]) => value !== undefined)
+        .map(([key, value]) => {
+        if (key === 'referenceTable') {
+            return ts_morph_1.ts.factory.createPropertyAssignment(ts_morph_1.ts.factory.createIdentifier('referenceTable'), ts_morph_1.ts.factory.createStringLiteral(value));
+        }
+        else if (key === 'calculated_value') {
+            const calVal = `${os.EOL}${(0, ScriptTemplatePlugin_1.formatScript)(value, schemaPosition)}`;
+            return ts_morph_1.ts.factory.createPropertyAssignment(ts_morph_1.ts.factory.createIdentifier(key), ts_morph_1.ts.factory.createTaggedTemplateExpression(ts_morph_1.ts.factory.createIdentifier('script'), undefined, ts_morph_1.ts.factory.createNoSubstitutionTemplateLiteral(calVal, calVal)));
+        }
+        return ts_morph_1.ts.factory.createPropertyAssignment((0, sdk_build_core_1.createPropertyIdentifier)(key), factoryCreateValue(value, ts_morph_1.ts.factory));
+    }));
+}
+function factoryCreateValue(value, factory) {
+    if (typeof value === 'string') {
+        return factory.createStringLiteral(value);
+    }
+    if (typeof value === 'number') {
+        if (value >= 0) {
+            return factory.createNumericLiteral(value);
+        }
+        else {
+            return factory.createPrefixUnaryExpression(ts_morph_1.ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+        }
+    }
+    if (typeof value === 'boolean') {
+        return value ? factory.createTrue() : factory.createFalse();
+    }
+    if (typeof value === 'object') {
+        if (value === null) {
+            return factory.createNull();
+        }
+        if ((0, lodash_1.isArray)(value)) {
+            const newvals = [];
+            Object.values(value).forEach((v) => {
+                newvals.push(factoryCreateValue(v, factory));
+            });
+            return factory.createArrayLiteralExpression(newvals);
+        }
+        else if (ts_morph_1.Structure.isImportSpecifier(value)) {
+            return factory.createIdentifier(value['name']);
+        }
+        else {
+            return createObjectExpression(value);
+        }
+    }
+    return factory.createNull();
+    // throw new Error(`Unsupported value type: ${typeof value}`)
+}
+function getCallExpressionFromType(internal_type) {
+    switch (internal_type) {
+        case 'boolean':
+            return db_1.BooleanColumn;
+        case 'choice':
+            return db_1.ChoiceColumn;
+        case 'conditions':
+            return db_1.ConditionsColumn;
+        case 'date':
+            return db_1.OtherDateColumn;
+        case 'calendar_date_time':
+            return db_1.CalendarDateTimeColumn;
+        case 'datetime':
+            return db_1.BasicDateTimeColumn;
+        case 'due_date':
+            return db_1.DueDateColumn;
+        case 'glide_date':
+            return db_1.DateColumn;
+        case 'glide_date_time':
+            return db_1.DateTimeColumn;
+        case 'integer_date':
+            return db_1.IntegerDateColumn;
+        case 'schedule_date_time':
+            return db_1.ScheduleDateTimeColumn;
+        case 'decimal':
+            return db_1.DecimalColumn;
+        case 'document_id':
+            return db_1.DocumentIdColumn;
+        case 'domain_id':
+            return db_1.DomainIdColumn;
+        case 'domain_path':
+            return db_1.DomainPathColumn;
+        case 'field_name':
+            return db_1.FieldNameColumn;
+        case 'integer':
+            return db_1.IntegerColumn;
+        case 'radio':
+            return db_1.RadioColumn;
+        case 'reference':
+            return db_1.ReferenceColumn;
+        case 'script':
+            return db_1.ScriptColumn;
+        case 'sys_class_name':
+            return db_1.SystemClassNameColumn;
+        case 'table_name':
+            return db_1.TableNameColumn;
+        case 'translated_field':
+            return db_1.TranslatedFieldColumn;
+        case 'translated_text':
+            return db_1.TranslatedTextColumn;
+        case 'user_roles':
+            return db_1.UserRolesColumn;
+        case 'version':
+            return db_1.VersionColumn;
+        case 'string':
+            return db_1.StringColumn;
+        case 'int':
+        case 'string_types':
+        case 'approval_rules':
+        case 'audio':
+        case 'auto_increment':
+        case 'auto_number':
+        case 'bootstrap_color':
+        case 'breakdown_element':
+        case 'catalog_preview':
+        case 'char':
+        case 'collection':
+        case 'color':
+        case 'color_display':
+        case 'composite_field':
+        case 'composite_name':
+        case 'compressed':
+        case 'condition_string':
+        case 'counter':
+        case 'css':
+        case 'currency':
+        case 'currency2':
+        case 'data_array':
+        case 'data_object':
+        case 'data_structure':
+        case 'days_of_week':
+        case 'day_of_week':
+        case 'documentation_field':
+        case 'dynamic_json':
+        case 'email':
+        case 'email_script':
+        case 'expression':
+        case 'external_names':
+        case 'field_list':
+        case 'file_attachment':
+        case 'float':
+        case 'formula':
+        case 'geo_point':
+        case 'glide_action_list':
+        case 'glide_duration':
+        case 'glide_list':
+        case 'glide_precise_time':
+        case 'glide_time':
+        case 'glide_utc_time':
+        case 'glide_var':
+        case 'glyphicon':
+        case 'graphql_schema':
+        case 'GUID':
+        case 'html':
+        case 'html_script':
+        case 'html_template':
+        case 'icon':
+        case 'image':
+        case 'index_name':
+        case 'insert_timestamp':
+        case 'integer_time':
+        case 'internal_type':
+        case 'ip_addr':
+        case 'ip_address':
+        case 'journal':
+        case 'journal_input':
+        case 'journal_list':
+        case 'json':
+        case 'json_translations':
+        case 'language':
+        case 'long':
+        case 'longint':
+        case 'mask_code':
+        case 'metric_absolute':
+        case 'metric_counter':
+        case 'metric_derive':
+        case 'metric_gauge':
+        case 'mid_config':
+        case 'month_of_year':
+        case 'multi_small':
+        case 'multi_two_lines':
+        case 'name_values':
+        case 'nds_icon':
+        case 'nl_task_int1':
+        case 'order_index':
+        case 'password':
+        case 'password2':
+        case 'percent_complete':
+        case 'phone_number':
+        case 'phone_number_e164':
+        case 'ph_number':
+        case 'price':
+        case 'properties':
+        case 'records':
+        case 'reference_name':
+        case 'related_tags':
+        case 'reminder_field_name':
+        case 'repeat_count':
+        case 'repeat_type':
+        case 'replication_payload':
+        case 'schedule_interval_count':
+        case 'script_client':
+        case 'script_plain':
+        case 'script_server':
+        case 'short_field_name':
+        case 'short_table_name':
+        case 'simple_name_values':
+        case 'slushbucket':
+        case 'snapshot_template_value':
+        case 'source_id':
+        case 'source_name':
+        case 'source_table':
+        case 'string_boolean':
+        case 'string_full_utf8':
+        case 'structure':
+        case 'sysevent_name':
+        case 'sysrule_field_name':
+        case 'sys_class_path':
+        case 'template_value':
+        case 'time':
+        case 'timer':
+        case 'translated':
+        case 'translated_html':
+        case 'tree_code':
+        case 'tree_path':
+        case 'url':
+        case 'user_image':
+        case 'user_input':
+        case 'variables':
+        case 'variable_conditions':
+        case 'variable_template_value':
+        case 'video':
+        case 'week_of_month':
+        case 'wide_text':
+        case 'wiki_text':
+        case 'wms_job':
+        case 'workflow':
+        case 'workflow_conditions':
+        case 'xml':
+        default:
+            return db_1.GenericColumn;
+    }
+}
+//# sourceMappingURL=TablePlugin.js.map