import ts from 'typescript';

declare const modifiers: {
    readonly async: ts.ModifierToken<ts.SyntaxKind.AsyncKeyword>;
    readonly export: ts.ModifierToken<ts.SyntaxKind.ExportKeyword>;
    readonly const: ts.ModifierToken<ts.SyntaxKind.ConstKeyword>;
    readonly static: ts.ModifierToken<ts.SyntaxKind.StaticKeyword>;
};
declare function createQuestionToken(token?: boolean | ts.QuestionToken): ts.PunctuationToken<ts.SyntaxKind.QuestionToken> | undefined;
declare function createIntersectionDeclaration({ nodes, withParentheses, }: {
    nodes: Array<ts.TypeNode>;
    withParentheses?: boolean;
}): ts.TypeNode | null;
/**
 * Minimum nodes length of 2
 * @example `string & number`
 */
declare function createTupleDeclaration({ nodes, withParentheses, }: {
    nodes: Array<ts.TypeNode>;
    withParentheses?: boolean;
}): ts.TypeNode | null;
declare function createArrayDeclaration({ nodes, }: {
    nodes: Array<ts.TypeNode>;
}): ts.TypeNode | null;
/**
 * Minimum nodes length of 2
 * @example `string | number`
 */
declare function createUnionDeclaration({ nodes, withParentheses, }: {
    nodes: Array<ts.TypeNode>;
    withParentheses?: boolean;
}): ts.TypeNode | null;
declare function createPropertySignature({ readOnly, modifiers, name, questionToken, type, }: {
    readOnly?: boolean;
    modifiers?: Array<ts.Modifier>;
    name: ts.PropertyName | string;
    questionToken?: ts.QuestionToken | boolean;
    type?: ts.TypeNode;
}): ts.PropertySignature;
declare function createParameterSignature(name: string | ts.BindingName, { modifiers, dotDotDotToken, questionToken, type, initializer, }: {
    decorators?: Array<ts.Decorator>;
    modifiers?: Array<ts.Modifier>;
    dotDotDotToken?: ts.DotDotDotToken;
    questionToken?: ts.QuestionToken | boolean;
    type?: ts.TypeNode;
    initializer?: ts.Expression;
}): ts.ParameterDeclaration;
declare function createJSDoc({ comments }: {
    comments: string[];
}): ts.JSDoc | null;
/**
 * @link https://github.com/microsoft/TypeScript/issues/44151
 */
declare function appendJSDocToNode<TNode extends ts.Node>({ node, comments, }: {
    node: TNode;
    comments: Array<string | undefined>;
}): TNode;
declare function createIndexSignature(type: ts.TypeNode, { modifiers, indexName, indexType, }?: {
    indexName?: string;
    indexType?: ts.TypeNode;
    decorators?: Array<ts.Decorator>;
    modifiers?: Array<ts.Modifier>;
}): ts.IndexSignatureDeclaration;
declare function createTypeAliasDeclaration({ modifiers, name, typeParameters, type, }: {
    modifiers?: Array<ts.Modifier>;
    name: string | ts.Identifier;
    typeParameters?: Array<ts.TypeParameterDeclaration>;
    type: ts.TypeNode;
}): ts.TypeAliasDeclaration;
declare function createNamespaceDeclaration({ statements, name, }: {
    name: string;
    statements: ts.Statement[];
}): ts.ModuleDeclaration;
/**
 * In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.
 * @example `import { Pet as Cat } from './Pet'`
 */
declare function createImportDeclaration({ name, path, isTypeOnly, isNameSpace, }: {
    name: string | Array<string | {
        propertyName: string;
        name?: string;
    }>;
    path: string;
    isTypeOnly?: boolean;
    isNameSpace?: boolean;
}): ts.ImportDeclaration;
declare function createExportDeclaration({ path, asAlias, isTypeOnly, name, }: {
    path: string;
    asAlias?: boolean;
    isTypeOnly?: boolean;
    name?: string | Array<ts.Identifier | string>;
}): ts.ExportDeclaration;
declare function createEnumDeclaration({ type, name, typeName, enums, }: {
    /**
     * @default `'enum'`
     */
    type?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal';
    /**
     * Enum name in camelCase.
     */
    name: string;
    /**
     * Enum name in PascalCase.
     */
    typeName: string;
    enums: [key: string | number, value: string | number | boolean][];
}): ts.EnumDeclaration[] | (ts.TypeAliasDeclaration | ts.VariableStatement)[];
declare function createOmitDeclaration({ keys, type, nonNullable, }: {
    keys: Array<string> | string;
    type: ts.TypeNode;
    nonNullable?: boolean;
}): ts.TypeReferenceNode;
declare const keywordTypeNodes: {
    readonly any: ts.KeywordTypeNode<ts.SyntaxKind.AnyKeyword>;
    readonly unknown: ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
    readonly number: ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword>;
    readonly integer: ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword>;
    readonly object: ts.KeywordTypeNode<ts.SyntaxKind.ObjectKeyword>;
    readonly string: ts.KeywordTypeNode<ts.SyntaxKind.StringKeyword>;
    readonly boolean: ts.KeywordTypeNode<ts.SyntaxKind.BooleanKeyword>;
    readonly undefined: ts.KeywordTypeNode<ts.SyntaxKind.UndefinedKeyword>;
    readonly null: ts.LiteralTypeNode;
};
declare const createTypeLiteralNode: (members: readonly ts.TypeElement[] | undefined) => ts.TypeLiteralNode;
declare const createTypeReferenceNode: (typeName: string | ts.EntityName, typeArguments?: readonly ts.TypeNode[] | undefined) => ts.TypeReferenceNode;
declare const createNumericLiteral: (value: string | number, numericLiteralFlags?: ts.TokenFlags | undefined) => ts.NumericLiteral;
declare const createStringLiteral: (text: string, isSingleQuote?: boolean | undefined) => ts.StringLiteral;
declare const createArrayTypeNode: (elementType: ts.TypeNode) => ts.ArrayTypeNode;
declare const createLiteralTypeNode: (literal: ts.LiteralExpression | ts.NullLiteral | ts.BooleanLiteral | ts.PrefixUnaryExpression) => ts.LiteralTypeNode;
declare const createNull: () => ts.NullLiteral;
declare const createIdentifier: (text: string) => ts.Identifier;
declare const createTupleTypeNode: (elements: readonly (ts.TypeNode | ts.NamedTupleMember)[]) => ts.TupleTypeNode;

export { appendJSDocToNode, createArrayDeclaration, createArrayTypeNode, createEnumDeclaration, createExportDeclaration, createIdentifier, createImportDeclaration, createIndexSignature, createIntersectionDeclaration, createJSDoc, createLiteralTypeNode, createNamespaceDeclaration, createNull, createNumericLiteral, createOmitDeclaration, createParameterSignature, createPropertySignature, createQuestionToken, createStringLiteral, createTupleDeclaration, createTupleTypeNode, createTypeAliasDeclaration, createTypeLiteralNode, createTypeReferenceNode, createUnionDeclaration, keywordTypeNodes, modifiers };