@futpib/parser 1.0.4 → 1.0.6

package/build/java.d.ts

@@ -0,0 +1,502 @@
+export type JavaName = {
+    type: 'Name';
+    identifier: string;
+    qualifier?: JavaName;
+};
+export type JavaSimpleName = {
+    type: 'SimpleName';
+    identifier: string;
+};
+export type JavaModifierKeyword = 'PUBLIC' | 'PROTECTED' | 'PRIVATE' | 'STATIC' | 'FINAL' | 'ABSTRACT' | 'SYNCHRONIZED' | 'NATIVE' | 'TRANSIENT' | 'VOLATILE' | 'STRICTFP' | 'DEFAULT' | 'SEALED' | 'NON_SEALED';
+export type JavaModifier = {
+    type: 'Modifier';
+    keyword: JavaModifierKeyword;
+};
+export type JavaMarkerAnnotationExpr = {
+    type: 'MarkerAnnotationExpr';
+    name: JavaName;
+};
+export type JavaSingleMemberAnnotationExpr = {
+    type: 'SingleMemberAnnotationExpr';
+    name: JavaName;
+    memberValue: JavaExpression;
+};
+export type JavaMemberValuePair = {
+    type: 'MemberValuePair';
+    name: JavaSimpleName;
+    value: JavaExpression;
+};
+export type JavaNormalAnnotationExpr = {
+    type: 'NormalAnnotationExpr';
+    name: JavaName;
+    pairs: JavaMemberValuePair[];
+};
+export type JavaAnnotationExpr = JavaMarkerAnnotationExpr | JavaSingleMemberAnnotationExpr | JavaNormalAnnotationExpr;
+export type JavaPackageDeclaration = {
+    type: 'PackageDeclaration';
+    annotations: JavaAnnotationExpr[];
+    name: JavaName;
+};
+export type JavaImportDeclaration = {
+    type: 'ImportDeclaration';
+    isStatic: boolean;
+    isAsterisk: boolean;
+    name: JavaName;
+};
+export type JavaTypeParameter = {
+    type: 'TypeParameter';
+    name: JavaSimpleName;
+    typeBound: JavaClassOrInterfaceType[];
+    annotations: JavaAnnotationExpr[];
+};
+export type JavaClassOrInterfaceType = {
+    type: 'ClassOrInterfaceType';
+    name: JavaSimpleName;
+    scope?: JavaClassOrInterfaceType;
+    typeArguments?: JavaType[];
+    annotations: JavaAnnotationExpr[];
+};
+export type JavaPrimitiveType = {
+    type: 'PrimitiveType';
+    type_: 'BOOLEAN' | 'BYTE' | 'CHAR' | 'DOUBLE' | 'FLOAT' | 'INT' | 'LONG' | 'SHORT';
+    annotations: JavaAnnotationExpr[];
+};
+export type JavaArrayType = {
+    type: 'ArrayType';
+    componentType: JavaType;
+    origin: 'NAME' | 'TYPE';
+    annotations: JavaAnnotationExpr[];
+};
+export type JavaVoidType = {
+    type: 'VoidType';
+    annotations: JavaAnnotationExpr[];
+};
+export type JavaWildcardType = {
+    type: 'WildcardType';
+    extendedType?: JavaReferenceType;
+    superType?: JavaReferenceType;
+    annotations: JavaAnnotationExpr[];
+};
+export type JavaVarType = {
+    type: 'VarType';
+    annotations: JavaAnnotationExpr[];
+};
+export type JavaUnionType = {
+    type: 'UnionType';
+    elements: JavaReferenceType[];
+    annotations: JavaAnnotationExpr[];
+};
+export type JavaIntersectionType = {
+    type: 'IntersectionType';
+    elements: JavaReferenceType[];
+    annotations: JavaAnnotationExpr[];
+};
+export type JavaReferenceType = JavaClassOrInterfaceType | JavaArrayType;
+export type JavaType = JavaPrimitiveType | JavaClassOrInterfaceType | JavaArrayType | JavaVoidType | JavaWildcardType | JavaVarType | JavaUnionType | JavaIntersectionType;
+export type JavaNameExpr = {
+    type: 'NameExpr';
+    name: JavaSimpleName;
+};
+export type JavaLiteralExpr = JavaIntegerLiteralExpr | JavaLongLiteralExpr | JavaDoubleLiteralExpr | JavaCharLiteralExpr | JavaStringLiteralExpr | JavaTextBlockLiteralExpr | JavaBooleanLiteralExpr | JavaNullLiteralExpr;
+export type JavaIntegerLiteralExpr = {
+    type: 'IntegerLiteralExpr';
+    value: string;
+};
+export type JavaLongLiteralExpr = {
+    type: 'LongLiteralExpr';
+    value: string;
+};
+export type JavaDoubleLiteralExpr = {
+    type: 'DoubleLiteralExpr';
+    value: string;
+};
+export type JavaCharLiteralExpr = {
+    type: 'CharLiteralExpr';
+    value: string;
+};
+export type JavaStringLiteralExpr = {
+    type: 'StringLiteralExpr';
+    value: string;
+};
+export type JavaTextBlockLiteralExpr = {
+    type: 'TextBlockLiteralExpr';
+    value: string;
+};
+export type JavaBooleanLiteralExpr = {
+    type: 'BooleanLiteralExpr';
+    value: boolean;
+};
+export type JavaNullLiteralExpr = {
+    type: 'NullLiteralExpr';
+};
+export type JavaThisExpr = {
+    type: 'ThisExpr';
+    typeName?: JavaName;
+};
+export type JavaSuperExpr = {
+    type: 'SuperExpr';
+    typeName?: JavaName;
+};
+export type JavaFieldAccessExpr = {
+    type: 'FieldAccessExpr';
+    scope: JavaExpression;
+    name: JavaSimpleName;
+    typeArguments?: JavaType[];
+};
+export type JavaArrayAccessExpr = {
+    type: 'ArrayAccessExpr';
+    name: JavaExpression;
+    index: JavaExpression;
+};
+export type JavaMethodCallExpr = {
+    type: 'MethodCallExpr';
+    scope?: JavaExpression;
+    name: JavaSimpleName;
+    arguments: JavaExpression[];
+    typeArguments?: JavaType[];
+};
+export type JavaObjectCreationExpr = {
+    type: 'ObjectCreationExpr';
+    scope?: JavaExpression;
+    type_: JavaClassOrInterfaceType;
+    arguments: JavaExpression[];
+    typeArguments?: JavaType[];
+    anonymousClassBody?: JavaBodyDeclaration[];
+};
+export type JavaArrayCreationExpr = {
+    type: 'ArrayCreationExpr';
+    elementType: JavaType;
+    levels: JavaArrayCreationLevel[];
+    initializer?: JavaArrayInitializerExpr;
+};
+export type JavaArrayCreationLevel = {
+    type: 'ArrayCreationLevel';
+    dimension?: JavaExpression;
+    annotations: JavaAnnotationExpr[];
+};
+export type JavaArrayInitializerExpr = {
+    type: 'ArrayInitializerExpr';
+    values: JavaExpression[];
+};
+export type JavaBinaryExpr = {
+    type: 'BinaryExpr';
+    left: JavaExpression;
+    right: JavaExpression;
+    operator: string;
+};
+export type JavaUnaryExpr = {
+    type: 'UnaryExpr';
+    expression: JavaExpression;
+    operator: string;
+    prefix: boolean;
+};
+export type JavaAssignExpr = {
+    type: 'AssignExpr';
+    target: JavaExpression;
+    value: JavaExpression;
+    operator: string;
+};
+export type JavaConditionalExpr = {
+    type: 'ConditionalExpr';
+    condition: JavaExpression;
+    thenExpr: JavaExpression;
+    elseExpr: JavaExpression;
+};
+export type JavaEnclosedExpr = {
+    type: 'EnclosedExpr';
+    inner: JavaExpression;
+};
+export type JavaCastExpr = {
+    type: 'CastExpr';
+    type_: JavaType;
+    expression: JavaExpression;
+};
+export type JavaInstanceOfExpr = {
+    type: 'InstanceOfExpr';
+    expression: JavaExpression;
+    type_: JavaReferenceType;
+    pattern?: JavaPatternExpr;
+};
+export type JavaTypePatternExpr = {
+    type: 'TypePatternExpr';
+    type_: JavaType;
+    name: JavaSimpleName;
+    modifiers: JavaModifier[];
+};
+export type JavaRecordPatternExpr = {
+    type: 'RecordPatternExpr';
+    type_: JavaType;
+    patternList: JavaPatternExpr[];
+};
+export type JavaPatternExpr = JavaTypePatternExpr | JavaRecordPatternExpr;
+export type JavaClassExpr = {
+    type: 'ClassExpr';
+    type_: JavaType;
+};
+export type JavaLambdaExpr = {
+    type: 'LambdaExpr';
+    parameters: JavaParameter[];
+    body: JavaStatement | JavaExpression;
+    isEnclosingParameters: boolean;
+};
+export type JavaMethodReferenceExpr = {
+    type: 'MethodReferenceExpr';
+    scope: JavaExpression | JavaType;
+    identifier: string;
+    typeArguments?: JavaType[];
+};
+export type JavaSwitchExpr = {
+    type: 'SwitchExpr';
+    selector: JavaExpression;
+    entries: JavaSwitchEntry[];
+};
+export type JavaExpression = JavaNameExpr | JavaLiteralExpr | JavaThisExpr | JavaSuperExpr | JavaFieldAccessExpr | JavaArrayAccessExpr | JavaMethodCallExpr | JavaObjectCreationExpr | JavaArrayCreationExpr | JavaArrayInitializerExpr | JavaBinaryExpr | JavaUnaryExpr | JavaAssignExpr | JavaConditionalExpr | JavaEnclosedExpr | JavaCastExpr | JavaInstanceOfExpr | JavaClassExpr | JavaLambdaExpr | JavaMethodReferenceExpr | JavaAnnotationExpr | JavaSwitchExpr;
+export type JavaBlockStmt = {
+    type: 'BlockStmt';
+    statements: JavaStatement[];
+};
+export type JavaExpressionStmt = {
+    type: 'ExpressionStmt';
+    expression: JavaExpression;
+};
+export type JavaReturnStmt = {
+    type: 'ReturnStmt';
+    expression?: JavaExpression;
+};
+export type JavaIfStmt = {
+    type: 'IfStmt';
+    condition: JavaExpression;
+    thenStmt: JavaStatement;
+    elseStmt?: JavaStatement;
+};
+export type JavaForStmt = {
+    type: 'ForStmt';
+    initialization: JavaExpression[];
+    compare?: JavaExpression;
+    update: JavaExpression[];
+    body: JavaStatement;
+};
+export type JavaForEachStmt = {
+    type: 'ForEachStmt';
+    variable: JavaVariableDeclarationExpr;
+    iterable: JavaExpression;
+    body: JavaStatement;
+};
+export type JavaWhileStmt = {
+    type: 'WhileStmt';
+    condition: JavaExpression;
+    body: JavaStatement;
+};
+export type JavaDoStmt = {
+    type: 'DoStmt';
+    body: JavaStatement;
+    condition: JavaExpression;
+};
+export type JavaSwitchStmt = {
+    type: 'SwitchStmt';
+    selector: JavaExpression;
+    entries: JavaSwitchEntry[];
+};
+export type JavaSwitchEntry = {
+    type: 'SwitchEntry';
+    labels: JavaExpression[];
+    type_: 'STATEMENT_GROUP' | 'EXPRESSION' | 'BLOCK' | 'THROWS_STATEMENT';
+    statements: JavaStatement[];
+    guard?: JavaExpression;
+};
+export type JavaBreakStmt = {
+    type: 'BreakStmt';
+    label?: JavaSimpleName;
+};
+export type JavaContinueStmt = {
+    type: 'ContinueStmt';
+    label?: JavaSimpleName;
+};
+export type JavaYieldStmt = {
+    type: 'YieldStmt';
+    expression: JavaExpression;
+};
+export type JavaThrowStmt = {
+    type: 'ThrowStmt';
+    expression: JavaExpression;
+};
+export type JavaTryStmt = {
+    type: 'TryStmt';
+    resources: JavaExpression[];
+    tryBlock: JavaBlockStmt;
+    catchClauses: JavaCatchClause[];
+    finallyBlock?: JavaBlockStmt;
+};
+export type JavaCatchClause = {
+    type: 'CatchClause';
+    parameter: JavaParameter;
+    body: JavaBlockStmt;
+};
+export type JavaSynchronizedStmt = {
+    type: 'SynchronizedStmt';
+    expression: JavaExpression;
+    body: JavaBlockStmt;
+};
+export type JavaLabeledStmt = {
+    type: 'LabeledStmt';
+    label: JavaSimpleName;
+    statement: JavaStatement;
+};
+export type JavaAssertStmt = {
+    type: 'AssertStmt';
+    check: JavaExpression;
+    message?: JavaExpression;
+};
+export type JavaLocalClassDeclarationStmt = {
+    type: 'LocalClassDeclarationStmt';
+    classDeclaration: JavaClassOrInterfaceDeclaration;
+};
+export type JavaLocalRecordDeclarationStmt = {
+    type: 'LocalRecordDeclarationStmt';
+    recordDeclaration: JavaRecordDeclaration;
+};
+export type JavaEmptyStmt = {
+    type: 'EmptyStmt';
+};
+export type JavaExplicitConstructorInvocationStmt = {
+    type: 'ExplicitConstructorInvocationStmt';
+    isThis: boolean;
+    expression?: JavaExpression;
+    arguments: JavaExpression[];
+    typeArguments?: JavaType[];
+};
+export type JavaUnparsableStmt = {
+    type: 'UnparsableStmt';
+};
+export type JavaStatement = JavaBlockStmt | JavaExpressionStmt | JavaReturnStmt | JavaIfStmt | JavaForStmt | JavaForEachStmt | JavaWhileStmt | JavaDoStmt | JavaSwitchStmt | JavaBreakStmt | JavaContinueStmt | JavaYieldStmt | JavaThrowStmt | JavaTryStmt | JavaSynchronizedStmt | JavaLabeledStmt | JavaAssertStmt | JavaLocalClassDeclarationStmt | JavaLocalRecordDeclarationStmt | JavaEmptyStmt | JavaExplicitConstructorInvocationStmt | JavaUnparsableStmt;
+export type JavaVariableDeclarator = {
+    type: 'VariableDeclarator';
+    name: JavaSimpleName;
+    type_: JavaType;
+    initializer?: JavaExpression;
+};
+export type JavaVariableDeclarationExpr = {
+    type: 'VariableDeclarationExpr';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    variables: JavaVariableDeclarator[];
+};
+export type JavaParameter = {
+    type: 'Parameter';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    type_: JavaType;
+    isVarArgs: boolean;
+    varArgsAnnotations: JavaAnnotationExpr[];
+    name: JavaSimpleName;
+};
+export type JavaReceiverParameter = {
+    type: 'ReceiverParameter';
+    annotations: JavaAnnotationExpr[];
+    type_: JavaType;
+    name: JavaName;
+};
+export type JavaFieldDeclaration = {
+    type: 'FieldDeclaration';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    variables: JavaVariableDeclarator[];
+};
+export type JavaMethodDeclaration = {
+    type: 'MethodDeclaration';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    typeParameters: JavaTypeParameter[];
+    type_: JavaType;
+    name: JavaSimpleName;
+    parameters: JavaParameter[];
+    receiverParameter?: JavaReceiverParameter;
+    thrownExceptions: JavaReferenceType[];
+    body?: JavaBlockStmt;
+};
+export type JavaConstructorDeclaration = {
+    type: 'ConstructorDeclaration';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    typeParameters: JavaTypeParameter[];
+    name: JavaSimpleName;
+    parameters: JavaParameter[];
+    receiverParameter?: JavaReceiverParameter;
+    thrownExceptions: JavaReferenceType[];
+    body: JavaBlockStmt;
+};
+export type JavaInitializerDeclaration = {
+    type: 'InitializerDeclaration';
+    isStatic: boolean;
+    body: JavaBlockStmt;
+};
+export type JavaEnumConstantDeclaration = {
+    type: 'EnumConstantDeclaration';
+    annotations: JavaAnnotationExpr[];
+    name: JavaSimpleName;
+    arguments: JavaExpression[];
+    classBody: JavaBodyDeclaration[];
+};
+export type JavaAnnotationMemberDeclaration = {
+    type: 'AnnotationMemberDeclaration';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    type_: JavaType;
+    name: JavaSimpleName;
+    defaultValue?: JavaExpression;
+};
+export type JavaCompactConstructorDeclaration = {
+    type: 'CompactConstructorDeclaration';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    typeParameters: JavaTypeParameter[];
+    name: JavaSimpleName;
+    thrownExceptions: JavaReferenceType[];
+    body: JavaBlockStmt;
+};
+export type JavaBodyDeclaration = JavaFieldDeclaration | JavaMethodDeclaration | JavaConstructorDeclaration | JavaInitializerDeclaration | JavaEnumConstantDeclaration | JavaAnnotationMemberDeclaration | JavaCompactConstructorDeclaration | JavaClassOrInterfaceDeclaration | JavaEnumDeclaration | JavaRecordDeclaration | JavaAnnotationDeclaration;
+export type JavaClassOrInterfaceDeclaration = {
+    type: 'ClassOrInterfaceDeclaration';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    name: JavaSimpleName;
+    isInterface: boolean;
+    typeParameters: JavaTypeParameter[];
+    extendedTypes: JavaClassOrInterfaceType[];
+    implementedTypes: JavaClassOrInterfaceType[];
+    permittedTypes: JavaClassOrInterfaceType[];
+    members: JavaBodyDeclaration[];
+};
+export type JavaEnumDeclaration = {
+    type: 'EnumDeclaration';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    name: JavaSimpleName;
+    implementedTypes: JavaClassOrInterfaceType[];
+    entries: JavaEnumConstantDeclaration[];
+    members: JavaBodyDeclaration[];
+};
+export type JavaRecordDeclaration = {
+    type: 'RecordDeclaration';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    name: JavaSimpleName;
+    typeParameters: JavaTypeParameter[];
+    parameters: JavaParameter[];
+    implementedTypes: JavaClassOrInterfaceType[];
+    members: JavaBodyDeclaration[];
+};
+export type JavaAnnotationDeclaration = {
+    type: 'AnnotationDeclaration';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotationExpr[];
+    name: JavaSimpleName;
+    members: JavaBodyDeclaration[];
+};
+export type JavaTypeDeclaration = JavaClassOrInterfaceDeclaration | JavaEnumDeclaration | JavaRecordDeclaration | JavaAnnotationDeclaration;
+export type JavaCompilationUnit = {
+    type: 'CompilationUnit';
+    packageDeclaration?: JavaPackageDeclaration;
+    imports: JavaImportDeclaration[];
+    types: JavaTypeDeclaration[];
+};

package/build/java.js

@@ -0,0 +1,2 @@
+// Java AST type definitions - matches javaparser's JSON output format
+export {};

package/build/javaKeyStoreParser.js

@@ -1,5 +1,7 @@
+import { MUtf8Decoder } from 'mutf-8';
 import { createExactSequenceParser } from './exactSequenceParser.js';
 import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { createObjectParser } from './objectParser.js';
 import { setParserName } from './parser.js';
 import { parserCreatorCompose } from './parserCreatorCompose.js';
 import { promiseCompose } from './promiseCompose.js';
@@ -14,17 +16,18 @@ setParserName(uint32BEParser, 'uint32BEParser');
 const uint16BEParser = promiseCompose(createFixedLengthSequenceParser(2), array => Buffer.from(array).readUInt16BE());
 setParserName(uint16BEParser, 'uint16BEParser');
 const createUint32BECountPrefixedParser = (elementParser) => parserCreatorCompose(() => uint32BEParser, count => createQuantifierParser(elementParser, count))();
-const javaModifiedUTF8StringParser = promiseCompose(parserCreatorCompose(() => uint16BEParser, length => createFixedLengthSequenceParser(length))(), uint8Array => Buffer.from(uint8Array).toString('utf8'));
+const mutf8Decoder = new MUtf8Decoder();
+const javaModifiedUTF8StringParser = promiseCompose(parserCreatorCompose(() => uint16BEParser, length => createFixedLengthSequenceParser(length))(), uint8Array => mutf8Decoder.decode(uint8Array));
 const uint32LengthPrefixedUint8ArrayParser = parserCreatorCompose(() => uint32BEParser, length => createFixedLengthSequenceParser(length))();
 const javaKeyStoreImplementationParser = promiseCompose(createUnionParser([
     createExactSequenceParser(Buffer.from('feedfeed', 'hex')),
     createExactSequenceParser(Buffer.from('cececece', 'hex')),
 ]), uint8Array => uint8Array[0] === 0xFE ? 'JKS' : 'JCEKS');
 const javaKeyStorePrivateKeyEntryPrivateKeyParser = uint32LengthPrefixedUint8ArrayParser;
-const javaKeyStorePrivateKeyEntryCertificateParser = promiseCompose(createTupleParser([
-    javaModifiedUTF8StringParser,
-    uint32LengthPrefixedUint8ArrayParser,
-]), ([type, certificate]) => ({ type, certificate }));
+const javaKeyStorePrivateKeyEntryCertificateParser = createObjectParser({
+    type: javaModifiedUTF8StringParser,
+    certificate: uint32LengthPrefixedUint8ArrayParser,
+});
 const javaKeyStorePrivateKeyEntryCertificateChainParser = createUint32BECountPrefixedParser(javaKeyStorePrivateKeyEntryCertificateParser);
 const javaKeyStorePrivateKeyEntryParser = promiseCompose(createTupleParser([
     createExactSequenceParser(Buffer.from('00000001', 'hex')),
@@ -53,15 +56,9 @@ const javaKeyStoreEntryParser = createUnionParser([
     javaKeyStoreSecretKeyEntryParser,
 ]);
 const javaKeyStoreEntriesParser = createUint32BECountPrefixedParser(javaKeyStoreEntryParser);
-const javaKeyStoreParser_ = createTupleParser([
-    javaKeyStoreImplementationParser,
-    uint32BEParser,
-    javaKeyStoreEntriesParser,
-    createFixedLengthSequenceParser(20),
-]);
-export const javaKeyStoreParser = promiseCompose(javaKeyStoreParser_, ([implementation, version, entries, hash,]) => ({
-    implementation,
-    version,
-    entries,
-    hash,
-}));
+export const javaKeyStoreParser = createObjectParser({
+    implementation: javaKeyStoreImplementationParser,
+    version: uint32BEParser,
+    entries: javaKeyStoreEntriesParser,
+    hash: createFixedLengthSequenceParser(20),
+});

package/build/javaParser.d.ts

@@ -0,0 +1,51 @@
+import { type Parser } from './parser.js';
+import { type JavaModifier, type JavaName, type JavaSimpleName, type JavaImportDeclaration } from './java.js';
+type JavaIdentifier = string;
+type JavaAnnotation = {
+    type: 'MarkerAnnotationExpr';
+    name: JavaName;
+};
+type JavaEnumDeclarationOutput = {
+    type: 'EnumDeclaration';
+    modifiers: JavaModifier[];
+    annotations: JavaAnnotation[];
+    name: JavaSimpleName;
+    implementedTypes: unknown[];
+    entries: unknown[];
+    members: unknown[];
+};
+type JavaRecordDeclaration = {
+    type: 'record';
+    annotations: JavaAnnotation[];
+    modifiers: JavaModifier[];
+    name: JavaIdentifier;
+};
+type JavaAnnotationTypeDeclaration = {
+    type: 'annotation';
+    annotations: JavaAnnotation[];
+    modifiers: JavaModifier[];
+    name: JavaIdentifier;
+};
+type JavaPackageDeclarationNew = {
+    type: 'PackageDeclaration';
+    annotations: JavaAnnotation[];
+    name: JavaName;
+};
+export declare const javaCompilationUnitParser: Parser<{
+    readonly type: "CompilationUnit";
+    readonly packageDeclaration: JavaPackageDeclarationNew | undefined;
+    readonly imports: JavaImportDeclaration[];
+    readonly types: (JavaEnumDeclarationOutput | JavaRecordDeclaration | JavaAnnotationTypeDeclaration | {
+        type: "ClassOrInterfaceDeclaration";
+        modifiers: JavaModifier[];
+        annotations: unknown[];
+        name: JavaSimpleName;
+        isInterface: boolean;
+        typeParameters: unknown[];
+        extendedTypes: unknown[];
+        implementedTypes: unknown[];
+        permittedTypes: unknown[];
+        members: unknown[];
+    })[];
+}, any>;
+export {};