@servicenow/sdk-build-plugins 3.0.2 → 4.0.0

package/dist/table-plugin.js

@@ -0,0 +1,1324 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TablePlugin = void 0;
+exports.isDefaultLicenseConfig = isDefaultLicenseConfig;
+const sdk_build_core_1 = require("@servicenow/sdk-build-core");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const zod_1 = require("zod");
+const column_plugin_1 = require("./column-plugin");
+const xmlbuilder2_1 = require("xmlbuilder2");
+const column_helper_1 = require("./column/column-helper");
+const utils_1 = require("./utils");
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+// Bootstrap XML schema
+const BooleanFromString = zod_1.z
+    .string()
+    .transform((str) => str === 'true')
+    .or(zod_1.z.boolean())
+    .optional();
+const ChoiceElementSchema = 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().or(zod_1.z.string()).optional(),
+    '@_hint': zod_1.z.string().optional(),
+    '@_inactive': BooleanFromString.optional(),
+    '@_inactive_on_update': BooleanFromString.optional(),
+    '@_language': zod_1.z.string().optional(),
+});
+const IndexElementSchema = zod_1.z.object({
+    '@_name': zod_1.z.string(),
+});
+const IndexSchema = zod_1.z.object({
+    '@_name': zod_1.z.string(),
+    '@_unique': BooleanFromString.optional(),
+    element: zod_1.z.array(IndexElementSchema).or(IndexElementSchema),
+});
+const ColumnSchema = zod_1.z
+    .object({
+    '@_name': zod_1.z.string(),
+    '@_type': zod_1.z.string().optional(),
+    '@_internal_type': zod_1.z.string().optional(),
+    '@_default': zod_1.z.string().optional(),
+    '@_default_value': zod_1.z.string().optional(),
+    '@_max_length': zod_1.z.coerce.number().or(zod_1.z.string()).optional(),
+    '@_mandatory': BooleanFromString.optional(),
+    '@_read_only': BooleanFromString.optional(),
+    '@_reference_table': zod_1.z.string().optional(),
+    '@_reference_qual': zod_1.z.string().optional(),
+    '@_label': zod_1.z.string().optional(),
+    '@_choice': zod_1.z.coerce.number().optional(),
+    '@_active': BooleanFromString.optional(),
+    '@_display': BooleanFromString.optional(),
+    '@_use_dependent_field': BooleanFromString.optional(),
+    '@_use_dynamic_default': BooleanFromString.optional(),
+    '@_reference': zod_1.z.string().optional(),
+    '@_virtual': BooleanFromString.optional(),
+    '@_calculation': zod_1.z.string().optional(),
+    '@_choice_field': zod_1.z.string().optional(),
+    '@_function_definition': zod_1.z.string().optional(),
+    '@_reference_floats': BooleanFromString.optional(),
+    '@_reference_key': zod_1.z.string().optional(),
+    '@_dynamic_creation_script': zod_1.z.string().optional(),
+    '@_dynamic_creation': BooleanFromString.optional(),
+    '@_plural': zod_1.z.string().optional(),
+    '@_hint': zod_1.z.string().optional(),
+    '@_help': zod_1.z.string().optional(),
+    '@_widget': zod_1.z.string().optional(),
+    '@_table_reference': BooleanFromString.optional(),
+    '@_element_reference': BooleanFromString.optional(),
+    '@_unique': BooleanFromString.optional(),
+    '@_spell_check': BooleanFromString.optional(),
+    '@_xml_view': BooleanFromString.optional(),
+    '@_array': BooleanFromString.optional(),
+    '@_text_index': BooleanFromString.optional(),
+    '@_primary': BooleanFromString.optional(),
+    '@_attributes': zod_1.z.string().optional(),
+    '@_audit': BooleanFromString.optional(),
+    choice: zod_1.z
+        .object({
+        element: zod_1.z.array(ChoiceElementSchema).or(ChoiceElementSchema).optional(),
+    })
+        .optional(),
+})
+    .catchall(zod_1.z.any());
+const TableSchema = zod_1.z
+    .object({
+    '@_name': zod_1.z.string(),
+    '@_extends': zod_1.z.string().optional(),
+    '@_label': zod_1.z.string().optional(),
+    '@_plural': zod_1.z.string().optional(),
+    '@_audit': BooleanFromString.optional(),
+    '@_read_only': BooleanFromString.optional(),
+    '@_text_index': BooleanFromString.optional(),
+    '@_client_scripts_access': BooleanFromString.optional().default(true),
+    '@_ws_access': BooleanFromString.optional().default(true),
+    '@_alter_access': BooleanFromString.optional().default(true),
+    '@_create_access': BooleanFromString.optional().default(true),
+    '@_delete_access': BooleanFromString.optional().default(false),
+    '@_update_access': BooleanFromString.optional().default(true),
+    '@_actions_access': BooleanFromString.optional().default(true),
+    '@_read_access': BooleanFromString.optional().default(true),
+    '@_is_extendable': BooleanFromString.optional().default(false),
+    '@_scriptable_table': BooleanFromString.optional().default(false),
+    '@_attributes': zod_1.z.string().optional(),
+    element: zod_1.z.array(ColumnSchema).or(ColumnSchema).optional(),
+    index: zod_1.z.array(IndexSchema).or(IndexSchema).optional(),
+})
+    .catchall(zod_1.z.any());
+const BootstrapDatabaseSchema = zod_1.z.object({
+    element: TableSchema,
+});
+/**
+ * The access levels are mapped to the following values on the platform
+ *
+ * - `none`: 0
+ * - `tracking`: 1
+ * - `restricted`: 2
+ *
+ */
+const callerAccessLevels = ['none', 'tracking', 'restricted'];
+const tableNameRegex = /^[a-z_][a-z0-9_]*[a-z0-9]$/;
+const columnNameRegex = /^[a-z_][a-z0-9_]*$/;
+const tableAliases = {
+    readOnly: ['read_only'],
+    textIndex: ['text_index'],
+    allowWebServiceAccess: ['allow_web_service_access'],
+    allowNewFields: ['allow_new_fields'],
+    allowUiActions: ['allow_ui_actions'],
+    allowClientScripts: ['allow_client_scripts'],
+    licensingConfig: ['licensing_config'],
+    liveFeed: ['live_feed'],
+    accessibleFrom: ['accessible_from'],
+    callerAccess: ['caller_access'],
+    scriptableTable: ['scriptable_table'],
+    autoNumber: ['auto_number'],
+};
+const documentationAliases = {
+    urlTarget: ['url_target'],
+};
+const autoNumberAliases = {
+    numberOfDigits: ['number_of_digits'],
+};
+const licensingAliases = {
+    licenseModel: ['license_model'],
+    ownerCondition: ['owner_condition'],
+    licenseCondition: ['license_condition'],
+    isFulfillment: ['is_fulfillment'],
+    opDelete: ['op_delete'],
+    opUpdate: ['op_update'],
+    opInsert: ['op_insert'],
+    licenseRoles: ['license_roles'],
+};
+exports.TablePlugin = sdk_build_core_1.Plugin.create({
+    name: 'TablePlugin',
+    files: [
+        {
+            matcher: /\.xml$/,
+            toRecord(file, { factory }) {
+                const xml = new fast_xml_parser_1.XMLParser({
+                    ignoreAttributes: false,
+                    alwaysCreateTextNode: true,
+                    htmlEntities: true,
+                }).parse(file.content).database;
+                if (!xml) {
+                    return { success: false };
+                }
+                const tableDef = parseTableBootstrapXml(xml);
+                if (!tableDef) {
+                    return { success: false };
+                }
+                const recordDefs = tableDefToRecordProperties(tableDef);
+                const [sysDbRecord, ...relatedRecords] = [
+                    ['sysDbObject', 'sys_db_object'],
+                    ['sysDictionary', 'sys_dictionary'],
+                    ['sysChoice', 'sys_choice'],
+                    ['sysIndex', 'sys_index'],
+                    ['sysDocumentation', 'sys_documentation'],
+                ].flatMap(([key, table]) => {
+                    return [recordDefs[key]].flat().map((rec) => factory.createRecord({
+                        source: file,
+                        table,
+                        properties: filterUndefinedProperties(rec),
+                    }));
+                });
+                return {
+                    success: true,
+                    value: sysDbRecord.with(...relatedRecords),
+                };
+            },
+        },
+    ],
+    records: {
+        sys_db_object: {
+            coalesce: ['name'],
+            relationships: {
+                sys_dictionary: {
+                    via: { name: 'name' },
+                    descendant: true,
+                    relationships: {
+                        sys_documentation: {
+                            descendant: true,
+                            via: {
+                                name: 'name',
+                                element: 'element',
+                            },
+                        },
+                        sys_choice: {
+                            descendant: true,
+                            via: {
+                                name: 'name',
+                                element: 'element',
+                            },
+                        },
+                        sys_choice_set: {
+                            descendant: true,
+                            via: {
+                                name: 'name',
+                                element: 'element',
+                            },
+                        },
+                    },
+                },
+                ua_table_licensing_config: {
+                    descendant: true,
+                    via: { name: 'name' },
+                },
+                sys_documentation: {
+                    descendant: true,
+                    via: { name: 'name' },
+                },
+                sys_number: {
+                    descendant: true,
+                    via: { category: 'name' },
+                },
+                sys_index: {
+                    descendant: true,
+                    via: { logical_table_name: 'name' },
+                },
+                sys_db_object: {
+                    descendant: false,
+                    via: 'super_class',
+                },
+            },
+            toShape(record, { descendants }) {
+                const schema = {};
+                let displayColumn;
+                const columns = descendants.query('sys_dictionary');
+                let collectionRecord;
+                const choices = descendants.query('sys_choice');
+                const documentation = descendants.query('sys_documentation');
+                for (const column of columns) {
+                    if (column.get('internal_type').getValue() === 'collection') {
+                        // 'collection' sys_dictionary record only has table properties
+                        collectionRecord = column;
+                        continue;
+                    }
+                    const columnName = column.get('element').asString().getValue();
+                    schema[columnName] = (0, column_plugin_1.columnToCallExpression)(column, {
+                        choices: choices.filter((choice) => choice.get('element').asString().getValue() === columnName),
+                        documentation: documentation.filter((d) => d.get('element').ifString()?.getValue() === columnName),
+                    });
+                    if (column.get('display').ifDefined()?.toBoolean().getValue()) {
+                        displayColumn = columnName;
+                    }
+                }
+                const tableDocumentation = documentation.filter((d) => !d.get('element').getValue());
+                const licensing = descendants.query('ua_table_licensing_config');
+                const autoNumber = descendants.query('sys_number');
+                const indexes = descendants.query('sys_index');
+                const originalSource = record.getOriginalSource();
+                // Avoid replacing call expressions with variable statements
+                const writeAsCallExpression = sdk_build_core_1.ts.Node.isNode(originalSource) && originalSource.isKind(sdk_build_core_1.ts.SyntaxKind.CallExpression);
+                const callExpression = new sdk_build_core_1.CallExpressionShape({
+                    source: record,
+                    callee: 'Table',
+                    args: [
+                        record
+                            .transform(({ $ }) => ({
+                            accessibleFrom: $.from('access')
+                                .map((access) => (access.ifString()?.getValue() === '' ? undefined : access))
+                                .def('public'),
+                            actions: $.from('read_access', 'update_access', 'delete_access', 'create_access')
+                                .map((readAccess, updateAccess, deleteAccess, createAccess) => {
+                                // TODO Add framework solution so these don't come in as strings
+                                const isTrueString = (value) => value === 'true';
+                                const actions = [];
+                                if (readAccess.ifBoolean()?.getValue() ||
+                                    isTrueString(readAccess.ifString()?.getValue())) {
+                                    actions.push('read');
+                                }
+                                if (updateAccess.ifBoolean()?.getValue() ||
+                                    isTrueString(updateAccess.ifString()?.getValue())) {
+                                    actions.push('update');
+                                }
+                                if (deleteAccess.ifBoolean()?.getValue() ||
+                                    isTrueString(deleteAccess.ifString()?.getValue())) {
+                                    actions.push('delete');
+                                }
+                                if (createAccess.ifBoolean()?.getValue() ||
+                                    isTrueString(createAccess.ifString()?.getValue())) {
+                                    actions.push('create');
+                                }
+                                return actions.length ? actions : undefined;
+                            })
+                                .def(['read']),
+                            allowClientScripts: $.from('client_scripts_access').toBoolean().def(false),
+                            allowNewFields: $.from('alter_access').toBoolean().def(false),
+                            allowUiActions: $.from('actions_access').toBoolean().def(false),
+                            allowWebServiceAccess: $.from('ws_access').toBoolean().def(false),
+                            attributes: $.val((() => {
+                                const attributes = collectionRecord?.get('attributes');
+                                if (!attributes?.isString()) {
+                                    return undefined;
+                                }
+                                const result = {};
+                                attributes
+                                    .toString()
+                                    .getValue()
+                                    .split(',')
+                                    .forEach((attr) => {
+                                    if (attr === '') {
+                                        return;
+                                    }
+                                    const [key, value] = attr.split('=').map((s) => s.trim());
+                                    if (value === 'true') {
+                                        result[key] = true;
+                                    }
+                                    else if (value === 'false') {
+                                        result[key] = false;
+                                    }
+                                    else {
+                                        result[key] = value;
+                                    }
+                                });
+                                return result;
+                            })()).def({ edgeEncryptionEnabled: true }),
+                            audit: $.val(collectionRecord?.get('audit')).toBoolean().def(false),
+                            autoNumber: $.val(autoNumber[0]
+                                ?.transform(({ $ }) => ({
+                                number: $.toNumber().def(1000),
+                                numberOfDigits: $.from('maximum_digits').toNumber().def(7),
+                                prefix: $.def('PRE'),
+                            }))
+                                .withAliasedKeys(autoNumberAliases)),
+                            callerAccess: $.from('caller_access')
+                                .map((callerAccess) => {
+                                if (callerAccess.isNumber()) {
+                                    return callerAccessLevels[callerAccess.getValue()];
+                                }
+                                if (callerAccess.isString()) {
+                                    const callerAccessString = callerAccess.getValue();
+                                    if (!isNaN(Number(callerAccessString))) {
+                                        return callerAccessLevels[Number(callerAccessString)];
+                                    }
+                                }
+                                return 'none';
+                            })
+                                .def('none'),
+                            display: displayColumn ? $.val(displayColumn) : undefined,
+                            extends: $.from('super_class').def(''),
+                            extensible: $.from('is_extendable').toBoolean().def(false),
+                            index: $.val(indexes.map((idx) => {
+                                return idx.transform(({ $ }) => ({
+                                    // TODO Find actual home of 'index_name' instead of using a fake property here
+                                    name: $.from('index_name'),
+                                    unique: $.from('unique_index').map((uniqueIndex) => uniqueIndex.ifBoolean() ?? false),
+                                    element: $.from('col_name_string').map((colNamesString) => {
+                                        const colNames = colNamesString.asString().getValue().split(',');
+                                        return colNames.length > 1 ? colNames : colNames[0];
+                                    }),
+                                }));
+                            })).def([]),
+                            label: $.map((label) => label.ifString() ??
+                                (tableDocumentation.length && !(0, column_plugin_1.isDefaultDocumentation)('', tableDocumentation)
+                                    ? tableDocumentation.map((doc) => doc
+                                        .transform(({ $ }) => ({
+                                        label: $.def(''),
+                                        help: $.def(''),
+                                        hint: $.def(''),
+                                        language: $.def(''),
+                                        plural: $.def(''),
+                                        url: $.def(''),
+                                        urlTarget: $.from('url_target').def(''),
+                                    }))
+                                        .withAliasedKeys(documentationAliases))
+                                    : undefined)),
+                            licensingConfig: licensing.length
+                                ? $.val(licensing[0]
+                                    .transform(({ $ }) => ({
+                                    licenseModel: $.from('license_model').def('none'),
+                                    ownerCondition: $.from('owner_condition').def(''),
+                                    licenseCondition: $.from('license_condition').def(''),
+                                    isFulfillment: $.from('is_fulfillment').toBoolean().def(false),
+                                    opDelete: $.from('op_delete').toBoolean().def(true),
+                                    opUpdate: $.from('op_update').toBoolean().def(true),
+                                    opInsert: $.from('op_insert').toBoolean().def(true),
+                                    licenseRoles: $.from('license_roles')
+                                        .map((v) => {
+                                        return v.isString() && !v.isEmpty()
+                                            ? v
+                                                .asString()
+                                                .getValue()
+                                                .split(',')
+                                                .map((role) => role.trim())
+                                            : [];
+                                    })
+                                        .def([]),
+                                }))
+                                    .withAliasedKeys(licensingAliases)).def({
+                                    licenseModel: 'none',
+                                    ownerCondition: '',
+                                    licenseCondition: '',
+                                    isFulfillment: false,
+                                    opDelete: true,
+                                    opUpdate: true,
+                                    opInsert: true,
+                                    licenseRoles: [],
+                                })
+                                : undefined,
+                            liveFeed: $.from('live_feed_enabled').toBoolean().def(false),
+                            name: $,
+                            readOnly: $.val(collectionRecord?.get('read_only')).toBoolean().def(false),
+                            schema: $.val(schema),
+                            scriptableTable: $.from('scriptable_table').toBoolean().def(false),
+                            textIndex: $.val(collectionRecord?.get('text_index')).toBoolean().def(false),
+                        }))
+                            .withAliasedKeys(tableAliases),
+                    ],
+                });
+                return {
+                    success: true,
+                    value: writeAsCallExpression
+                        ? callExpression
+                        : new sdk_build_core_1.VariableStatementShape({
+                            source: record,
+                            isExported: true,
+                            variableName: new sdk_build_core_1.IdentifierShape({
+                                source: record,
+                                name: record.get('name').asString().getValue(),
+                            }),
+                            initializer: callExpression,
+                        }),
+                };
+            },
+            toFile(record, { descendants, config }) {
+                if (config.tableOutputFormat !== 'bootstrap' || record.isDeleted()) {
+                    // Defer to record plugin
+                    return { success: false };
+                }
+                const tableName = record.get('name').asString().getValue();
+                const columns = descendants.query('sys_dictionary');
+                const choices = descendants.query('sys_choice');
+                const indexes = descendants.query('sys_index');
+                const documentation = descendants.query('sys_documentation');
+                const licensing = descendants.query('ua_table_licensing_config');
+                const autoNumber = descendants.query('sys_number');
+                let collectionRecord;
+                let displayColumn;
+                const elements = [];
+                for (const column of columns) {
+                    const displayValue = column.get('display').ifBoolean()?.getValue();
+                    if (displayValue) {
+                        displayColumn = column.get('element').asString().getValue();
+                    }
+                    if (column.get('internal_type').asString().getValue() === 'collection') {
+                        // collection element has only table properties
+                        collectionRecord = column;
+                        continue;
+                    }
+                    const defaultValue = column.get('default_value');
+                    const maxLength = column.get('max_length');
+                    const dependentOnField = column.get('dependent_on_field').ifString();
+                    const columnAttributes = [
+                        ['name', column.get('element').asString().getValue()],
+                        ['type', column.get('internal_type').asString().getValue()],
+                        ['active', column.get('active').ifBoolean()?.getValue().toString()],
+                        ['array', column.get('array').ifBoolean()?.getValue().toString()],
+                        ['audit', column.get('audit').ifBoolean()?.getValue().toString()],
+                        [
+                            'default_value',
+                            defaultValue.ifString()?.getValue() ??
+                                defaultValue.ifNumber()?.toString().getValue() ??
+                                defaultValue.ifBoolean()?.toString().getValue() ??
+                                defaultValue
+                                    .ifArray()
+                                    ?.getElements()
+                                    .map((v) => v.asString().getValue())
+                                    .join(', '),
+                        ],
+                        ['unique', column.get('unique').ifBoolean()?.getValue().toString()],
+                        ['label', column.get('column_label').ifString()?.getValue()],
+                        ['max_length', maxLength.ifNumber()?.getValue().toString() ?? maxLength.ifString()?.getValue()],
+                        ['mandatory', column.get('mandatory').ifBoolean()?.getValue().toString()],
+                        ['read_only', column.get('read_only').ifBoolean()?.getValue().toString()],
+                        ['reference_cascade_rule', column.get('reference_cascade_rule').ifString()?.getValue()],
+                        ['calculation', column.get('calculation').ifString()?.getValue()],
+                        ['choice', column.get('choice').ifNumber()?.getValue().toString()],
+                        ['choice_table', column.get('choice_table').ifString()?.getValue()],
+                        ['choice_field', column.get('choice_field').ifString()?.getValue()],
+                        ['display', displayValue?.toString()],
+                        ['function_field', column.get('function_field').ifBoolean()?.getValue().toString()],
+                        ['attributes', column.get('attributes').ifString()?.getValue()],
+                        ['inactive', column.get('inactive').ifBoolean()?.getValue().toString()],
+                        ['dynamic_default', column.get('dynamic_default').ifString()?.getValue()],
+                        ['spell_check', column.get('spell_check').ifBoolean()?.getValue().toString()],
+                        ['xml_view', column.get('xml_view').ifBoolean()?.getValue().toString()],
+                        ['table_reference', column.get('table_reference').ifBoolean()?.getValue().toString()],
+                        ['text_index', column?.get('text_index').ifBoolean()?.getValue().toString()],
+                        ['element_reference', column.get('element_reference').ifBoolean()?.getValue().toString()],
+                        ['primary', column.get('primary').ifBoolean()?.getValue().toString()],
+                        ['dependent', column.get('dependent').ifString()?.getValue().toString()],
+                        ['dependent_on_field', dependentOnField?.getValue()],
+                        [
+                            'use_dependent_field',
+                            dependentOnField ? (!!dependentOnField.getValue()).toString() : undefined,
+                        ],
+                        ['use_dynamic_default', column.get('use_dynamic_default').ifBoolean()?.getValue().toString()],
+                        ['reference', column.get('reference').ifString()?.getValue()],
+                        ['function_definition', column.get('function_definition').ifString()?.getValue()],
+                        ['reference_floats', column.get('reference_floats').ifBoolean()?.getValue().toString()],
+                        ['reference_key', column.get('reference_key').ifString()?.getValue()],
+                        ['dynamic_creation_script', column.get('dynamic_creation_script').ifString()?.getValue()],
+                        ['dynamic_creation', column.get('dynamic_creation').ifBoolean()?.getValue().toString()],
+                        ['plural', column.get('plural').ifString()?.getValue()],
+                        ['hint', column.get('hint').ifString()?.getValue()],
+                        ['help', column.get('help').ifString()?.getValue()],
+                        ['virtual', column.get('virtual').ifBoolean()?.getValue().toString()],
+                        ['widget', column.get('widget').ifString()?.getValue()],
+                        ['reference_qual', column.get('reference_qual').ifString()?.getValue()],
+                        ['reference_qual_condition', column.get('reference_qual_condition').ifString()?.getValue()],
+                    ];
+                    const choiceElements = choices
+                        .filter((choice) => choice.get('element').asString().getValue() ===
+                        column.get('element').asString().getValue())
+                        .map((choice) => createElement('element', filterUndefinedAttributes([
+                        ['value', choice.get('value').ifString()?.getValue()],
+                        ['label', choice.get('label').ifString()?.getValue()],
+                        [
+                            'dependent_value',
+                            choice.get('dependent_value').ifNumber()?.getValue().toString() ??
+                                choice.get('dependent_value').ifString()?.asString().getValue(),
+                        ],
+                        ['inactive', choice.get('inactive').ifBoolean()?.getValue().toString()],
+                        [
+                            'inactive_on_update',
+                            choice.get('inactive_on_update').ifBoolean()?.getValue().toString(),
+                        ],
+                        ['sequence', choice.get('sequence').ifNumber()?.getValue().toString()],
+                    ])));
+                    elements.push(createElement('element', filterUndefinedAttributes(columnAttributes), choiceElements.length ? [createElement('choice', [], choiceElements)] : []));
+                }
+                const indexElements = indexes.map((index) => {
+                    const indexAttributes = [
+                        ['name', index.get('index_name').ifString()?.getValue()],
+                        ['unique', index.get('unique_index').ifBoolean()?.getValue().toString()],
+                    ];
+                    const indexColumns = index
+                        .get('col_name_string')
+                        .asString()
+                        .getValue()
+                        .split(',')
+                        .map((col) => createElement('element', [['name', col.trim()]]));
+                    return createElement('index', filterUndefinedAttributes(indexAttributes), indexColumns);
+                });
+                const tableAttributes = [
+                    ['name', tableName],
+                    ['type', 'collection'],
+                    ['label', record.get('label').ifString()?.getValue()],
+                    ['extends', record.get('super_class').ifRecordId()?.getPrimaryKey()],
+                    ['is_extendable', record.get('is_extendable').ifBoolean()?.getValue().toString()],
+                    ['text_index', collectionRecord?.get('text_index').ifBoolean()?.getValue().toString()],
+                    ['read_only', collectionRecord?.get('read_only').ifBoolean()?.getValue().toString()],
+                    ['audit', collectionRecord?.get('audit').ifBoolean()?.getValue().toString()],
+                    ['display', displayColumn],
+                    ['access', record.get('access').ifString()?.getValue()],
+                    ['caller_access', record.get('caller_access').ifNumber()?.getValue().toString()],
+                    ['ws_access', record.get('ws_access').ifBoolean()?.getValue().toString()],
+                    ['read_access', record.get('read_access').ifBoolean()?.getValue().toString()],
+                    ['alter_access', record.get('alter_access').ifBoolean()?.getValue().toString()],
+                    ['create_access', record.get('create_access').ifBoolean()?.getValue().toString()],
+                    ['update_access', record.get('update_access').ifBoolean()?.getValue().toString()],
+                    ['delete_access', record.get('delete_access').ifBoolean()?.getValue().toString()],
+                    ['actions_access', record.get('actions_access').ifBoolean()?.getValue().toString()],
+                    ['client_scripts_access', record.get('client_scripts_access').ifBoolean()?.getValue().toString()],
+                    ['scriptable_table', record.get('scriptable_table').ifBoolean()?.getValue().toString()],
+                    ['attributes', collectionRecord?.get('attributes').ifString()?.getValue()],
+                ];
+                const tableXml = createElement('database', [], [
+                    createElement('element', filterUndefinedAttributes(tableAttributes), [
+                        ...elements,
+                        ...indexElements,
+                    ]),
+                ]).end({ prettyPrint: true });
+                const documentationFiles = generateRecordXml(documentation.filter((doc) => !(0, column_plugin_1.isDefaultDocumentation)(doc.get('element')?.toString().getValue(), [doc])), config, (doc) => `sys_documentation_${tableName}${doc.get('element').isDefined() ? `_${doc.get('element').asString().getValue()}` : ''}_${doc.get('language').isDefined() ? doc.get('language').asString().getValue() : 'en'}.xml`);
+                const licensingFiles = generateRecordXml(licensing.filter((licensing) => !isDefaultLicenseConfig(tableName, licensing)), config, (record) => `ua_table_licensing_config_${record.getId().getValue()}.xml`);
+                const autoNumberFiles = generateRecordXml(autoNumber, config, (record) => `sys_number_${record.getId().getValue()}.xml`);
+                return {
+                    success: true,
+                    value: [
+                        {
+                            name: `${tableName}.xml`,
+                            category: 'dictionary',
+                            content: tableXml,
+                        },
+                        ...documentationFiles,
+                        ...licensingFiles,
+                        ...autoNumberFiles,
+                    ],
+                };
+            },
+        },
+        sys_dictionary: {
+            coalesce: ['name', 'element'],
+        },
+        sys_documentation: {
+            coalesce: ['name', 'element', 'language'],
+        },
+        ua_table_licensing_config: {
+            coalesce: ['name'],
+        },
+        sys_index: {
+            coalesce: ['logical_table_name', 'col_name_string'],
+        },
+        sys_number: {
+            coalesce: ['category', 'prefix'],
+        },
+    },
+    shapes: [
+        {
+            shape: sdk_build_core_1.CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { config, factory, transform, diagnostics, compiler }) {
+                if (callExpression.getCallee() !== 'Table') {
+                    return { success: false };
+                }
+                const statement = callExpression
+                    .getOriginalNode()
+                    .getFirstAncestorByKind(sdk_build_core_1.ts.SyntaxKind.VariableStatement);
+                const table = callExpression.getArgument(0).asObject().withAliasedKeys(tableAliases);
+                (0, utils_1.generateDeprecatedDiagnostics)(table, diagnostics);
+                const relatedRecords = [];
+                const tableName = table.get('name').asString();
+                if (!tableName.getValue().match(tableNameRegex)) {
+                    diagnostics.error(table.get('name'), 'Table name must only contain lowercase letters, numbers, and underscores and end with a letter or number');
+                }
+                let ignoreColumnNameCheck = false;
+                const scopeName = config.scope;
+                const scopeRegex = new RegExp(`^${scopeName}_`);
+                const tableNameMatch = tableName.getValue().match(scopeRegex);
+                if (!tableNameMatch && !(0, sdk_build_core_1.isSNScope)(scopeName) && scopeName !== 'global') {
+                    const nameNode = tableName.getOriginalNode();
+                    if (nameNode && !nameNode.isKind(sdk_build_core_1.ts.SyntaxKind.AsExpression)) {
+                        // 'sn' and 'now' scoped apps ignore this validation
+                        diagnostics.error(table.get('name'), `'name' property should start with scope prefix '${scopeName}_'`);
+                    }
+                    else {
+                        ignoreColumnNameCheck = true;
+                    }
+                }
+                const declaration = callExpression.getOriginalNode().getParent();
+                const exportedByName = declaration?.isKind(sdk_build_core_1.ts.SyntaxKind.VariableDeclaration) &&
+                    declaration.isNamedExport() &&
+                    declaration.getName() === tableName.getValue();
+                if (!exportedByName) {
+                    diagnostics.error(callExpression, `Table definition should be exported as a named export with the name '${tableName.getValue()}'`);
+                }
+                // sys_dictionary
+                const schema = table.get('schema').asObject();
+                for (const [name, column] of schema.entries()) {
+                    if (!name.match(columnNameRegex)) {
+                        diagnostics.error(column.getOriginalNode().getParentIfKind(sdk_build_core_1.ts.SyntaxKind.PropertyAssignment) ?? column, 'Column name must only contain lowercase letters, numbers, and underscores');
+                    }
+                    if (!ignoreColumnNameCheck &&
+                        !tableNameMatch &&
+                        !(0, sdk_build_core_1.isSNScope)(scopeName) &&
+                        scopeName !== 'global' &&
+                        !name.match(scopeRegex)) {
+                        // 'sn' and 'now' scoped apps ignore this validation
+                        diagnostics.error(column.getOriginalNode().getParentIfKind(sdk_build_core_1.ts.SyntaxKind.PropertyAssignment) ?? column, `Column name should be prefixed with scope '${scopeName}_' if table name does not contain prefix`);
+                    }
+                    const display = table.get('display').ifString()?.getValue() === name;
+                    const result = await transform.toRecord((0, column_helper_1.addFieldsToColumn)({ name, table: tableName.getValue(), display }, column.as(sdk_build_core_1.CallExpressionShape)));
+                    if (!result.success) {
+                        diagnostics.error(column, 'Invalid column in table schema');
+                        return { success: false };
+                    }
+                    relatedRecords.push(result.value);
+                }
+                // sys_index
+                if (table.get('index').isArray()) {
+                    for (const index of table.get('index').asArray().getElements()) {
+                        const indexObject = index.asObject().getValue();
+                        const colNames = Array.isArray(indexObject['element'])
+                            ? indexObject['element'].join(',')
+                            : indexObject['element'];
+                        relatedRecords.push(factory.createRecord({
+                            source: statement ?? callExpression,
+                            table: 'sys_index',
+                            properties: {
+                                index_name: indexObject['name'],
+                                col_name_string: colNames,
+                                unique_index: indexObject['unique'] === true,
+                                logical_table_name: table.get('name').asString().getValue(),
+                            },
+                        }));
+                    }
+                }
+                // ua_table_licensing_config
+                if (table.get('licensingConfig').isObject()) {
+                    const licenseObj = table.get('licensingConfig').asObject().withAliasedKeys(licensingAliases);
+                    (0, utils_1.generateDeprecatedDiagnostics)(licenseObj, diagnostics);
+                    const licenseRecord = factory.createRecord({
+                        source: statement ?? callExpression,
+                        table: 'ua_table_licensing_config',
+                        properties: licenseObj.transform(({ $ }) => ({
+                            name: $.val(table.get('name')),
+                            license_model: $.from('licenseModel').def('none'),
+                            owner_condition: $.from('ownerCondition'),
+                            license_condition: $.from('licenseCondition'),
+                            is_fulfillment: $.from('isFulfillment').def(false),
+                            op_delete: $.from('opDelete').def(true),
+                            op_update: $.from('opUpdate').def(true),
+                            license_roles: $.from('licenseRoles')
+                                .map((licenseRoles) => {
+                                return (licenseRoles
+                                    .ifArray()
+                                    ?.getElements()
+                                    .map((e) => e.asString().getValue())
+                                    .join(',') ?? []);
+                            })
+                                .def([]),
+                            op_insert: $.from('opInsert').def(true),
+                        })),
+                    });
+                    relatedRecords.push(licenseRecord);
+                }
+                else {
+                    relatedRecords.push(factory.createRecord({
+                        source: statement ?? callExpression,
+                        table: 'ua_table_licensing_config',
+                        properties: {
+                            name: tableName,
+                            license_model: 'none',
+                            is_fulfillment: false,
+                            op_delete: true,
+                            op_insert: true,
+                            op_update: true,
+                        },
+                    }));
+                }
+                // sys_documentation
+                if (table.get('label').isArray()) {
+                    const documentation = table.get('label').asArray().getElements();
+                    const languages = new Set();
+                    for (const doc of documentation) {
+                        const docObject = doc.asObject().withAliasedKeys(documentationAliases);
+                        (0, utils_1.generateDeprecatedDiagnostics)(docObject, diagnostics);
+                        const language = docObject.get('language').ifString()?.getValue();
+                        if (language) {
+                            if (language.length !== 2) {
+                                diagnostics.error(doc.getOriginalNode(), `'language' must be a 2 character identifier (Ex. 'en', 'es')`);
+                            }
+                            if (languages.has(language)) {
+                                diagnostics.error(doc.getOriginalNode(), `'language' must be unique per table/column`);
+                            }
+                            languages.add(language);
+                        }
+                        relatedRecords.push(factory.createRecord({
+                            source: statement ?? callExpression,
+                            table: 'sys_documentation',
+                            properties: docObject.transform(({ $ }) => ({
+                                name: $.val(table.get('name').asString().getValue()),
+                                element: $.val(undefined),
+                                label: $,
+                                help: $,
+                                hint: $,
+                                language: $,
+                                plural: $,
+                                url: $,
+                                url_target: $.from('urlTarget'),
+                            })),
+                        }));
+                    }
+                }
+                else {
+                    relatedRecords.push(factory.createRecord({
+                        source: statement ?? callExpression,
+                        table: 'sys_documentation',
+                        properties: {
+                            name: tableName,
+                            element: undefined,
+                            language: 'en',
+                            label: table.get('label').ifString() ?? tableName,
+                            plural: (0, column_plugin_1.generatePlural)(table.get('label')?.ifString()?.getValue() ?? tableName.getValue()),
+                        },
+                    }));
+                }
+                // sys-number
+                let numberRef;
+                if (table.get('autoNumber').isObject()) {
+                    const autoNumber = table.get('autoNumber').asObject().withAliasedKeys(autoNumberAliases);
+                    const sysNumberRecord = factory.createRecord({
+                        source: statement ?? callExpression,
+                        table: 'sys_number',
+                        properties: autoNumber.transform(({ $ }) => ({
+                            category: $.val(table.get('name').getValue()),
+                            maximum_digits: $.from('numberOfDigits').toNumber().def(7),
+                            number: $.def(1000),
+                            prefix: $.from('prefix').def('PRE'),
+                        })),
+                    });
+                    numberRef = sysNumberRecord.getId();
+                    relatedRecords.push(sysNumberRecord);
+                }
+                // sys_dictionary (collection)
+                relatedRecords.push(factory.createRecord({
+                    source: statement ?? callExpression,
+                    table: 'sys_dictionary',
+                    properties: table.transform(({ $ }) => ({
+                        name: $,
+                        element: $.val(undefined),
+                        internal_type: $.def('collection'),
+                        attributes: $.map((attributes) => {
+                            if (!attributes.isObject()) {
+                                return undefined;
+                            }
+                            const attributesObj = attributes.asObject().getValue();
+                            return Object.entries(attributesObj)
+                                .map(([key, value]) => `${key}=${value}`)
+                                .join(',');
+                        }).def(''),
+                        audit: $.def(false),
+                        read_only: $.from('readOnly').def(false),
+                        text_index: $.from('textIndex').def(false),
+                    })),
+                }));
+                const hasAction = (actionName, actions) => {
+                    return actions
+                        .ifArray()
+                        ?.getElements()
+                        .some((action) => action.isString() && action.getValue() === actionName);
+                };
+                // sys_db_object
+                const tableRecord = factory.createRecord({
+                    source: statement ?? callExpression,
+                    table: 'sys_db_object',
+                    properties: table.transform(({ $ }) => ({
+                        client_scripts_access: $.from('allowClientScripts').toBoolean().def(false),
+                        alter_access: $.from('allowNewFields').toBoolean().def(false),
+                        actions_access: $.from('allowUiActions').toBoolean().def(false),
+                        ws_access: $.from('allowWebServiceAccess').toBoolean().def(false),
+                        number_ref: $.val(numberRef),
+                        access: $.from('accessibleFrom').def('public'),
+                        caller_access: $.from('callerAccess').map((callerAccess) => callerAccessLevels.indexOf((callerAccess.ifString()?.getValue() ?? 'none'))),
+                        super_class: $.from('extends').map((v) => v.ifString()?.pipe((parent) => factory.createReference({
+                            source: parent,
+                            table: 'sys_db_object',
+                            keys: { name: parent.getValue() },
+                        })) ?? v.ifDefined()?.toRecordId()),
+                        read_access: $.from('actions')
+                            .map((actions) => hasAction('read', actions))
+                            .def(true),
+                        update_access: $.from('actions')
+                            .map((actions) => hasAction('update', actions))
+                            .def(false),
+                        delete_access: $.from('actions')
+                            .map((actions) => hasAction('delete', actions))
+                            .def(false),
+                        create_access: $.from('actions')
+                            .map((actions) => hasAction('create', actions))
+                            .def(false),
+                        is_extendable: $.from('extensible').toBoolean().def(false),
+                        label: $.map((label) => (label.isString() ? label.asString() : undefined)),
+                        live_feed_enabled: $.from('liveFeed').toBoolean().def(false),
+                        name: $,
+                        scriptable_table: $.from('scriptableTable').toBoolean().def(false),
+                    })),
+                });
+                if (exportedByName) {
+                    addTableToGlobalGeneratedFile(table, callExpression.getOriginalFilePath(), compiler);
+                }
+                return {
+                    success: true,
+                    value: tableRecord.with(...relatedRecords),
+                };
+            },
+        },
+    ],
+    nodes: [
+        {
+            node: 'VariableStatement',
+            fileTypes: ['fluent'],
+            entryPoint: true,
+        },
+        {
+            node: 'ExportAssignment',
+            fileTypes: ['fluent'],
+            entryPoint: true,
+            toShape(node, { diagnostics }) {
+                const expression = node.getExpression().asKind(sdk_build_core_1.ts.SyntaxKind.CallExpression)?.getExpression();
+                if (expression && expression.getText() === 'Table') {
+                    diagnostics.error(expression, 'Export assignments are not supported for Table definitions');
+                }
+                return { success: false };
+            },
+        },
+    ],
+});
+function parseTableBootstrapXml(xml) {
+    const parsedXml = BootstrapDatabaseSchema.safeParse(xml);
+    if (!parsedXml.success) {
+        return null;
+    }
+    const table = parsedXml.data.element;
+    const columns = [];
+    if (table.element) {
+        const mapColumnToDefinition = (column) => ({
+            name: column['@_name'],
+            type: column['@_internal_type'] ?? column['@_type'],
+            defaultValue: column['@_default'] ?? column['@_default_value'],
+            audit: column['@_audit'],
+            maxLength: column['@_max_length'],
+            isMandatory: column['@_mandatory'],
+            isReadOnly: column['@_read_only'],
+            referenceTable: column['@_reference_table'],
+            referenceQual: column['@_reference_qual'],
+            columnLabel: column['@_label'],
+            choices: column.choice?.element
+                ? Array.isArray(column.choice.element)
+                    ? column.choice.element.map((choice) => ({
+                        label: choice['@_label'],
+                        value: choice['@_value'] ?? '',
+                        sequence: choice['@_sequence'],
+                        dependentValue: choice['@_dependent_value'],
+                        hint: choice['@_hint'],
+                        inactive: choice['@_inactive'],
+                        inactiveOnUpdate: choice['@_inactive_on_update'],
+                        language: choice['@_language'],
+                    }))
+                    : [
+                        {
+                            label: column.choice.element['@_label'],
+                            value: column.choice.element['@_value'] ?? '',
+                            sequence: column.choice.element['@_sequence'],
+                            dependentValue: column.choice.element['@_dependent_value'],
+                            hint: column.choice.element['@_hint'],
+                            inactive: column.choice.element['@_inactive'],
+                            inactiveOnUpdate: column.choice.element['@_inactive_on_update'],
+                            language: column.choice.element['@_language'],
+                        },
+                    ]
+                : undefined,
+            isActive: column['@_active'],
+            display: column['@_display'],
+            useDependentField: column['@_use_dependent_field'],
+            useDynamicDefault: column['@_use_dynamic_default'],
+            reference: column['@_reference'],
+            isVirtual: column['@_virtual'],
+            calculation: column['@_calculation'],
+            choiceField: column['@_choice_field'],
+            functionDefinition: column['@_function_definition'],
+            referenceFloats: column['@_reference_floats'],
+            referenceKey: column['@_reference_key'],
+            dynamicCreationScript: column['@_dynamic_creation_script'],
+            dynamicCreation: column['@_dynamic_creation'],
+            plural: column['@_plural'],
+            hint: column['@_hint'],
+            help: column['@_help'],
+            widget: column['@_widget'],
+            tableReference: column['@_table_reference'],
+            elementReference: column['@_element_reference'],
+            unique: column['@_unique'],
+            spellCheck: column['@_spell_check'],
+            xmlView: column['@_xml_view'],
+            isArray: column['@_array'],
+            textIndex: column['@_text_index'],
+            isPrimary: column['@_primary'],
+            attributes: column['@_attributes'],
+            referenceCascadeRule: column['@_reference_cascade_rule'],
+            choiceValue: column['@_choice'],
+            choiceTable: column['@_choice_table'],
+            dependent: column['@_dependent'],
+        });
+        if (Array.isArray(table.element)) {
+            columns.push(...table.element.map(mapColumnToDefinition));
+        }
+        else {
+            columns.push(mapColumnToDefinition(table.element));
+        }
+    }
+    const indexes = [];
+    if (table.index) {
+        const mapIndexToDefinition = (index) => ({
+            name: index['@_name'],
+            unique: index['@_unique'],
+            columns: index.element
+                ? Array.isArray(index.element)
+                    ? index.element.map((element) => element['@_name'])
+                    : [index.element['@_name']]
+                : [],
+        });
+        if (Array.isArray(table.index)) {
+            indexes.push(...table.index.map(mapIndexToDefinition));
+        }
+        else {
+            indexes.push(mapIndexToDefinition(table.index));
+        }
+    }
+    return {
+        name: table['@_name'],
+        label: table['@_label'],
+        plural: table['@_plural'],
+        extends: table['@_extends'],
+        columns,
+        indexes,
+        audit: table['@_audit'],
+        readOnly: table['@_read_only'],
+        textIndex: table['@_text_index'],
+        clientScriptsAccess: table['@_client_scripts_access'],
+        wsAccess: table['@_ws_access'],
+        display: table['@_display'],
+        alterAccess: table['@_alter_access'],
+        createAccess: table['@_create_access'],
+        deleteAccess: table['@_delete_access'],
+        updateAccess: table['@_update_access'],
+        callerAccess: table['@_caller_access'],
+        actionsAccess: table['@_actions_access'],
+        readAccess: table['@_read_access'],
+        isExtendable: table['@_is_extendable'],
+        scriptableTable: table['@_scriptable_table'],
+        attributes: table['@_attributes'],
+    };
+}
+function tableDefToRecordProperties(tableDef) {
+    const sysDbObject = {
+        name: tableDef.name,
+        label: tableDef.label,
+        super_class: tableDef.extends,
+        is_extendable: tableDef.isExtendable,
+        scriptable_table: tableDef.scriptableTable,
+        client_scripts_access: tableDef.clientScriptsAccess,
+        ws_access: tableDef.wsAccess,
+        alter_access: tableDef.alterAccess,
+        create_access: tableDef.createAccess,
+        delete_access: tableDef.deleteAccess,
+        update_access: tableDef.updateAccess,
+        caller_access: tableDef.callerAccess,
+        actions_access: tableDef.actionsAccess,
+        read_access: tableDef.readAccess,
+    };
+    const sysDictionary = [];
+    const sysChoice = [];
+    const sysDocumentation = [];
+    // table documentation
+    if (tableDef.label && tableDef.plural) {
+        sysDocumentation.push({
+            name: tableDef.name,
+            element: undefined,
+            label: tableDef.label,
+            plural: tableDef.plural,
+            language: 'en',
+            hint: undefined,
+            help: undefined,
+        });
+    }
+    for (const column of tableDef.columns) {
+        sysDictionary.push({
+            name: tableDef.name,
+            element: column.name,
+            internal_type: column.type || 'string',
+            default_value: column.defaultValue,
+            max_length: column.maxLength,
+            mandatory: column.isMandatory,
+            read_only: column.isReadOnly,
+            reference_table: column.referenceTable,
+            reference_qual: column.referenceQual,
+            column_label: column.columnLabel,
+            active: column.isActive,
+            display: tableDef.display === column.name || column.display,
+            use_dependent_field: column.useDependentField,
+            use_dynamic_default: column.useDynamicDefault,
+            reference: column.reference,
+            virtual: column.isVirtual,
+            default: column.defaultValue,
+            calculation: column.calculation,
+            choice_field: column.choiceField,
+            function_definition: column.functionDefinition,
+            reference_floats: column.referenceFloats,
+            reference_key: column.referenceKey,
+            dynamic_creation_script: column.dynamicCreationScript,
+            dynamic_creation: column.dynamicCreation,
+            plural: column.plural,
+            hint: column.hint,
+            help: column.help,
+            widget: column.widget,
+            table_reference: column.tableReference,
+            element_reference: column.elementReference,
+            unique: column.unique,
+            spell_check: column.spellCheck,
+            xml_view: column.xmlView,
+            array: column.isArray,
+            text_index: column.textIndex,
+            primary: column.isPrimary,
+            attributes: column.attributes,
+            reference_cascade_rule: column.referenceCascadeRule,
+            choice: column.choiceValue,
+            choice_table: column.choiceTable,
+            dependent: column.dependent,
+            function_field: column.functionDefinition ? true : undefined,
+            audit: column.audit,
+        });
+        if (column.choices?.length) {
+            for (const choice of column.choices) {
+                sysChoice.push({
+                    name: tableDef.name,
+                    element: column.name,
+                    label: choice.label || choice.value,
+                    value: choice.value,
+                    sequence: choice.sequence,
+                    dependent_value: choice.dependentValue,
+                    hint: choice.hint,
+                    inactive: choice.inactive,
+                    inactive_on_update: choice.inactiveOnUpdate,
+                    language: choice.language,
+                });
+            }
+        }
+        // Add column documentation
+        sysDocumentation.push({
+            name: tableDef.name,
+            element: column.name,
+            label: column.columnLabel || column.name,
+            plural: column.plural || (0, column_plugin_1.generatePlural)(column.columnLabel || column.name),
+            language: 'en',
+            hint: column.hint,
+            help: column.help,
+        });
+    }
+    // sys_dictionary collection record
+    sysDictionary.push({
+        name: tableDef.name,
+        internal_type: 'collection',
+        // table properties
+        attributes: tableDef.attributes,
+        audit: tableDef.audit,
+        text_index: tableDef.textIndex,
+        read_only: tableDef.readOnly,
+        // column properties left undefined
+        element: undefined,
+        default_value: undefined,
+        max_length: undefined,
+        mandatory: undefined,
+        reference_table: undefined,
+        reference_qual: undefined,
+        column_label: undefined,
+        active: undefined,
+        display: undefined,
+        use_dependent_field: undefined,
+        use_dynamic_default: undefined,
+        reference: undefined,
+        virtual: undefined,
+        default: undefined,
+        calculation: undefined,
+        choice_field: undefined,
+        function_definition: undefined,
+        reference_floats: undefined,
+        reference_key: undefined,
+        dynamic_creation_script: undefined,
+        dynamic_creation: undefined,
+        plural: undefined,
+        hint: undefined,
+        help: undefined,
+        widget: undefined,
+        table_reference: undefined,
+        element_reference: undefined,
+        unique: undefined,
+        spell_check: undefined,
+        xml_view: undefined,
+        array: undefined,
+        primary: undefined,
+        reference_cascade_rule: undefined,
+        choice: undefined,
+        choice_table: undefined,
+        dependent: undefined,
+        function_field: undefined,
+    });
+    const sysIndex = [];
+    for (const index of tableDef.indexes) {
+        sysIndex.push({
+            index_name: index.name,
+            col_name_string: index.columns.join(','),
+            unique_index: index.unique,
+            logical_table_name: tableDef.name,
+        });
+    }
+    return {
+        sysDbObject,
+        sysDictionary,
+        sysChoice,
+        sysIndex,
+        sysDocumentation,
+    };
+}
+function addTableToGlobalGeneratedFile(tableArg, sourceFilePath, compiler) {
+    const { interfaces, properties, imports, namedImports } = {
+        interfaces: [],
+        properties: [],
+        imports: {},
+        namedImports: [],
+    };
+    const generatedTableFile = compiler.getGeneratedTableFile();
+    const tableName = tableArg.get('name').asString().getValue();
+    if (!(tableName.trim().length > 0 && tableName.match(tableNameRegex))) {
+        return;
+    }
+    const extendsTable = tableArg.get('extends').ifString()?.getValue();
+    if (!compiler.interfaceExistsInGlobalDeclaration(tableName)) {
+        interfaces.push({
+            name: tableName,
+            extends: [`Helper<typeof ${tableName}>`],
+        });
+    }
+    if (!compiler.propertyExistsInGlobalDeclaration(tableName)) {
+        const interfaceType = extendsTable
+            ? `Table<TableSchemas.${tableName}, "${extendsTable}">`
+            : `Table<TableSchemas.${tableName}>`;
+        properties.push({
+            name: tableName,
+            type: interfaceType,
+        });
+    }
+    if (generatedTableFile) {
+        const resolvedModuleSpecifier = generatedTableFile.getRelativePathAsModuleSpecifierTo(sourceFilePath);
+        if (resolvedModuleSpecifier) {
+            const importExists = compiler.importExistsInGlobalDeclaration(resolvedModuleSpecifier);
+            if (!importExists) {
+                if (imports[sourceFilePath]) {
+                    const existingImport = imports[sourceFilePath];
+                    if (Array.isArray(existingImport.namedImports)) {
+                        ;
+                        existingImport.namedImports.push(tableName);
+                    }
+                }
+                else {
+                    imports[sourceFilePath] = {
+                        namedImports: [tableName],
+                        moduleSpecifier: resolvedModuleSpecifier,
+                    };
+                }
+            }
+            else {
+                const namedImportExists = importExists?.getNamedImports().some((value) => value.getName() === tableName);
+                if (!namedImportExists) {
+                    namedImports.push({
+                        existingImport: importExists,
+                        name: tableName,
+                    });
+                }
+            }
+        }
+    }
+    if (interfaces.length > 0 || properties.length > 0 || Object.keys(imports).length > 0 || namedImports.length > 0) {
+        compiler.addTableInterfacesToGlobalDeclaration({
+            interfaces,
+            properties,
+            imports,
+            namedImports,
+        });
+    }
+}
+function filterUndefinedProperties(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== undefined));
+}
+function filterUndefinedAttributes(attributes) {
+    return attributes.filter((pair) => pair[1] !== undefined);
+}
+function createElement(name, attributes = [], children = []) {
+    const element = (0, xmlbuilder2_1.create)().ele(name);
+    for (const [key, value] of attributes) {
+        const sanitizedValue = value.replaceAll('\n', '&#10;').replaceAll('\r', '&#13;');
+        element.att(key, sanitizedValue);
+    }
+    for (const child of children) {
+        element.import(child);
+    }
+    return element;
+}
+function generateRecordXml(records, config, getFileName) {
+    return records.map((record) => {
+        const recordBuilder = (0, sdk_build_core_1.unloadBuilder)({ scope: config.scope, scopeId: config.scopeId });
+        const builder = recordBuilder.record(record);
+        record
+            .entries()
+            .sort(([a], [b]) => a.localeCompare(b))
+            .forEach(([prop, shape]) => builder.field(prop, shape));
+        return {
+            name: getFileName(record),
+            category: record.getInstallCategory(),
+            content: recordBuilder.end(),
+        };
+    });
+}
+function isDefaultLicenseConfig(tableName, licenseRecord) {
+    const license = licenseRecord.asObject().getValue();
+    const defaultRecord = {
+        name: tableName,
+        license_model: 'none',
+        is_fulfillment: false,
+        op_delete: true,
+        op_insert: true,
+        op_update: true,
+    };
+    const optionalFields = ['owner_condition', 'license_condition', 'license_roles'];
+    optionalFields.forEach((field) => {
+        if (field in license) {
+            defaultRecord[field] = '';
+        }
+    });
+    return (0, isEqual_1.default)(defaultRecord, license);
+}
+//# sourceMappingURL=table-plugin.js.map