oazapfts 6.0.4 → 6.0.5

package/generate.d.ts

@@ -1,8 +1,8 @@
+import { default as default_2 } from 'typescript';
 import { OpenAPIV3 } from 'openapi-types';
 import { OpenAPIV3_1 } from 'openapi-types';
-import ts from 'typescript';
 
-export declare function addComment<T extends ts.Node>(node: T, comment?: string): T;
+export declare function addComment<T extends default_2.Node>(node: T, comment?: string): T;
 
 /**
  * Main entry point that generates TypeScript code from a given API spec.
@@ -16,16 +16,16 @@ declare class ApiGenerator {
     /** Indicates if the document was converted from an older version of the OpenAPI specification. */
     isConverted?: boolean);
     discriminatingSchemas: Set<string>;
-    aliases: (ts.TypeAliasDeclaration | ts.InterfaceDeclaration)[];
-    enumAliases: ts.Statement[];
+    aliases: (default_2.TypeAliasDeclaration | default_2.InterfaceDeclaration)[];
+    enumAliases: default_2.Statement[];
     enumRefs: Record<string, {
         values: string;
-        type: ts.TypeReferenceNode;
+        type: default_2.TypeReferenceNode;
     }>;
     refs: Record<string, {
-        base: ts.TypeReferenceNode;
-        readOnly?: ts.TypeReferenceNode;
-        writeOnly?: ts.TypeReferenceNode;
+        base: default_2.TypeReferenceNode;
+        readOnly?: default_2.TypeReferenceNode;
+        writeOnly?: default_2.TypeReferenceNode;
     }>;
     refsOnlyMode: Map<string, OnlyModes>;
     typeAliases: Record<string, number>;
@@ -39,26 +39,26 @@ declare class ApiGenerator {
     /**
      * Create a type alias for the schema referenced by the given ReferenceObject
      */
-    getRefAlias(obj: OpenAPIReferenceObject, onlyMode?: OnlyMode, ignoreDiscriminator?: boolean): ts.TypeNode;
-    getUnionType(variants: (OpenAPIReferenceObject | SchemaObject)[], discriminator?: OpenAPIDiscriminatorObject, onlyMode?: OnlyMode): ts.UnionTypeNode;
+    getRefAlias(obj: OpenAPIReferenceObject, onlyMode?: OnlyMode, ignoreDiscriminator?: boolean): default_2.TypeNode;
+    getUnionType(variants: (OpenAPIReferenceObject | SchemaObject)[], discriminator?: OpenAPIDiscriminatorObject, onlyMode?: OnlyMode): default_2.UnionTypeNode;
     /**
      * Creates a type node from a given schema.
      * Delegates to getBaseTypeFromSchema internally and
      * optionally adds a union with null.
      */
-    getTypeFromSchema(schema?: SchemaObject | OpenAPIReferenceObject, name?: string, onlyMode?: OnlyMode): ts.TypeNode;
+    getTypeFromSchema(schema?: SchemaObject | OpenAPIReferenceObject, name?: string, onlyMode?: OnlyMode): default_2.TypeNode;
     /**
      * This is the very core of the OpenAPI to TS conversion - it takes a
      * schema and returns the appropriate type.
      */
-    getBaseTypeFromSchema(schema?: SchemaObject | OpenAPIReferenceObject, name?: string, onlyMode?: OnlyMode): ts.TypeNode;
+    getBaseTypeFromSchema(schema?: SchemaObject | OpenAPIReferenceObject, name?: string, onlyMode?: OnlyMode): default_2.TypeNode;
     isTrueEnum(schema: SchemaObject, name?: string): name is string;
     /**
      * Creates literal type (or union) from an array of values
      */
-    getTypeFromEnum(values: unknown[]): ts.LiteralTypeNode | ts.UnionTypeNode;
+    getTypeFromEnum(values: unknown[]): default_2.LiteralTypeNode | default_2.UnionTypeNode;
     getEnumValuesString(values: string[]): string;
-    getTrueEnum(schema: SchemaObject, propName: string): ts.TypeReferenceNode;
+    getTrueEnum(schema: SchemaObject, propName: string): default_2.TypeReferenceNode;
     /**
      * Checks if readOnly/writeOnly properties are present in the given schema.
      * Returns a tuple of booleans; the first one is about readOnly, the second
@@ -70,13 +70,13 @@ declare class ApiGenerator {
      */
     getTypeFromProperties(props: {
         [prop: string]: SchemaObject | OpenAPIReferenceObject;
-    }, required?: string[], additionalProperties?: boolean | OpenAPISchemaObject | OpenAPIReferenceObject, onlyMode?: OnlyMode): ts.TypeLiteralNode;
-    getTypeFromResponses(responses: OpenAPIResponsesObject, onlyMode?: OnlyMode): ts.UnionTypeNode;
-    getTypeFromResponse(resOrRef: OpenAPIResponseObject | OpenAPIReferenceObject, onlyMode?: OnlyMode): ts.TypeNode;
+    }, required?: string[], additionalProperties?: boolean | OpenAPISchemaObject | OpenAPIReferenceObject, onlyMode?: OnlyMode): default_2.TypeLiteralNode;
+    getTypeFromResponses(responses: OpenAPIResponsesObject, onlyMode?: OnlyMode): default_2.UnionTypeNode;
+    getTypeFromResponse(resOrRef: OpenAPIResponseObject | OpenAPIReferenceObject, onlyMode?: OnlyMode): default_2.TypeNode;
     getResponseType(responses?: OpenAPIResponsesObject): "json" | "text" | "blob";
     getSchemaFromContent(content: Record<string, OpenAPIMediaTypeObject>): OpenAPISchemaObject | OpenAPIReferenceObject;
-    getTypeFromParameter(p: OpenAPIParameterObject): ts.TypeNode;
-    wrapResult(ex: ts.Expression): ts.Expression;
+    getTypeFromParameter(p: OpenAPIParameterObject): default_2.TypeNode;
+    wrapResult(ex: default_2.Expression): default_2.Expression;
     /**
      * Does three things:
      * 1. Add a `x-component-ref-path` property.
@@ -88,152 +88,152 @@ declare class ApiGenerator {
     preprocessComponents(schemas: {
         [key: string]: OpenAPIReferenceObject | SchemaObject;
     }): void;
-    generateApi(): ts.SourceFile;
+    generateApi(): default_2.SourceFile;
 }
 export default ApiGenerator;
 
-export declare function appendNodes<T extends ts.Node>(array: ts.NodeArray<T>, ...nodes: T[]): ts.NodeArray<T>;
+export declare function appendNodes<T extends default_2.Node>(array: default_2.NodeArray<T>, ...nodes: T[]): default_2.NodeArray<T>;
 
-export declare function block(...statements: ts.Statement[]): ts.Block;
+export declare function block(...statements: default_2.Statement[]): default_2.Block;
 
 /**
  * Create a call expression for one of the oazapfts runtime functions.
  */
-export declare function callOazapftsFunction(name: string, args: ts.Expression[], typeArgs?: ts.TypeNode[]): ts.CallExpression;
+export declare function callOazapftsFunction(name: string, args: default_2.Expression[], typeArgs?: default_2.TypeNode[]): default_2.CallExpression;
 
 /**
  * Create a call expression for one of the QS runtime functions.
  */
-export declare function callQsFunction(name: string, args: ts.Expression[]): ts.CallExpression;
+export declare function callQsFunction(name: string, args: default_2.Expression[]): default_2.CallExpression;
 
-export declare function changePropertyValue(o: ts.ObjectLiteralExpression, property: string, value: ts.Expression): void;
+export declare function changePropertyValue(o: default_2.ObjectLiteralExpression, property: string, value: default_2.Expression): void;
 
 declare type ContentType = "json" | "form" | "multipart";
 
-export declare function createArrowFunction(parameters: ts.ParameterDeclaration[], body: ts.ConciseBody, { modifiers, typeParameters, type, equalsGreaterThanToken, }?: {
-    modifiers?: ts.Modifier[];
-    typeParameters?: ts.TypeParameterDeclaration[];
-    type?: ts.TypeNode;
-    equalsGreaterThanToken?: ts.EqualsGreaterThanToken;
-}): ts.ArrowFunction;
+export declare function createArrowFunction(parameters: default_2.ParameterDeclaration[], body: default_2.ConciseBody, { modifiers, typeParameters, type, equalsGreaterThanToken, }?: {
+    modifiers?: default_2.Modifier[];
+    typeParameters?: default_2.TypeParameterDeclaration[];
+    type?: default_2.TypeNode;
+    equalsGreaterThanToken?: default_2.EqualsGreaterThanToken;
+}): default_2.ArrowFunction;
 
-export declare function createCall(expression: ts.Expression | string, { typeArgs, args, }?: {
-    typeArgs?: Array<ts.TypeNode>;
-    args?: Array<ts.Expression>;
-}): ts.CallExpression;
+export declare function createCall(expression: default_2.Expression | string, { typeArgs, args, }?: {
+    typeArgs?: Array<default_2.TypeNode>;
+    args?: Array<default_2.Expression>;
+}): default_2.CallExpression;
 
 export declare function createClassDeclaration({ modifiers, name, typeParameters, heritageClauses, members, }: {
-    modifiers?: Array<ts.Modifier>;
-    name?: string | ts.Identifier;
-    typeParameters?: Array<ts.TypeParameterDeclaration>;
-    heritageClauses?: Array<ts.HeritageClause>;
-    members: Array<ts.ClassElement>;
-}): ts.ClassDeclaration;
+    modifiers?: Array<default_2.Modifier>;
+    name?: string | default_2.Identifier;
+    typeParameters?: Array<default_2.TypeParameterDeclaration>;
+    heritageClauses?: Array<default_2.HeritageClause>;
+    members: Array<default_2.ClassElement>;
+}): default_2.ClassDeclaration;
 
 export declare function createConstructor({ modifiers, parameters, body, }: {
-    modifiers?: Array<ts.Modifier>;
-    parameters: Array<ts.ParameterDeclaration>;
-    body?: ts.Block;
-}): ts.ConstructorDeclaration;
+    modifiers?: Array<default_2.Modifier>;
+    parameters: Array<default_2.ParameterDeclaration>;
+    body?: default_2.Block;
+}): default_2.ConstructorDeclaration;
 
-export declare function createEnumTypeNode(values: Array<string | boolean | number>): ts.LiteralTypeNode | ts.UnionTypeNode;
+export declare function createEnumTypeNode(values: Array<string | boolean | number>): default_2.LiteralTypeNode | default_2.UnionTypeNode;
 
-export declare function createFunctionDeclaration(name: string | ts.Identifier | undefined, { modifiers, asteriskToken, typeParameters, type, }: {
-    modifiers?: ts.Modifier[];
-    asteriskToken?: ts.AsteriskToken;
-    typeParameters?: ts.TypeParameterDeclaration[];
-    type?: ts.TypeNode;
-}, parameters: ts.ParameterDeclaration[], body?: ts.Block): ts.FunctionDeclaration;
+export declare function createFunctionDeclaration(name: string | default_2.Identifier | undefined, { modifiers, asteriskToken, typeParameters, type, }: {
+    modifiers?: default_2.Modifier[];
+    asteriskToken?: default_2.AsteriskToken;
+    typeParameters?: default_2.TypeParameterDeclaration[];
+    type?: default_2.TypeNode;
+}, parameters: default_2.ParameterDeclaration[], body?: default_2.Block): default_2.FunctionDeclaration;
 
-export declare function createIndexSignature(type: ts.TypeNode, { modifiers, indexName, indexType, }?: {
+export declare function createIndexSignature(type: default_2.TypeNode, { modifiers, indexName, indexType, }?: {
     indexName?: string;
-    indexType?: ts.TypeNode;
-    modifiers?: Array<ts.Modifier>;
-}): ts.IndexSignatureDeclaration;
+    indexType?: default_2.TypeNode;
+    modifiers?: Array<default_2.Modifier>;
+}): default_2.IndexSignatureDeclaration;
 
 export declare function createInterfaceAliasDeclaration({ modifiers, name, typeParameters, type, inheritedNodeNames, }: {
-    modifiers?: Array<ts.Modifier>;
-    name: string | ts.Identifier;
-    typeParameters?: Array<ts.TypeParameterDeclaration>;
-    type: ts.TypeNode;
-    inheritedNodeNames?: (string | ts.Identifier)[];
-}): ts.InterfaceDeclaration;
+    modifiers?: Array<default_2.Modifier>;
+    name: string | default_2.Identifier;
+    typeParameters?: Array<default_2.TypeParameterDeclaration>;
+    type: default_2.TypeNode;
+    inheritedNodeNames?: (string | default_2.Identifier)[];
+}): default_2.InterfaceDeclaration;
 
-export declare function createKeywordType(type: KeywordTypeName): ts.KeywordTypeNode<ts.SyntaxKind.AnyKeyword> | ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword> | ts.KeywordTypeNode<ts.SyntaxKind.ObjectKeyword> | ts.KeywordTypeNode<ts.SyntaxKind.StringKeyword> | ts.KeywordTypeNode<ts.SyntaxKind.BooleanKeyword> | ts.KeywordTypeNode<ts.SyntaxKind.UndefinedKeyword> | ts.KeywordTypeNode<ts.SyntaxKind.VoidKeyword> | ts.LiteralTypeNode;
+export declare function createKeywordType(type: KeywordTypeName): default_2.KeywordTypeNode<default_2.SyntaxKind.AnyKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.NumberKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.ObjectKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.StringKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.BooleanKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.UndefinedKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.VoidKeyword> | default_2.LiteralTypeNode;
 
-export declare function createLiteral(v: string | boolean | number): ts.StringLiteral | ts.TrueLiteral | ts.FalseLiteral | ts.NumericLiteral;
+export declare function createLiteral(v: string | boolean | number): default_2.StringLiteral | default_2.TrueLiteral | default_2.FalseLiteral | default_2.NumericLiteral;
 
-export declare function createMethod(name: string | ts.Identifier | ts.StringLiteral | ts.NumericLiteral | ts.ComputedPropertyName, { modifiers, asteriskToken, questionToken, typeParameters, type, }?: {
-    modifiers?: ts.Modifier[];
-    asteriskToken?: ts.AsteriskToken;
-    questionToken?: ts.QuestionToken | boolean;
-    typeParameters?: ts.TypeParameterDeclaration[];
-    type?: ts.TypeNode;
-}, parameters?: ts.ParameterDeclaration[], body?: ts.Block): ts.MethodDeclaration;
+export declare function createMethod(name: string | default_2.Identifier | default_2.StringLiteral | default_2.NumericLiteral | default_2.ComputedPropertyName, { modifiers, asteriskToken, questionToken, typeParameters, type, }?: {
+    modifiers?: default_2.Modifier[];
+    asteriskToken?: default_2.AsteriskToken;
+    questionToken?: default_2.QuestionToken | boolean;
+    typeParameters?: default_2.TypeParameterDeclaration[];
+    type?: default_2.TypeNode;
+}, parameters?: default_2.ParameterDeclaration[], body?: default_2.Block): default_2.MethodDeclaration;
 
 export declare function createMethodCall(method: string, opts: {
-    typeArgs?: Array<ts.TypeNode>;
-    args?: Array<ts.Expression>;
-}): ts.CallExpression;
+    typeArgs?: Array<default_2.TypeNode>;
+    args?: Array<default_2.Expression>;
+}): default_2.CallExpression;
 
 export declare function createObjectBinding(elements: Array<{
-    name: string | ts.BindingName;
-    dotDotDotToken?: ts.DotDotDotToken;
-    propertyName?: string | ts.PropertyName;
-    initializer?: ts.Expression;
-}>): ts.ObjectBindingPattern;
+    name: string | default_2.BindingName;
+    dotDotDotToken?: default_2.DotDotDotToken;
+    propertyName?: string | default_2.PropertyName;
+    initializer?: default_2.Expression;
+}>): default_2.ObjectBindingPattern;
 
-export declare function createObjectLiteral(props: [string, string | ts.Expression][]): ts.ObjectLiteralExpression;
+export declare function createObjectLiteral(props: [string, string | default_2.Expression][]): default_2.ObjectLiteralExpression;
 
-export declare function createParameter(name: string | ts.BindingName, { modifiers, dotDotDotToken, questionToken, type, initializer, }: {
-    modifiers?: Array<ts.Modifier>;
-    dotDotDotToken?: ts.DotDotDotToken;
-    questionToken?: ts.QuestionToken | boolean;
-    type?: ts.TypeNode;
-    initializer?: ts.Expression;
-}): ts.ParameterDeclaration;
+export declare function createParameter(name: string | default_2.BindingName, { modifiers, dotDotDotToken, questionToken, type, initializer, }: {
+    modifiers?: Array<default_2.Modifier>;
+    dotDotDotToken?: default_2.DotDotDotToken;
+    questionToken?: default_2.QuestionToken | boolean;
+    type?: default_2.TypeNode;
+    initializer?: default_2.Expression;
+}): default_2.ParameterDeclaration;
 
-export declare function createPropertyAssignment(name: string, expression: ts.Expression): ts.PropertyAssignment | ts.ShorthandPropertyAssignment;
+export declare function createPropertyAssignment(name: string, expression: default_2.Expression): default_2.PropertyAssignment | default_2.ShorthandPropertyAssignment;
 
 export declare function createPropertySignature({ modifiers, name, questionToken, type, }: {
-    modifiers?: Array<ts.Modifier>;
-    name: ts.PropertyName | string;
-    questionToken?: ts.QuestionToken | boolean;
-    type?: ts.TypeNode;
-}): ts.PropertySignature;
+    modifiers?: Array<default_2.Modifier>;
+    name: default_2.PropertyName | string;
+    questionToken?: default_2.QuestionToken | boolean;
+    type?: default_2.TypeNode;
+}): default_2.PropertySignature;
 
-export declare function createQuestionToken(token?: boolean | ts.QuestionToken): ts.QuestionToken | undefined;
+export declare function createQuestionToken(token?: boolean | default_2.QuestionToken): default_2.QuestionToken | undefined;
 
 export declare function createTemplateString(head: string, spans: Array<{
     literal: string;
-    expression: ts.Expression;
-}>): ts.StringLiteral | ts.TemplateExpression;
+    expression: default_2.Expression;
+}>): default_2.StringLiteral | default_2.TemplateExpression;
 
 export declare function createTypeAliasDeclaration({ modifiers, name, typeParameters, type, }: {
-    modifiers?: Array<ts.Modifier>;
-    name: string | ts.Identifier;
-    typeParameters?: Array<ts.TypeParameterDeclaration>;
-    type: ts.TypeNode;
-}): ts.TypeAliasDeclaration;
+    modifiers?: Array<default_2.Modifier>;
+    name: string | default_2.Identifier;
+    typeParameters?: Array<default_2.TypeParameterDeclaration>;
+    type: default_2.TypeNode;
+}): default_2.TypeAliasDeclaration;
 
 /**
  * Create a template string literal from the given OpenAPI urlTemplate.
  * Curly braces in the path are turned into identifier expressions,
  * which are read from the local scope during runtime.
  */
-export declare function createUrlExpression(path: string, qs?: ts.Expression): ts.StringLiteral | ts.TemplateExpression;
+export declare function createUrlExpression(path: string, qs?: default_2.Expression): default_2.StringLiteral | default_2.TemplateExpression;
 
-export declare function defaultBaseUrl(servers: OpenAPIV3.ServerObject[]): ts.StringLiteral;
+export declare function defaultBaseUrl(servers: OpenAPIV3.ServerObject[]): default_2.StringLiteral;
 
-export declare function findFirstVariableDeclaration(nodes: ts.NodeArray<ts.Node>, name: string): ts.VariableDeclaration;
+export declare function findFirstVariableDeclaration(nodes: default_2.NodeArray<default_2.Node>, name: string): default_2.VariableDeclaration;
 
-export declare function findNode<T extends ts.Node>(nodes: ts.NodeArray<ts.Node>, kind: T extends {
+export declare function findNode<T extends default_2.Node>(nodes: default_2.NodeArray<default_2.Node>, kind: T extends {
     kind: infer K;
 } ? K : never, test?: (node: T) => boolean | undefined): T;
 
 export declare function getBodyFormatter(body?: OpenAPIRequestBodyObject): ContentType | undefined;
 
-export declare function getFirstDeclarationName(n: ts.VariableStatement): string | (void & {
+export declare function getFirstDeclarationName(n: default_2.VariableStatement): string | (void & {
     __escapedIdentifier: void;
 });
 
@@ -242,7 +242,7 @@ export declare function getFirstDeclarationName(n: ts.VariableStatement): string
  */
 export declare function getFormatter({ style, explode, content, }: OpenAPIParameterObject): "json" | "form" | "deep" | "explode" | "space" | "pipe";
 
-export declare function getName(name: ts.Node): string | (void & {
+export declare function getName(name: default_2.Node): string | (void & {
     __escapedIdentifier: void;
 });
 
@@ -270,21 +270,21 @@ export declare function isReference(obj: unknown): obj is OpenAPIReferenceObject
 export declare function isValidIdentifier(str: string): boolean;
 
 export declare const keywordType: {
-    any: ts.KeywordTypeNode<ts.SyntaxKind.AnyKeyword>;
-    number: ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword>;
-    object: ts.KeywordTypeNode<ts.SyntaxKind.ObjectKeyword>;
-    string: ts.KeywordTypeNode<ts.SyntaxKind.StringKeyword>;
-    boolean: ts.KeywordTypeNode<ts.SyntaxKind.BooleanKeyword>;
-    undefined: ts.KeywordTypeNode<ts.SyntaxKind.UndefinedKeyword>;
-    void: ts.KeywordTypeNode<ts.SyntaxKind.VoidKeyword>;
-    null: ts.LiteralTypeNode;
+    any: default_2.KeywordTypeNode<default_2.SyntaxKind.AnyKeyword>;
+    number: default_2.KeywordTypeNode<default_2.SyntaxKind.NumberKeyword>;
+    object: default_2.KeywordTypeNode<default_2.SyntaxKind.ObjectKeyword>;
+    string: default_2.KeywordTypeNode<default_2.SyntaxKind.StringKeyword>;
+    boolean: default_2.KeywordTypeNode<default_2.SyntaxKind.BooleanKeyword>;
+    undefined: default_2.KeywordTypeNode<default_2.SyntaxKind.UndefinedKeyword>;
+    void: default_2.KeywordTypeNode<default_2.SyntaxKind.VoidKeyword>;
+    null: default_2.LiteralTypeNode;
 };
 
 declare type KeywordTypeName = keyof typeof keywordType;
 
 export declare const modifier: {
-    async: ts.ModifierToken<ts.SyntaxKind.AsyncKeyword>;
-    export: ts.ModifierToken<ts.SyntaxKind.ExportKeyword>;
+    async: default_2.ModifierToken<default_2.SyntaxKind.AsyncKeyword>;
+    export: default_2.ModifierToken<default_2.SyntaxKind.ExportKeyword>;
 };
 
 declare type OnlyMode = "readOnly" | "writeOnly";
@@ -321,20 +321,20 @@ declare type Opts = {
 
 declare const optsArgumentStyles: string[];
 
-export declare function printFile(sourceFile: ts.SourceFile): string;
+export declare function printFile(sourceFile: default_2.SourceFile): string;
 
-export declare function printNode(node: ts.Node): string;
+export declare function printNode(node: default_2.Node): string;
 
-export declare function printNodes(nodes: ts.Node[]): string;
+export declare function printNodes(nodes: default_2.Node[]): string;
 
-export declare const questionToken: ts.PunctuationToken<ts.SyntaxKind.QuestionToken>;
+export declare const questionToken: default_2.PunctuationToken<default_2.SyntaxKind.QuestionToken>;
 
 /**
  * Converts a local reference path into an array of property names.
  */
 export declare function refPathToPropertyPath(ref: string): string[];
 
-declare type SchemaObject = OpenAPISchemaObject & {
+export declare type SchemaObject = OpenAPISchemaObject & {
     const?: unknown;
     "x-enumNames"?: string[];
     "x-enum-varnames"?: string[];
@@ -349,7 +349,7 @@ declare type SchemaObject = OpenAPISchemaObject & {
  */
 export declare function supportDeepObjects(params: OpenAPIParameterObject[]): OpenAPIV3.ParameterObject[];
 
-export declare function toExpression(ex: ts.Expression | string): ts.Expression;
+export declare function toExpression(ex: default_2.Expression | string): default_2.Expression;
 
 export declare function toIdentifier(s: string, upperFirst?: boolean, onlyMode?: OnlyMode): string;