@autobe/compiler 0.9.2 → 0.10.1

package/src/test/programmers/AutoBeTestRandomProgrammer.ts

@@ -0,0 +1,314 @@
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
+
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+import { writeTestExpression } from "./writeTestExpression";
+
+export namespace AutoBeTestRandomProgrammer {
+  export const pickRandom = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IPickRandom,
+  ): ts.CallExpression =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "instance",
+            library: "@nestia/e2e",
+            name: "RandomGenerator",
+          }),
+        ),
+        "pick",
+      ),
+      undefined,
+      [writeTestExpression(ctx, expr.array)],
+    );
+
+  export const sampleRandom = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.ISampleRandom,
+  ): ts.CallExpression =>
+    ExpressionFactory.currying({
+      function: ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "instance",
+            library: "@nestia/e2e",
+            name: "RandomGenerator",
+          }),
+        ),
+        "sample",
+      ),
+      arguments: [
+        writeTestExpression(ctx, expr.array),
+        writeTestExpression(ctx, expr.count),
+      ],
+    });
+
+  export const booleanRandom = (
+    _ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IBooleanRandom,
+  ): ts.BinaryExpression =>
+    ts.factory.createLessThanEquals(
+      ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createIdentifier("Math"),
+          "random",
+        ),
+        undefined,
+        undefined,
+      ),
+      ts.factory.createNumericLiteral(expr.probability ?? 0.5),
+    );
+
+  export const integerRandom = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IIntegerRandom,
+  ): ts.CallExpression => {
+    const intersection: ts.TypeNode[] = [
+      ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+      createTypiaTag(ctx, "Type", [
+        ts.factory.createLiteralTypeNode(
+          ts.factory.createStringLiteral("int32"),
+        ),
+      ]),
+    ];
+    if (expr.minimum !== null && expr.minimum !== undefined)
+      intersection.push(
+        createTypiaTag(ctx, "Minimum", [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createNumericLiteral(expr.minimum),
+          ),
+        ]),
+      );
+    if (expr.maximum !== null && expr.maximum !== undefined)
+      intersection.push(
+        createTypiaTag(ctx, "Maximum", [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createNumericLiteral(expr.maximum),
+          ),
+        ]),
+      );
+    if (expr.multipleOf !== null && expr.multipleOf !== undefined)
+      intersection.push(
+        createTypiaTag(ctx, "MultipleOf", [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createNumericLiteral(expr.multipleOf),
+          ),
+        ]),
+      );
+    return createTypiaRandom(ctx, intersection);
+  };
+
+  export const numberRandom = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.INumberRandom,
+  ): ts.CallExpression => {
+    const intersection: ts.TypeNode[] = [
+      ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+    ];
+    if (expr.minimum !== null && expr.minimum !== undefined)
+      intersection.push(
+        createTypiaTag(ctx, "Minimum", [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createNumericLiteral(expr.minimum),
+          ),
+        ]),
+      );
+    if (expr.maximum !== null && expr.maximum !== undefined)
+      intersection.push(
+        createTypiaTag(ctx, "Maximum", [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createNumericLiteral(expr.maximum),
+          ),
+        ]),
+      );
+    if (expr.multipleOf !== null && expr.multipleOf !== undefined)
+      intersection.push(
+        createTypiaTag(ctx, "MultipleOf", [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createNumericLiteral(expr.multipleOf),
+          ),
+        ]),
+      );
+    return createTypiaRandom(ctx, intersection);
+  };
+
+  export const stringRandom = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IStringRandom,
+  ): ts.CallExpression => {
+    const intersection: ts.TypeNode[] = [
+      ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+    ];
+    if (expr.minLength !== null && expr.minLength !== undefined)
+      intersection.push(
+        createTypiaTag(ctx, "MinLength", [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createNumericLiteral(expr.minLength),
+          ),
+        ]),
+      );
+    if (expr.maxLength !== null && expr.maxLength !== undefined)
+      intersection.push(
+        createTypiaTag(ctx, "MaxLength", [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createNumericLiteral(expr.maxLength),
+          ),
+        ]),
+      );
+    return createTypiaRandom(ctx, intersection);
+  };
+
+  export const formatRandom = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IFormatRandom,
+  ): ts.CallExpression =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "default",
+            library: "typia",
+            name: "typia",
+          }),
+        ),
+        "random",
+      ),
+      [
+        ts.factory.createIntersectionTypeNode([
+          ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+          ts.factory.createTypeReferenceNode(
+            ts.factory.createQualifiedName(
+              ts.factory.createIdentifier(
+                ctx.importer.external({
+                  type: "instance",
+                  library: "typia",
+                  name: "tags",
+                }),
+              ),
+              ts.factory.createIdentifier("Format"),
+            ),
+            [
+              ts.factory.createLiteralTypeNode(
+                ts.factory.createStringLiteral(expr.format),
+              ),
+            ],
+          ),
+        ]),
+      ],
+      [],
+    );
+
+  export const patternRandom = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IPatternRandom,
+  ): ts.CallExpression =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "default",
+            library: "typia",
+            name: "typia",
+          }),
+        ),
+        "random",
+      ),
+      [
+        ts.factory.createIntersectionTypeNode([
+          ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+          ts.factory.createTypeReferenceNode(
+            ts.factory.createQualifiedName(
+              ts.factory.createIdentifier(
+                ctx.importer.external({
+                  type: "instance",
+                  library: "typia",
+                  name: "tags",
+                }),
+              ),
+              ts.factory.createIdentifier("Pattern"),
+            ),
+            [
+              ts.factory.createLiteralTypeNode(
+                ts.factory.createStringLiteral(expr.pattern),
+              ),
+            ],
+          ),
+        ]),
+      ],
+      [],
+    );
+
+  export const keywordRandom = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IKeywordRandom,
+  ): ts.Expression => {
+    let value: ts.Expression = ts.factory.createPropertyAccessExpression(
+      ts.factory.createIdentifier(
+        ctx.importer.external({
+          type: "instance",
+          library: "@nestia/e2e",
+          name: "RandomGenerator",
+        }),
+      ),
+      expr.keyword,
+    );
+    new Array(KEYWORD_CURRYING_COUNT[expr.keyword]).fill(0).forEach(() => {
+      value = ts.factory.createCallExpression(value, undefined, undefined);
+    });
+    return value;
+  };
+}
+
+const createTypiaTag = (
+  ctx: IAutoBeTestProgrammerContext,
+  name: string,
+  typeArguments: ts.TypeNode[],
+) =>
+  ts.factory.createTypeReferenceNode(
+    ts.factory.createQualifiedName(
+      ts.factory.createIdentifier(
+        ctx.importer.external({
+          type: "instance",
+          library: "typia",
+          name: "tags",
+        }),
+      ),
+      ts.factory.createIdentifier(name),
+    ),
+    typeArguments,
+  );
+
+const createTypiaRandom = (
+  ctx: IAutoBeTestProgrammerContext,
+  typeArguments: ts.TypeNode[] = [],
+) =>
+  ts.factory.createCallExpression(
+    ts.factory.createPropertyAccessExpression(
+      ts.factory.createIdentifier(
+        ctx.importer.external({
+          type: "default",
+          library: "typia",
+          name: "typia",
+        }),
+      ),
+      "random",
+    ),
+    typeArguments.length === 0
+      ? undefined
+      : typeArguments.length === 1
+        ? typeArguments
+        : [ts.factory.createIntersectionTypeNode(typeArguments)],
+    undefined,
+  );
+
+const KEYWORD_CURRYING_COUNT = {
+  alphabets: 1,
+  alphaNumeric: 1,
+  mobile: 1,
+  name: 1,
+  paragraph: 2,
+  content: 3,
+};

package/src/test/programmers/AutoBeTestStatementProgrammer.ts

@@ -0,0 +1,154 @@
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+
+import { FilePrinter } from "../../utils/FilePrinter";
+import { IAutoBeTestApiFunction } from "./IAutoBeTestApiFunction";
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+import { writeTestExpression } from "./writeTestExpression";
+import { writeTestStatement } from "./writeTestStatement";
+
+export namespace AutoBeTestStatementProgrammer {
+  export const block = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IBlock,
+  ): ts.Block =>
+    ts.factory.createBlock(
+      stmt.statements
+        .map((child, i) => [
+          ...writeTestStatement(ctx, child).filter((childStmt, j) =>
+            j === 0
+              ? ts.addSyntheticLeadingComment(
+                  childStmt,
+                  ts.SyntaxKind.SingleLineCommentTrivia,
+                  JSON.stringify(child),
+                  true,
+                )
+              : childStmt,
+          ),
+          ...(i !== 0 ? [FilePrinter.newLine()] : []),
+        ])
+        .flat(),
+      true,
+    );
+
+  export const expressionStatement = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IExpressionStatement,
+  ): ts.ExpressionStatement =>
+    ts.factory.createExpressionStatement(
+      writeTestExpression(ctx, stmt.expression),
+    );
+
+  // export const variableDeclaration = (
+  //   ctx: IAutoBeTestProgrammerContext,
+  //   stmt: AutoBeTest.IVariableDeclaration,
+  // ): ts.VariableStatement => {
+  //   const typeNode: ts.TypeNode = NestiaMigrateSchemaProgrammer.write({
+  //     components: ctx.document.components,
+  //     importer: ctx.importer,
+  //     schema: OpenApiV3_1Emender.convertSchema(ctx.document.components)(
+  //       stmt.schema,
+  //     ),
+  //   });
+  //   return ts.factory.createVariableStatement(
+  //     undefined,
+  //     ts.factory.createVariableDeclarationList(
+  //       [
+  //         ts.factory.createVariableDeclaration(
+  //           stmt.name,
+  //           undefined,
+  //           typeNode,
+  //           undefined,
+  //         ),
+  //       ],
+  //       stmt.mutability === "const" ? ts.NodeFlags.Constant : ts.NodeFlags.Let,
+  //     ),
+  //   );
+  // };
+
+  export const ifStatement = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IIfStatement,
+  ): ts.IfStatement =>
+    ts.factory.createIfStatement(
+      writeTestExpression(ctx, stmt.condition),
+      block(ctx, stmt.thenStatement),
+      stmt.elseStatement
+        ? stmt.elseStatement.type === "ifStatement"
+          ? ifStatement(ctx, stmt.elseStatement)
+          : block(ctx, stmt.elseStatement)
+        : undefined,
+    );
+
+  export const returnStatement = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IReturnStatement,
+  ): ts.ReturnStatement =>
+    ts.factory.createReturnStatement(writeTestExpression(ctx, stmt.expression));
+
+  export const throwStatement = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IThrowStatement,
+  ): ts.ThrowStatement =>
+    ts.factory.createThrowStatement(writeTestExpression(ctx, stmt.expression));
+
+  export const apiOperateStatement = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IApiOperateStatement,
+  ): ts.Statement[] => {
+    // find the function
+    const func: IAutoBeTestApiFunction = ctx.endpoints.get(stmt.endpoint);
+    if (!!stmt.variableName?.length && !!func.operation.responseBody)
+      ctx.importer.dto(func.operation.responseBody.typeName);
+
+    // make await function call expression
+    const initializer: ts.AwaitExpression = ts.factory.createAwaitExpression(
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(func.accessor),
+        [],
+        [
+          ts.factory.createIdentifier("connection"),
+          ...(stmt.argument ? [writeTestExpression(ctx, stmt.argument)] : []),
+        ],
+      ),
+    );
+    if (stmt.variableName === null || stmt.variableName === undefined)
+      return [ts.factory.createExpressionStatement(initializer)];
+
+    const variable: ts.VariableStatement = ts.factory.createVariableStatement(
+      undefined,
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            stmt.variableName,
+            undefined,
+            !!func.operation.responseBody
+              ? ts.factory.createTypeReferenceNode(
+                  func.operation.responseBody.typeName,
+                )
+              : ts.factory.createKeywordTypeNode(
+                  ts.SyntaxKind.UndefinedKeyword,
+                ),
+            initializer,
+          ),
+        ],
+        ts.NodeFlags.Const,
+      ),
+    );
+    const assertion = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "default",
+            library: "typia",
+            name: "typia",
+          }),
+        ),
+        "assert",
+      ),
+      undefined,
+      [ts.factory.createIdentifier(stmt.variableName)],
+    );
+    return [variable, ts.factory.createExpressionStatement(assertion)];
+  };
+}

package/src/test/programmers/IAutoBeTestApiFunction.ts

@@ -0,0 +1,6 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+export interface IAutoBeTestApiFunction {
+  operation: AutoBeOpenApi.IOperation;
+  accessor: string;
+}

package/src/test/programmers/IAutoBeTestProgrammerContext.ts

@@ -0,0 +1,11 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { NestiaMigrateImportProgrammer } from "@nestia/migrate/lib/programmers/NestiaMigrateImportProgrammer";
+import { HashMap } from "tstl";
+
+import { IAutoBeTestApiFunction } from "./IAutoBeTestApiFunction";
+
+export interface IAutoBeTestProgrammerContext {
+  importer: NestiaMigrateImportProgrammer;
+  document: AutoBeOpenApi.IDocument;
+  endpoints: HashMap<AutoBeOpenApi.IEndpoint, IAutoBeTestApiFunction>;
+}

package/src/test/programmers/writeTestExpression.ts

@@ -0,0 +1,24 @@
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+
+import { AutoBeTestAccessorProgrammer } from "./AutoBeTestAccessorProgrammer";
+import { AutoBeTestFunctionalProgrammer } from "./AutoBeTestFunctionalProgrammer";
+import { AutoBeTestLiteralProgrammer } from "./AutoBeTestLiteralProgrammer";
+import { AutoBeTestOperatorProgrammer } from "./AutoBeTestOperatorProgrammer";
+import { AutoBeTestPredicateProgrammer } from "./AutoBeTestPredicateProgrammer";
+import { AutoBeTestRandomProgrammer } from "./AutoBeTestRandomProgrammer";
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+
+export const writeTestExpression = (
+  ctx: IAutoBeTestProgrammerContext,
+  expr: AutoBeTest.IExpression,
+): ts.Expression => factory[expr.type](ctx, expr as any);
+
+const factory = {
+  ...AutoBeTestLiteralProgrammer,
+  ...AutoBeTestOperatorProgrammer,
+  ...AutoBeTestAccessorProgrammer,
+  ...AutoBeTestFunctionalProgrammer,
+  ...AutoBeTestRandomProgrammer,
+  ...AutoBeTestPredicateProgrammer,
+};

package/src/test/programmers/writeTestFunction.ts

@@ -0,0 +1,100 @@
+import { AutoBeOpenApi, IAutoBeTestWriteProps } from "@autobe/interface";
+import { AutoBeEndpointComparator } from "@autobe/utils";
+import { NestiaMigrateImportProgrammer } from "@nestia/migrate/lib/programmers/NestiaMigrateImportProgrammer";
+import { HttpMigration, IHttpMigrateApplication } from "@samchon/openapi";
+import { HashMap, Pair } from "tstl";
+import ts, { FunctionDeclaration } from "typescript";
+
+import { transformOpenApiDocument } from "../../interface/transformOpenApi";
+import { FilePrinter } from "../../utils/FilePrinter";
+import { AutoBeTestStatementProgrammer } from "./AutoBeTestStatementProgrammer";
+import { IAutoBeTestApiFunction } from "./IAutoBeTestApiFunction";
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+
+export function writeTestFunction(props: IAutoBeTestWriteProps): string {
+  const ctx: IAutoBeTestProgrammerContext = {
+    importer: new NestiaMigrateImportProgrammer(),
+    document: props.document,
+    endpoints: associate(props.document),
+  };
+  const decla: FunctionDeclaration = ts.factory.createFunctionDeclaration(
+    [
+      ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
+      ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+    ],
+    undefined,
+    props.scenario.functionName,
+    undefined,
+    [
+      ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        "connection",
+        undefined,
+        ts.factory.createTypeReferenceNode(
+          `${ctx.importer.external({
+            type: "default",
+            name: "api",
+            library: `@ORGANIZATION/PROJECT-api`,
+          })}.IConnection`,
+        ),
+      ),
+    ],
+    undefined,
+    AutoBeTestStatementProgrammer.block(ctx, {
+      type: "block",
+      statements: props.function.statements,
+    }),
+  );
+  return FilePrinter.write({
+    statements: [
+      ...ctx.importer.toStatements(
+        (key) => `@ORGANIZATION/PROJECT-api/lib/structures/${key}`,
+      ),
+      FilePrinter.newLine(),
+      FilePrinter.description(decla, props.scenario.draft),
+    ],
+  });
+}
+
+function associate(
+  document: AutoBeOpenApi.IDocument,
+): HashMap<AutoBeOpenApi.IEndpoint, IAutoBeTestApiFunction> {
+  // associate operations and functions
+  const operations: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation> =
+    new HashMap(
+      document.operations.map(
+        (o) =>
+          new Pair(
+            {
+              method: o.method,
+              path: o.path,
+            },
+            o,
+          ),
+      ),
+      AutoBeEndpointComparator.hashCode,
+      AutoBeEndpointComparator.equals,
+    );
+  const functions: HashMap<AutoBeOpenApi.IEndpoint, IAutoBeTestApiFunction> =
+    new HashMap(
+      AutoBeEndpointComparator.hashCode,
+      AutoBeEndpointComparator.equals,
+    );
+
+  // from migrate application
+  const migrate: IHttpMigrateApplication = HttpMigration.application(
+    transformOpenApiDocument(document),
+  );
+  for (const route of migrate.routes) {
+    const endpoint: AutoBeOpenApi.IEndpoint = {
+      path: route.path,
+      method: route.method as "get",
+    };
+    functions.emplace(endpoint, {
+      accessor: "api.functional." + route.accessor.join("."),
+      operation: operations.get(endpoint),
+    });
+  }
+  return functions;
+}

package/src/test/programmers/writeTestStatement.ts

@@ -0,0 +1,15 @@
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+
+import { AutoBeTestStatementProgrammer } from "./AutoBeTestStatementProgrammer";
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+
+export const writeTestStatement = (
+  ctx: IAutoBeTestProgrammerContext,
+  stmt: AutoBeTest.IStatement,
+): ts.Statement[] => {
+  const next: ts.Statement | ts.Statement[] = AutoBeTestStatementProgrammer[
+    stmt.type
+  ](ctx, stmt as any);
+  return Array.isArray(next) ? next : [next];
+};

package/src/utils/FilePrinter.ts

@@ -0,0 +1,56 @@
+import sortImport from "@trivago/prettier-plugin-sort-imports";
+import import2 from "import2";
+import { format } from "prettier";
+import ts from "typescript";
+
+export namespace FilePrinter {
+  export const description = <Node extends ts.Node>(
+    node: Node,
+    comment: string,
+  ): Node => {
+    if (comment.length === 0) return node;
+    ts.addSyntheticLeadingComment(
+      node,
+      ts.SyntaxKind.MultiLineCommentTrivia,
+      ["*", ...comment.split("\n").map((str) => ` * ${str}`), ""].join("\n"),
+      true,
+    );
+    return node;
+  };
+
+  export const newLine = () =>
+    ts.factory.createExpressionStatement(ts.factory.createIdentifier("\n"));
+
+  export const write = (props: {
+    statements: ts.Statement[];
+    top?: string;
+  }): string => {
+    const script: string = ts
+      .createPrinter({
+        newLine: ts.NewLineKind.LineFeed,
+      })
+      .printFile(
+        ts.factory.createSourceFile(
+          props.statements,
+          ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
+          ts.NodeFlags.None,
+        ),
+      );
+    return (props.top ?? "") + script;
+  };
+
+  export const beautify = async (script: string): Promise<string> => {
+    try {
+      return await format(script, {
+        parser: "typescript",
+        plugins: [sortImport, await import2("prettier-plugin-jsdoc")],
+        importOrder: ["<THIRD_PARTY_MODULES>", "^[./]"],
+        importOrderSeparation: true,
+        importOrderSortSpecifiers: true,
+        importOrderParserPlugins: ["decorators-legacy", "typescript", "jsx"],
+      });
+    } catch {
+      return script;
+    }
+  };
+}

package/lib/utils/StringUtil.d.ts

@@ -1,4 +0,0 @@
-export declare namespace StringUtil {
-    function trim(strings: TemplateStringsArray, ...values: any[]): string;
-    function singleLine(strings: TemplateStringsArray, ...values: any[]): string;
-}