@connorbritain/mssql-mcp-core 0.1.0

package/dist/tools/ListScriptsTool.js

@@ -0,0 +1,86 @@
+import { getScriptManager } from "../config/ScriptManager.js";
+export class ListScriptsTool {
+    constructor() {
+        this.name = "list_scripts";
+        this.description = "Lists available named SQL scripts. Scripts are pre-approved SQL templates that can be executed with parameters.";
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                environment: {
+                    type: "string",
+                    description: "Filter scripts to those allowed in this environment (optional)",
+                },
+                tier: {
+                    type: "string",
+                    enum: ["reader", "writer", "admin"],
+                    description: "Filter scripts by minimum tier requirement (optional)",
+                },
+            },
+            required: [],
+        };
+    }
+    async run(params) {
+        const scriptManager = getScriptManager();
+        if (!scriptManager.isConfigured()) {
+            return {
+                success: false,
+                message: "Named scripts are not configured. Set scriptsPath in environments.json or SCRIPTS_PATH env var.",
+                scriptsPath: null,
+                scripts: [],
+            };
+        }
+        const allScripts = scriptManager.listScripts();
+        if (allScripts.length === 0) {
+            return {
+                success: true,
+                message: "No scripts found in scripts directory.",
+                scriptsPath: scriptManager.getScriptsPath(),
+                scripts: [],
+            };
+        }
+        // Filter by environment if specified
+        let filteredScripts = allScripts;
+        if (params?.environment) {
+            filteredScripts = filteredScripts.filter((script) => {
+                const check = scriptManager.canRunInEnvironment(script.name, params.environment);
+                return check.allowed;
+            });
+        }
+        // Filter by tier if specified
+        if (params?.tier) {
+            const tierOrder = ["reader", "writer", "admin"];
+            const requestedTierIndex = tierOrder.indexOf(params.tier);
+            filteredScripts = filteredScripts.filter((script) => {
+                if (!script.tier)
+                    return true; // No tier restriction
+                const scriptTierIndex = tierOrder.indexOf(script.tier);
+                return scriptTierIndex <= requestedTierIndex;
+            });
+        }
+        // Map to output format (exclude SQL content for listing)
+        const scriptsOutput = filteredScripts.map((script) => ({
+            name: script.name,
+            description: script.description,
+            parameters: script.parameters?.map((p) => ({
+                name: p.name,
+                type: p.type,
+                required: p.required ?? false,
+                default: p.default,
+                description: p.description,
+            })),
+            tier: script.tier,
+            requiresApproval: script.requiresApproval,
+            readonly: script.readonly,
+            allowedEnvironments: script.allowedEnvironments,
+            deniedEnvironments: script.deniedEnvironments,
+        }));
+        return {
+            success: true,
+            scriptsPath: scriptManager.getScriptsPath(),
+            totalScripts: allScripts.length,
+            filteredCount: scriptsOutput.length,
+            scripts: scriptsOutput,
+        };
+    }
+}
+//# sourceMappingURL=ListScriptsTool.js.map

package/dist/tools/ListScriptsTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ListScriptsTool.js","sourceRoot":"","sources":["../../src/tools/ListScriptsTool.ts"],"names":[],"mappings":"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"}

package/dist/tools/ListTableTool.d.ts

@@ -0,0 +1,24 @@
+import sql from "mssql";
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare class ListTableTool implements Tool {
+    [key: string]: any;
+    name: string;
+    description: string;
+    inputSchema: any;
+    run(params: any): Promise<{
+        success: boolean;
+        message: string;
+        error: string;
+        database?: undefined;
+        tableCount?: undefined;
+        tables?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        database: any;
+        tableCount: number;
+        tables: sql.IRecordSet<any>;
+        error?: undefined;
+    }>;
+}
+//# sourceMappingURL=ListTableTool.d.ts.map

package/dist/tools/ListTableTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ListTableTool.d.ts","sourceRoot":"","sources":["../../src/tools/ListTableTool.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,OAAO,CAAC;AACxB,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAG1D,qBAAa,aAAc,YAAW,IAAI;IACxC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IACnB,IAAI,SAAiB;IACrB,WAAW,SAE+E;IAC1F,WAAW,EAiBN,GAAG,CAAC;IAEH,GAAG,CAAC,MAAM,EAAE,GAAG;;;;;;;;;;;;;;;CA4DtB"}

package/dist/tools/ListTableTool.js

@@ -0,0 +1,85 @@
+import sql from "mssql";
+import { getEnvironmentManager } from "../config/EnvironmentManager.js";
+export class ListTableTool {
+    constructor() {
+        this.name = "list_tables";
+        this.description = "Lists tables in an MSSQL Database, optionally filtered by schema. " +
+            "For server-level access environments, you can specify a database to list tables from.";
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: Target database name for server-level access environments.",
+                },
+                schemas: {
+                    type: "array",
+                    description: "Schemas to filter by (optional)",
+                    items: {
+                        type: "string",
+                    },
+                    minItems: 0,
+                },
+            },
+            required: [],
+        };
+    }
+    async run(params) {
+        try {
+            const { database, schemas, environment } = params ?? {};
+            // Validate database access if specified
+            if (database) {
+                const envManager = getEnvironmentManager();
+                const dbCheck = envManager.isDatabaseAllowed(environment, database);
+                if (!dbCheck.allowed) {
+                    return {
+                        success: false,
+                        message: dbCheck.reason || `Access to database '${database}' is not allowed.`,
+                        error: "DATABASE_ACCESS_DENIED",
+                    };
+                }
+            }
+            const request = new sql.Request(params.pool);
+            const schemaFilter = schemas && schemas.length > 0
+                ? `AND TABLE_SCHEMA IN (${schemas.map((p) => `'${p.replace(/'/g, "''")}'`).join(", ")})`
+                : "";
+            // Build query with optional database prefix
+            let query;
+            if (database) {
+                const safeDbName = database.replace(/]/g, "]]");
+                query = `
+          USE [${safeDbName}];
+          SELECT TABLE_SCHEMA + '.' + TABLE_NAME AS table_name, TABLE_SCHEMA, TABLE_NAME
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_TYPE = 'BASE TABLE' ${schemaFilter}
+          ORDER BY TABLE_SCHEMA, TABLE_NAME
+        `;
+            }
+            else {
+                query = `
+          SELECT TABLE_SCHEMA + '.' + TABLE_NAME AS table_name, TABLE_SCHEMA, TABLE_NAME
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_TYPE = 'BASE TABLE' ${schemaFilter}
+          ORDER BY TABLE_SCHEMA, TABLE_NAME
+        `;
+            }
+            const result = await request.query(query);
+            return {
+                success: true,
+                message: `Found ${result.recordset.length} table(s)${database ? ` in [${database}]` : ""}`,
+                database: database || undefined,
+                tableCount: result.recordset.length,
+                tables: result.recordset,
+            };
+        }
+        catch (error) {
+            console.error("Error listing tables:", error);
+            return {
+                success: false,
+                message: `Failed to list tables: ${error}`,
+                error: "QUERY_FAILED",
+            };
+        }
+    }
+}
+//# sourceMappingURL=ListTableTool.js.map

package/dist/tools/ListTableTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ListTableTool.js","sourceRoot":"","sources":["../../src/tools/ListTableTool.ts"],"names":[],"mappings":"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"}

package/dist/tools/ProfileTableTool.d.ts

@@ -0,0 +1,78 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+type ProfileParams = {
+    tableName: string;
+    schemaName?: string;
+    sampleSize?: number;
+    includeDistributions?: boolean;
+    topValuesLimit?: number;
+    columnsToProfile?: string[];
+    includeSamples?: boolean;
+};
+type NumericStats = {
+    min: number;
+    max: number;
+    avg: number;
+    median?: number;
+    p90?: number;
+};
+type StringStats = {
+    minLength: number;
+    maxLength: number;
+    avgLength: number;
+    emptyCount: number;
+};
+type DateStats = {
+    earliest: string;
+    latest: string;
+    range: string;
+};
+type TopValue = {
+    value: any;
+    count: number;
+    percentage: number;
+};
+type ColumnProfile = {
+    columnName: string;
+    dataType: string;
+    isNullable: boolean;
+    nullCount: number;
+    nullPercentage: number;
+    distinctCount: number;
+    cardinality: "unique" | "high" | "medium" | "low";
+    numericStats?: NumericStats;
+    stringStats?: StringStats;
+    dateStats?: DateStats;
+    topValues?: TopValue[];
+};
+type ProfileResult = {
+    success: boolean;
+    message?: string;
+    tableName?: string;
+    schemaName?: string;
+    rowCount?: number;
+    columnCount?: number;
+    sampleSize?: number;
+    columns?: ColumnProfile[];
+    samples?: Record<string, unknown>[];
+};
+export declare class ProfileTableTool implements Tool {
+    [key: string]: any;
+    name: string;
+    description: string;
+    inputSchema: any;
+    private static readonly SKIP_TYPES;
+    private static readonly NUMERIC_TYPES;
+    private static readonly STRING_TYPES;
+    private static readonly DATE_TYPES;
+    private normalizeLimit;
+    private classifyCardinality;
+    private formatDateRange;
+    private escapeIdentifier;
+    private isNumericType;
+    private isStringType;
+    private isDateType;
+    private shouldSkipType;
+    run(params: ProfileParams): Promise<ProfileResult>;
+}
+export {};
+//# sourceMappingURL=ProfileTableTool.d.ts.map

package/dist/tools/ProfileTableTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProfileTableTool.d.ts","sourceRoot":"","sources":["../../src/tools/ProfileTableTool.ts"],"names":[],"mappings":"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"}

package/dist/tools/ProfileTableTool.js

@@ -0,0 +1,373 @@
+import sql from "mssql";
+const clampEnvInt = (value, fallback, min, max) => {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = parseInt(value, 10);
+    if (Number.isNaN(parsed)) {
+        return fallback;
+    }
+    return Math.min(Math.max(parsed, min), max);
+};
+const DEFAULT_SAMPLE_SIZE = clampEnvInt(process.env.PROFILE_SAMPLE_SIZE_DEFAULT, 50, 1, 1000);
+const SAMPLE_RETURN_LIMIT = clampEnvInt(process.env.PROFILE_SAMPLE_RETURN_LIMIT, 10, 1, 100);
+export class ProfileTableTool {
+    constructor() {
+        this.name = "profile_table";
+        this.description = "Profiles a table by analyzing column statistics, data distributions, and sample records. Returns metadata, cardinality info, null counts, and representative samples for each column.";
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                tableName: {
+                    type: "string",
+                    description: "Name of table to profile (schema.table or table)",
+                },
+                schemaName: {
+                    type: "string",
+                    description: "Explicit schema (defaults to 'dbo')",
+                },
+                sampleSize: {
+                    type: "number",
+                    description: "Number of sample rows (default 100, max 1000)",
+                },
+                includeSamples: {
+                    type: "boolean",
+                    description: "Return sampled rows used for profiling (default false)",
+                },
+                includeDistributions: {
+                    type: "boolean",
+                    description: "Include top value frequencies (default true)",
+                },
+                topValuesLimit: {
+                    type: "number",
+                    description: "Max distinct values per column (default 10, max 50)",
+                },
+                columnsToProfile: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Specific columns to profile (default: all)",
+                },
+            },
+            required: ["tableName"],
+        };
+    }
+    normalizeLimit(value, defaultVal, max) {
+        if (typeof value !== "number" || Number.isNaN(value) || value <= 0) {
+            return defaultVal;
+        }
+        return Math.min(Math.floor(value), max);
+    }
+    classifyCardinality(distinctCount, rowCount) {
+        if (rowCount === 0)
+            return "low";
+        const ratio = distinctCount / rowCount;
+        if (ratio > 0.95)
+            return "unique";
+        if (ratio > 0.5)
+            return "high";
+        if (ratio > 0.1)
+            return "medium";
+        return "low";
+    }
+    formatDateRange(earliest, latest) {
+        const diffMs = latest.getTime() - earliest.getTime();
+        const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+        if (diffDays < 1)
+            return "less than 1 day";
+        if (diffDays < 30)
+            return `${diffDays} day${diffDays > 1 ? "s" : ""}`;
+        const diffMonths = Math.floor(diffDays / 30);
+        if (diffMonths < 12)
+            return `${diffMonths} month${diffMonths > 1 ? "s" : ""}`;
+        const years = Math.floor(diffMonths / 12);
+        const remainingMonths = diffMonths % 12;
+        if (remainingMonths === 0)
+            return `${years} year${years > 1 ? "s" : ""}`;
+        return `${years} year${years > 1 ? "s" : ""}, ${remainingMonths} month${remainingMonths > 1 ? "s" : ""}`;
+    }
+    escapeIdentifier(name) {
+        return `[${name.replace(/\]/g, "]]")}]`;
+    }
+    isNumericType(dataType) {
+        return ProfileTableTool.NUMERIC_TYPES.includes(dataType.toLowerCase());
+    }
+    isStringType(dataType) {
+        return ProfileTableTool.STRING_TYPES.includes(dataType.toLowerCase());
+    }
+    isDateType(dataType) {
+        return ProfileTableTool.DATE_TYPES.includes(dataType.toLowerCase());
+    }
+    shouldSkipType(dataType) {
+        return ProfileTableTool.SKIP_TYPES.includes(dataType.toLowerCase());
+    }
+    async run(params) {
+        try {
+            const pool = params.pool;
+            const tableName = params.tableName?.trim();
+            if (!tableName) {
+                return { success: false, message: "tableName is required." };
+            }
+            const schemaName = params.schemaName?.trim() || "dbo";
+            const sampleSize = this.normalizeLimit(params.sampleSize, DEFAULT_SAMPLE_SIZE, 1000);
+            const includeDistributions = params.includeDistributions !== false;
+            const includeSamples = params.includeSamples === true;
+            const topValuesLimit = this.normalizeLimit(params.topValuesLimit, 10, 50);
+            const columnsToProfile = params.columnsToProfile?.map((c) => c.trim()).filter(Boolean);
+            // 1. Validate table exists and get columns
+            const metaRequest = new sql.Request(pool);
+            metaRequest.input("schemaName", sql.NVarChar, schemaName);
+            metaRequest.input("tableName", sql.NVarChar, tableName);
+            const metaResult = await metaRequest.query(`
+        SELECT 
+          c.COLUMN_NAME AS columnName,
+          c.DATA_TYPE AS dataType,
+          CASE WHEN c.IS_NULLABLE = 'YES' THEN 1 ELSE 0 END AS isNullable
+        FROM INFORMATION_SCHEMA.COLUMNS c
+        INNER JOIN INFORMATION_SCHEMA.TABLES t
+          ON c.TABLE_SCHEMA = t.TABLE_SCHEMA AND c.TABLE_NAME = t.TABLE_NAME
+        WHERE c.TABLE_SCHEMA = @schemaName AND c.TABLE_NAME = @tableName
+        ORDER BY c.ORDINAL_POSITION
+      `);
+            if (!metaResult.recordset.length) {
+                return {
+                    success: false,
+                    message: `Table [${schemaName}].[${tableName}] not found or has no columns.`,
+                };
+            }
+            // Filter columns if requested
+            let columns = [...metaResult.recordset];
+            if (columnsToProfile && columnsToProfile.length) {
+                const requested = new Set(columnsToProfile.map((c) => c.toLowerCase()));
+                columns = columns.filter((c) => requested.has(c.columnName.toLowerCase()));
+                if (!columns.length) {
+                    return {
+                        success: false,
+                        message: `None of the requested columns exist in [${schemaName}].[${tableName}].`,
+                    };
+                }
+            }
+            // Filter out binary/blob types
+            columns = columns.filter((c) => !this.shouldSkipType(c.dataType));
+            // 2. Get total row count
+            const countRequest = new sql.Request(pool);
+            const fqTable = `${this.escapeIdentifier(schemaName)}.${this.escapeIdentifier(tableName)}`;
+            const countResult = await countRequest.query(`SELECT COUNT(*) AS cnt FROM ${fqTable}`);
+            const rowCount = countResult.recordset[0]?.cnt ?? 0;
+            let sampleRows;
+            if (rowCount === 0) {
+                return {
+                    success: true,
+                    tableName,
+                    schemaName,
+                    rowCount: 0,
+                    columnCount: columns.length,
+                    sampleSize: 0,
+                    columns: columns.map((c) => ({
+                        columnName: c.columnName,
+                        dataType: c.dataType,
+                        isNullable: Boolean(c.isNullable),
+                        nullCount: 0,
+                        nullPercentage: 0,
+                        distinctCount: 0,
+                        cardinality: "low",
+                    })),
+                };
+            }
+            if (includeSamples) {
+                const sampleRequest = new sql.Request(pool);
+                const sampleQuery = `
+          SELECT TOP (${sampleSize}) *
+          FROM ${fqTable}
+          ORDER BY NEWID()
+        `;
+                const sampleResult = await sampleRequest.query(sampleQuery);
+                sampleRows = (sampleResult.recordset ?? []).slice(0, SAMPLE_RETURN_LIMIT);
+            }
+            // 3. Profile each column
+            const columnProfiles = [];
+            for (const col of columns) {
+                const colName = this.escapeIdentifier(col.columnName);
+                const profile = {
+                    columnName: col.columnName,
+                    dataType: col.dataType,
+                    isNullable: Boolean(col.isNullable),
+                    nullCount: 0,
+                    nullPercentage: 0,
+                    distinctCount: 0,
+                    cardinality: "low",
+                };
+                // Base stats: null count and distinct count
+                const baseRequest = new sql.Request(pool);
+                const baseResult = await baseRequest.query(`
+          SELECT 
+            SUM(CASE WHEN ${colName} IS NULL THEN 1 ELSE 0 END) AS nullCount,
+            COUNT(DISTINCT ${colName}) AS distinctCount
+          FROM ${fqTable}
+        `);
+                const baseRow = baseResult.recordset[0];
+                profile.nullCount = baseRow?.nullCount ?? 0;
+                profile.nullPercentage = rowCount > 0 ? Number(((profile.nullCount / rowCount) * 100).toFixed(2)) : 0;
+                profile.distinctCount = baseRow?.distinctCount ?? 0;
+                profile.cardinality = this.classifyCardinality(profile.distinctCount, rowCount);
+                // Type-specific stats
+                if (this.isNumericType(col.dataType)) {
+                    const numRequest = new sql.Request(pool);
+                    const numResult = await numRequest.query(`
+            SELECT 
+              MIN(${colName}) AS minVal,
+              MAX(${colName}) AS maxVal,
+              AVG(CAST(${colName} AS FLOAT)) AS avgVal
+            FROM ${fqTable}
+            WHERE ${colName} IS NOT NULL
+          `);
+                    const numRow = numResult.recordset[0];
+                    if (numRow && numRow.minVal !== null) {
+                        profile.numericStats = {
+                            min: numRow.minVal,
+                            max: numRow.maxVal,
+                            avg: Number(Number(numRow.avgVal).toFixed(4)),
+                        };
+                        const percentileRequest = new sql.Request(pool);
+                        const percentileResult = await percentileRequest.query(`
+              SELECT TOP 1
+                PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY ${colName}) OVER () AS medianVal,
+                PERCENTILE_CONT(0.9) WITHIN GROUP (ORDER BY ${colName}) OVER () AS p90Val
+              FROM ${fqTable}
+              WHERE ${colName} IS NOT NULL
+            `);
+                        const percentileRow = percentileResult.recordset[0];
+                        if (percentileRow) {
+                            if (percentileRow.medianVal !== null && percentileRow.medianVal !== undefined) {
+                                profile.numericStats.median = Number(Number(percentileRow.medianVal).toFixed(4));
+                            }
+                            if (percentileRow.p90Val !== null && percentileRow.p90Val !== undefined) {
+                                profile.numericStats.p90 = Number(Number(percentileRow.p90Val).toFixed(4));
+                            }
+                        }
+                    }
+                }
+                else if (this.isStringType(col.dataType)) {
+                    const strRequest = new sql.Request(pool);
+                    const strResult = await strRequest.query(`
+            SELECT 
+              MIN(LEN(${colName})) AS minLength,
+              MAX(LEN(${colName})) AS maxLength,
+              AVG(CAST(LEN(${colName}) AS FLOAT)) AS avgLength,
+              SUM(CASE WHEN ${colName} = '' THEN 1 ELSE 0 END) AS emptyCount
+            FROM ${fqTable}
+            WHERE ${colName} IS NOT NULL
+          `);
+                    const strRow = strResult.recordset[0];
+                    if (strRow && strRow.minLength !== null) {
+                        profile.stringStats = {
+                            minLength: strRow.minLength,
+                            maxLength: strRow.maxLength,
+                            avgLength: Number(Number(strRow.avgLength).toFixed(2)),
+                            emptyCount: strRow.emptyCount ?? 0,
+                        };
+                    }
+                }
+                else if (this.isDateType(col.dataType)) {
+                    const dateRequest = new sql.Request(pool);
+                    const dateResult = await dateRequest.query(`
+            SELECT 
+              MIN(${colName}) AS earliest,
+              MAX(${colName}) AS latest
+            FROM ${fqTable}
+            WHERE ${colName} IS NOT NULL
+          `);
+                    const dateRow = dateResult.recordset[0];
+                    if (dateRow && dateRow.earliest !== null) {
+                        const earliest = new Date(dateRow.earliest);
+                        const latest = new Date(dateRow.latest);
+                        profile.dateStats = {
+                            earliest: earliest.toISOString(),
+                            latest: latest.toISOString(),
+                            range: this.formatDateRange(earliest, latest),
+                        };
+                    }
+                }
+                // Top values distribution
+                if (includeDistributions && profile.distinctCount > 0 && profile.distinctCount <= rowCount) {
+                    const topRequest = new sql.Request(pool);
+                    topRequest.input("topLimit", sql.Int, topValuesLimit);
+                    const topResult = await topRequest.query(`
+            SELECT TOP (@topLimit)
+              ${colName} AS value,
+              COUNT(*) AS cnt
+            FROM ${fqTable}
+            WHERE ${colName} IS NOT NULL
+            GROUP BY ${colName}
+            ORDER BY cnt DESC
+          `);
+                    if (topResult.recordset.length) {
+                        profile.topValues = topResult.recordset.map((r) => ({
+                            value: r.value,
+                            count: r.cnt,
+                            percentage: Number(((r.cnt / rowCount) * 100).toFixed(2)),
+                        }));
+                    }
+                }
+                columnProfiles.push(profile);
+            }
+            return {
+                success: true,
+                tableName,
+                schemaName,
+                rowCount,
+                columnCount: columnProfiles.length,
+                sampleSize: includeSamples ? sampleRows?.length ?? 0 : sampleSize,
+                columns: columnProfiles,
+                samples: includeSamples ? sampleRows : undefined,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to profile table: ${error}`,
+            };
+        }
+    }
+}
+// Binary/blob types to skip
+ProfileTableTool.SKIP_TYPES = [
+    "image",
+    "varbinary",
+    "binary",
+    "timestamp",
+    "rowversion",
+    "sql_variant",
+    "xml",
+    "geography",
+    "geometry",
+    "hierarchyid",
+];
+ProfileTableTool.NUMERIC_TYPES = [
+    "int",
+    "bigint",
+    "smallint",
+    "tinyint",
+    "decimal",
+    "numeric",
+    "float",
+    "real",
+    "money",
+    "smallmoney",
+];
+ProfileTableTool.STRING_TYPES = [
+    "char",
+    "varchar",
+    "nchar",
+    "nvarchar",
+    "text",
+    "ntext",
+];
+ProfileTableTool.DATE_TYPES = [
+    "date",
+    "datetime",
+    "datetime2",
+    "smalldatetime",
+    "datetimeoffset",
+    "time",
+];
+//# sourceMappingURL=ProfileTableTool.js.map