@servicenow/sdk-build-core 3.0.3 → 4.0.0

package/src/typescript.ts

@@ -0,0 +1,502 @@
+/**
+ * For some reason ts-morph.d.ts doesn't export these types even though they are actually
+ * exported by the runtime library, so we are declaring them here
+ *
+ * @version 23.0.0
+ */
+declare module 'ts-morph' {
+    abstract class BaseError extends Error {
+        protected constructor()
+    }
+
+    class PathNotFoundError extends BaseError {
+        readonly path: string
+        constructor(path: string, prefix?: string)
+        readonly code: 'ENOENT'
+    }
+
+    class FileNotFoundError extends Error {
+        constructor(filePath: string)
+    }
+
+    class DirectoryNotFoundError extends Error {
+        constructor(dirPath: string)
+    }
+}
+
+// biome-ignore lint/style/noRestrictedImports: This is where our re-export comes from
+import * as ts from 'ts-morph'
+// biome-ignore lint/style/noRestrictedImports: This is where our re-export comes from
+import { ts as tsc } from 'ts-morph'
+
+export { ts, tsc }
+
+export function getValueDeclaration(node: ts.Node) {
+    const symbol = node.getSymbol()
+    if (!symbol) {
+        return undefined
+    }
+
+    // Obtain the declaration for the symbol (possibly undefined)
+    const valueDeclaration = getValueDeclarationFromSymbolOrAlias(symbol)
+
+    // Guard against TypeScript erroneously resolving a property access like `data.some` to
+    // the *PropertyAccessExpression* itself. When that happens `getValueDeclaration()` is
+    // called on the identifier `some` and we get back its parent `PropertyAccessExpression`
+    // whose `.getNameNode()` is the same identifier. Returning that node causes infinite
+    // recursion (`Identifier → PropertyAccessExpression → Identifier …`) and eventually
+    // crashes. Since there's no useful way to handle that scenario, we just bail out here.
+    if (
+        valueDeclaration &&
+        (valueDeclaration === node ||
+            (ts.Node.isPropertyAccessExpression(valueDeclaration) &&
+                (valueDeclaration.getNameNode() === node || valueDeclaration.getExpression() === node)))
+    ) {
+        return undefined
+    }
+
+    if (!ts.Node.isShorthandPropertyAssignment(valueDeclaration)) {
+        return valueDeclaration
+    }
+
+    const valueSymbol = valueDeclaration.getValueSymbol()
+    if (!valueSymbol) {
+        throw `Expected value declaration for shorthand property assignment to have value symbol: ${valueDeclaration.getText()}`
+    }
+
+    return getValueDeclarationFromSymbolOrAlias(valueSymbol)
+}
+
+function getValueDeclarationFromSymbolOrAlias(symbol: ts.Symbol) {
+    return symbol.getValueDeclaration() ?? symbol.getAliasedSymbol()?.getValueDeclaration()
+}
+
+export function parseType(
+    type: ts.Type,
+    location: ts.Node,
+    unparsableTypeHandler: (unparsableType: ts.Type) => unknown = (unparsableType) => {
+        throw `Unparsable type: ${unparsableType.getText()}`
+    }
+): unknown {
+    if (type.isBooleanLiteral()) {
+        return type.getText() === 'true'
+    } else if (type.isLiteral()) {
+        return type.getLiteralValueOrThrow()
+    } else if (type.isTuple()) {
+        return type.getTupleElements().map((e) => parseType(e, location, unparsableTypeHandler))
+    } else if (type.isObject() && !type.isArray()) {
+        return type.getProperties().reduce((result, property) => {
+            result[property.getName()] = parseType(
+                property.getTypeAtLocation(location),
+                location,
+                unparsableTypeHandler
+            )
+            return result
+        }, {})
+    } else {
+        return unparsableTypeHandler(type)
+    }
+}
+
+/**
+ * A lot of the extra information here only exists because TypeScript doesn't
+ * export a union containing all the different node types, so you can't narrow
+ * a node's type by its kind. Narrowing based on kind is very useful for plugins
+ * since you can define a property using a kind name and the type of the 'node'
+ * argument can be inferred instead of every plugin needing to cast it manually.
+ * If you find yourself needing to parse any node kinds that aren't on this list,
+ * please add them here.
+ *
+ * See: https://github.com/microsoft/TypeScript/issues/13634
+ */
+export const SupportedKinds = {
+    [ts.SyntaxKind.TypeAliasDeclaration]: {
+        name: 'TypeAliasDeclaration',
+        node: {} as ts.TypeAliasDeclaration,
+    },
+    [ts.SyntaxKind.TypeReference]: {
+        name: 'TypeReference',
+        node: {} as ts.TypeReferenceNode,
+    },
+    [ts.SyntaxKind.TypeLiteral]: {
+        name: 'TypeLiteral',
+        node: {} as ts.TypeLiteralNode,
+    },
+    [ts.SyntaxKind.PropertySignature]: {
+        name: 'PropertySignature',
+        node: {} as ts.PropertySignature,
+    },
+    [ts.SyntaxKind.TupleType]: {
+        name: 'TupleType',
+        node: {} as ts.TupleTypeNode,
+    },
+    [ts.SyntaxKind.BinaryExpression]: {
+        name: 'BinaryExpression',
+        node: {} as ts.BinaryExpression,
+    },
+    [ts.SyntaxKind.FunctionExpression]: {
+        name: 'FunctionExpression',
+        node: {} as ts.FunctionExpression,
+    },
+    [ts.SyntaxKind.FunctionDeclaration]: {
+        name: 'FunctionDeclaration',
+        node: {} as ts.FunctionDeclaration,
+    },
+    [ts.SyntaxKind.ArrayLiteralExpression]: {
+        name: 'ArrayLiteralExpression',
+        node: {} as ts.ArrayLiteralExpression,
+    },
+    [ts.SyntaxKind.CallExpression]: {
+        name: 'CallExpression',
+        node: {} as ts.CallExpression,
+    },
+    [ts.SyntaxKind.StringLiteral]: {
+        name: 'StringLiteral',
+        node: {} as ts.StringLiteral,
+    },
+    [ts.SyntaxKind.NumericLiteral]: {
+        name: 'NumericLiteral',
+        node: {} as ts.NumericLiteral,
+    },
+    [ts.SyntaxKind.TrueKeyword]: {
+        name: 'TrueKeyword',
+        node: {} as ts.TrueLiteral,
+    },
+    [ts.SyntaxKind.FalseKeyword]: {
+        name: 'FalseKeyword',
+        node: {} as ts.FalseLiteral,
+    },
+    [ts.SyntaxKind.NullKeyword]: {
+        name: 'NullKeyword',
+        node: {} as ts.NullLiteral,
+    },
+    [ts.SyntaxKind.Identifier]: {
+        name: 'Identifier',
+        node: {} as ts.Identifier,
+    },
+    [ts.SyntaxKind.SourceFile]: {
+        name: 'SourceFile',
+        node: {} as ts.SourceFile,
+    },
+    [ts.SyntaxKind.VariableDeclaration]: {
+        name: 'VariableDeclaration',
+        node: {} as ts.VariableDeclaration,
+    },
+    [ts.SyntaxKind.ClassDeclaration]: {
+        name: 'ClassDeclaration',
+        node: {} as ts.ClassDeclaration,
+    },
+    [ts.SyntaxKind.ExportDeclaration]: {
+        name: 'ExportDeclaration',
+        node: {} as ts.ExportDeclaration,
+    },
+    [ts.SyntaxKind.ObjectLiteralExpression]: {
+        name: 'ObjectLiteralExpression',
+        node: {} as ts.ObjectLiteralExpression,
+    },
+    [ts.SyntaxKind.AsExpression]: {
+        name: 'AsExpression',
+        node: {} as ts.AsExpression,
+    },
+    [ts.SyntaxKind.ComputedPropertyName]: {
+        name: 'ComputedPropertyName',
+        node: {} as ts.ComputedPropertyName,
+    },
+    [ts.SyntaxKind.PropertyAssignment]: {
+        name: 'PropertyAssignment',
+        node: {} as ts.PropertyAssignment,
+    },
+    [ts.SyntaxKind.PropertyAccessExpression]: {
+        name: 'PropertyAccessExpression',
+        node: {} as ts.PropertyAccessExpression,
+    },
+    [ts.SyntaxKind.NoSubstitutionTemplateLiteral]: {
+        name: 'NoSubstitutionTemplateLiteral',
+        node: {} as ts.NoSubstitutionTemplateLiteral,
+    },
+    [ts.SyntaxKind.ExpressionStatement]: {
+        name: 'ExpressionStatement',
+        node: {} as ts.ExpressionStatement,
+    },
+    [ts.SyntaxKind.TaggedTemplateExpression]: {
+        name: 'TaggedTemplateExpression',
+        node: {} as ts.TaggedTemplateExpression,
+    },
+    [ts.SyntaxKind.ExportAssignment]: {
+        name: 'ExportAssignment',
+        node: {} as ts.ExportAssignment,
+    },
+    [ts.SyntaxKind.NamedExports]: {
+        name: 'NamedExports',
+        node: {} as ts.NamedExports,
+    },
+    [ts.SyntaxKind.ExportSpecifier]: {
+        name: 'ExportSpecifier',
+        node: {} as ts.ExportSpecifier,
+    },
+    [ts.SyntaxKind.ElementAccessExpression]: {
+        name: 'ElementAccessExpression',
+        node: {} as ts.ElementAccessExpression,
+    },
+    [ts.SyntaxKind.TemplateExpression]: {
+        name: 'TemplateExpression',
+        node: {} as ts.TemplateExpression,
+    },
+    [ts.SyntaxKind.ImportClause]: {
+        name: 'ImportClause',
+        node: {} as ts.ImportClause,
+    },
+    [ts.SyntaxKind.ImportSpecifier]: {
+        name: 'ImportSpecifier',
+        node: {} as ts.ImportSpecifier,
+    },
+    [ts.SyntaxKind.ImportDeclaration]: {
+        name: 'ImportDeclaration',
+        node: {} as ts.ImportDeclaration,
+    },
+    [ts.SyntaxKind.NamedImports]: {
+        name: 'NamedImports',
+        node: {} as ts.NamedImports,
+    },
+    [ts.SyntaxKind.VariableStatement]: {
+        name: 'VariableStatement',
+        node: {} as ts.VariableStatement,
+    },
+    [ts.SyntaxKind.VariableDeclarationList]: {
+        name: 'VariableDeclarationList',
+        node: {} as ts.VariableDeclarationList,
+    },
+    [ts.SyntaxKind.PlusToken]: {
+        name: 'PlusToken',
+        node: {} as ts.Node<tsc.PlusToken>,
+    },
+    [ts.SyntaxKind.EndOfFileToken]: {
+        name: 'EndOfFileToken',
+        node: {} as ts.Node<tsc.EndOfFileToken>,
+    },
+    [ts.SyntaxKind.ExportKeyword]: {
+        name: 'ExportKeyword',
+        node: {} as ts.Node<tsc.ExportKeyword>,
+    },
+    [ts.SyntaxKind.AnyKeyword]: {
+        name: 'AnyKeyword',
+        node: {} as ts.Node<tsc.KeywordTypeNode<tsc.SyntaxKind.AnyKeyword>>,
+    },
+    [ts.SyntaxKind.ModuleDeclaration]: {
+        name: 'ModuleDeclaration',
+        node: {} as ts.ModuleDeclaration,
+    },
+    [ts.SyntaxKind.ModuleBlock]: {
+        name: 'ModuleBlock',
+        node: {} as ts.ModuleBlock,
+    },
+    [ts.SyntaxKind.Block]: {
+        name: 'Block',
+        node: {} as ts.Block,
+    },
+    [ts.SyntaxKind.Parameter]: {
+        name: 'Parameter',
+        node: {} as ts.ParameterDeclaration,
+    },
+    [ts.SyntaxKind.EqualsToken]: {
+        name: 'EqualsToken',
+        node: {} as ts.Node<tsc.EqualsToken>,
+    },
+    [ts.SyntaxKind.EqualsGreaterThanToken]: {
+        name: 'EqualsGreaterThanToken',
+        node: {} as ts.Node<tsc.EqualsGreaterThanToken>,
+    },
+    [ts.SyntaxKind.ArrowFunction]: {
+        name: 'ArrowFunction',
+        node: {} as ts.ArrowFunction,
+    },
+    [ts.SyntaxKind.TemplateHead]: {
+        name: 'TemplateHead',
+        node: {} as ts.TemplateHead,
+    },
+    [ts.SyntaxKind.TemplateMiddle]: {
+        name: 'TemplateMiddle',
+        node: {} as ts.TemplateMiddle,
+    },
+    [ts.SyntaxKind.TemplateSpan]: {
+        name: 'TemplateSpan',
+        node: {} as ts.TemplateSpan,
+    },
+    [ts.SyntaxKind.TemplateTail]: {
+        name: 'TemplateTail',
+        node: {} as ts.TemplateTail,
+    },
+    [ts.SyntaxKind.PrefixUnaryExpression]: {
+        name: 'PrefixUnaryExpression',
+        node: {} as ts.PrefixUnaryExpression,
+    },
+} satisfies {
+    [K in ts.SyntaxKind]?: {
+        name: keyof typeof ts.SyntaxKind
+        node: ts.Node<tsc.Node & { kind: K }>
+    }
+}
+
+export type SupportedKind = keyof typeof SupportedKinds
+export type SupportedKindName = (typeof SupportedKinds)[SupportedKind]['name']
+export type SupportedNode = (typeof SupportedKinds)[SupportedKind]['node']
+export type SupportedNodeByKind<K extends SupportedKind> = (typeof SupportedKinds)[K]['node']
+export type SupportedNodeByKindName<K extends SupportedKindName> = Extract<
+    (typeof SupportedKinds)[SupportedKind],
+    { name: K }
+>['node']
+
+export function isSupportedKind(kind: ts.SyntaxKind): kind is SupportedKind {
+    return kind in SupportedKinds
+}
+
+export function isSupportedNode(node: ts.Node | undefined): node is SupportedNode {
+    return !!node && isSupportedKind(node.getKind())
+}
+
+export function getKind(node: SupportedNode): SupportedKind {
+    return node.getKind() as SupportedKind
+}
+
+export function getKindName(nodeOrKind: SupportedNode | SupportedKind): SupportedKindName {
+    const kind: SupportedKind = typeof nodeOrKind === 'object' ? getKind(nodeOrKind) : nodeOrKind
+    return SupportedKinds[kind].name
+}
+
+export function isUndefined(node: ts.Node): boolean {
+    return (
+        ts.Node.isUndefinedKeyword(node) ||
+        ts.Node.isNullLiteral(node) ||
+        (ts.Node.isIdentifier(node) && (node.getText() === 'undefined' || node.getText() === 'null'))
+    )
+}
+
+export function isOnlyChild(node: ts.Node | undefined): boolean {
+    if (!node) {
+        return false
+    }
+
+    const parent = node.getParent()
+    if (!parent) {
+        return true
+    }
+
+    if (ts.Node.isInitializerExpressionGetable(parent) && parent.getInitializer() === node) {
+        return true
+    }
+
+    if (ts.Node.hasExpression(parent) && parent.getExpression() === node) {
+        return true
+    }
+
+    if (ts.Node.isImportDeclaration(parent) && parent.getImportClause() === node) {
+        return true
+    }
+
+    if (ts.Node.isExportSpecifier(parent) && parent.getNameNode() === node) {
+        return true
+    }
+
+    const syntaxList = node.getParentSyntaxList()
+    if (syntaxList && syntaxList.getChildCount() === 1 && syntaxList.getChildAtIndex(0) === node) {
+        return true
+    }
+
+    return parent.getChildCount() === 1 && parent.getChildAtIndex(0) === node
+}
+
+type RemovableNode = Extract<SupportedNode, { remove(): void }>
+
+export function isRemovable(node: ts.Node | undefined): node is RemovableNode {
+    return isSupportedNode(node) && 'remove' in node
+}
+
+function buildUnaryChain(node: ts.Node, chain: ts.Node[] = []) {
+    chain.push(node)
+    return isOnlyChild(node) ? buildUnaryChain(node.getParentOrThrow(), chain) : chain
+}
+
+/**
+ * Recursively walks up the tree to remove the furthest possible ancestor along a
+ * unary chain from this node, or the node itself if that's all we can do. This
+ * avoids leaving behind dead code as much as possible.
+ *
+ * @throws Error if the node cannot be removed
+ */
+export function remove(target: ts.Node): void {
+    if (target.wasForgotten()) {
+        return
+    }
+
+    const chain = buildUnaryChain(target, [])
+    for (const node of chain) {
+        const parent = node.getParent()
+
+        // We can remove this node via the parent if it's an element in an array
+        if (ts.Node.isArrayLiteralExpression(parent)) {
+            for (const [i, e] of parent.getElements().entries()) {
+                if (e === node) {
+                    parent.removeElement(i)
+                    return
+                }
+            }
+        }
+
+        // We need to avoid leaving imports without any specifiers (side effect imports)
+        if (ts.Node.isImportSpecifier(node) && isOnlyChild(node)) {
+            node.getImportDeclaration().remove()
+            return
+        }
+
+        if (isRemovable(node)) {
+            node.remove()
+            return
+        }
+    }
+
+    throw new Error(`Unable to remove "${getUnsupportedKindName(target)}" node: ${target.getText()}`)
+}
+
+/**
+ * Recursively walks up the tree removing references to this node and any ancestors
+ * along a unary chain. In other words, if this node is the only child of its parent,
+ * we also remove references to the parent, and repeat that process recursively. This
+ * avoids leaving behind dead code as much as possible.
+ */
+export function removeReferences(target: ts.Node): void {
+    const chain = buildUnaryChain(target, [])
+    for (const node of chain) {
+        if (ts.Node.isReferenceFindable(node)) {
+            node.findReferencesAsNodes().forEach(remove)
+        }
+    }
+}
+
+/**
+ * This is a hack to get more accurate names for given syntax kinds. TypeScript's
+ * `SyntaxKind` enum has a lot of reused numeric values, so when you try to index
+ * it with a number, you might get a different name than you expect. For example,
+ * `VariableStatement` and `FirstStatement` both have the same numeric value, and
+ * you probably never would expect the latter. Thankfully, all the names that you
+ * probably never want are towards the end, so this just grabs all the first ones
+ * and ignores any duplicates that come after.
+ */
+let unsupportedKindNames: globalThis.Record<ts.SyntaxKind, string> | undefined
+export function getUnsupportedKindName(node: ts.Node): string | undefined {
+    if (!unsupportedKindNames) {
+        unsupportedKindNames = Object.entries(ts.SyntaxKind)
+            .filter(([k]) => Number.isNaN(Number(k)))
+            .reduce(
+                (names, [name, value]) => {
+                    if (typeof value === 'number' && !names[value]) {
+                        names[value] = name // Only add if it hasn't been added already
+                    }
+
+                    return names
+                },
+                {} as globalThis.Record<ts.SyntaxKind, string>
+            )
+    }
+
+    return unsupportedKindNames[node.getKind()]
+}

package/src/util/get-file-type.ts

@@ -0,0 +1,11 @@
+import type { FileType } from '../plugins'
+
+export function getFileType(filePath: string): FileType {
+    return filePath.endsWith('.now.ts')
+        ? 'fluent'
+        : filePath.endsWith('.ts') || filePath.endsWith('.js')
+          ? 'module'
+          : filePath.endsWith('.json') || filePath.endsWith('.jsonc')
+            ? 'json'
+            : 'unknown'
+}

package/src/util/index.ts

@@ -1,6 +1,2 @@
-export * from './Debug'
-export * from './Util'
-export * from './XMLUploadParser'
-export * from './Scope'
-export * from './Directive'
-export * from './RuntimeTableSchema'
+export * from './is-sn-scope'
+export * from './get-file-type'

package/src/xml.ts

@@ -0,0 +1,86 @@
+import { type Action, Record, RecordId, ResolvableShape, Shape, StringShape } from './plugins'
+import { create } from 'xmlbuilder2'
+import type { XMLBuilder } from 'xmlbuilder2/lib/interfaces'
+
+export function unloadBuilder({ scope, scopeId }: { scope: string; scopeId: string }) {
+    const xml = create({ version: '1.0' }).ele('record_update')
+    const end = () => xml.end({ prettyPrint: true })
+
+    // Root Builder
+    return {
+        xml,
+        end,
+        record: (record: Record) => {
+            const rec = recordXml(xml, record.getTable(), record.getId().getValue(), {
+                attr: { action: record.getAction() },
+            })
+            rec.field('sys_scope', scopeId, { display_value: scope })
+            // TODO: Add sys_update_name here too
+            return rec
+        },
+        createXML: (tableName: string, id: string | number, action: Action = 'INSERT_OR_UPDATE') => {
+            const rec = recordXml(xml, tableName, id, { attr: { action } })
+            rec.addSysScope(scope, scopeId)
+            return rec
+        },
+    }
+}
+
+export function recordXml(
+    xml: XMLBuilder,
+    tableName: string,
+    id: string | number,
+    options: {
+        attr?: globalThis.Record<string, string>
+        excludeScopeElement?: boolean
+    } = {}
+) {
+    const recordXml = xml.ele(tableName, options.attr || { action: 'INSERT_OR_UPDATE' })
+    recordXml.ele('sys_id', undefined).txt(`${id}`)
+
+    // Record Builder
+    return {
+        field(columnName: string, value: unknown, attributes: globalThis.Record<string, string> = {}) {
+            if (value instanceof ResolvableShape) {
+                value = value.resolve()
+            }
+
+            if (value instanceof Record) {
+                value = value.getId()
+            }
+
+            if (value instanceof RecordId) {
+                attributes = { ...attributes, ...serializeKeys(value) }
+            }
+
+            const { stringValue, contentType } =
+                value instanceof Shape
+                    ? value.toString().pipe((s) => ({ stringValue: s.getValue(), contentType: s.getContentType() }))
+                    : { stringValue: `${value ?? ''}`, contentType: 'plain' }
+
+            /*
+                &nbsp is not a predefined entity for XML, to overcome that the platform uses &amp;nbsp; in XMLs.
+                When we transform XML that contains &amp;nbsp; that translates to `&nbsp;`.
+                But when fluent generates the XML from source it creates XML with &nbsp; which makes the XML invalid since `nbsp` is not defined.
+
+                So we are replacing &nbsp; with &amp;nbsp; to ensure the XML is valid.
+            */
+            const sanitizedValue = stringValue.replaceAll('&nbsp;', '&amp;nbsp;')
+
+            const element = recordXml.ele(columnName, attributes)
+            return contentType === 'plain'
+                ? element.txt(sanitizedValue)
+                : element.dat(StringShape.escapeCdataTags(sanitizedValue))
+        },
+        addSysScope(scope: string, scopeId: string) {
+            return recordXml.ele('sys_scope', { display_value: scope }).txt(scopeId)
+        },
+    }
+}
+
+function serializeKeys(id: RecordId): globalThis.Record<string, string> | undefined {
+    const keys = id.getKeys()
+    return keys
+        ? Object.fromEntries(Object.entries(keys).map(([k, v]) => [k, v instanceof RecordId ? v.getValue() : v]))
+        : undefined
+}

package/dist/GUID.d.ts

@@ -1,2 +0,0 @@
-export declare function GUID(): string;
-export declare function isGUID(guid: string | number): guid is string;

package/dist/GUID.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GUID.js","sourceRoot":"","sources":["../src/GUID.ts"],"names":[],"mappings":";;AAEA,oBAEC;AAKD,wBAMC;AAfD,yDAAgD;AAEhD,SAAgB,IAAI;IAChB,OAAO,oBAAM,CAAC,UAAU,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;AAClD,CAAC;AAED,kDAAkD;AAClD,MAAM,SAAS,GAAG,iBAAiB,CAAA;AAEnC,SAAgB,MAAM,CAAC,IAAqB;IACxC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAA;IAChB,CAAC;IAED,OAAO,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAC/B,CAAC"}

package/dist/IncludePaths.d.ts

@@ -1,25 +0,0 @@
-import { Context } from './plugins';
-export type IncludePaths = {
-    [table: string]: {
-        fields: {
-            [field: string]: string;
-        }[];
-    };
-};
-type CustomizedFieldPaths = {
-    field: string;
-    path: string;
-};
-export type CustomizedIncludePathForTable = {
-    table: string;
-    guid: string;
-    fields: CustomizedFieldPaths[];
-};
-export type CustomizedIncludePaths = {
-    [table: string]: CustomizedIncludePathForTable[];
-};
-export declare const DefaultIncludePaths: IncludePaths;
-export declare const getIncludePaths: (context: Context) => IncludePaths;
-export declare const calculateCustomPathsFromDocs: (context: Context) => CustomizedIncludePaths;
-export declare function replaceTemplate(template: string, properties: Record<string, any>): string;
-export {};