@goast/kotlin 0.1.18 → 0.2.0

package/types/lib/ast/nodes/lambda.d.ts

@@ -0,0 +1,20 @@
+import { SourceBuilder, AstNodeOptions, Nullable, BasicAppendValue, AppendValue } from '@goast/core';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = 'arguments' | 'body';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    arguments?: Nullable<Nullable<BasicAppendValue<TBuilder>>[]>;
+    body?: Nullable<AppendValue<TBuilder>>;
+    singleline?: boolean;
+}>;
+export declare class KtLambda<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    arguments: BasicAppendValue<TBuilder>[];
+    body: AppendValue<TBuilder> | null;
+    singleline: boolean;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const ktLambda: (<TBuilder extends SourceBuilder<never>>(args: Options<TBuilder>['arguments'], body: Options<TBuilder>['body'], options?: Omit<Options<TBuilder>, 'arguments' | 'body'>) => KtLambda<TBuilder, never>) & {
+    write: typeof writeKtNodes;
+};
+export {};

package/types/lib/ast/nodes/object.d.ts

@@ -0,0 +1,34 @@
+import { SourceBuilder, AstNodeOptions, Nullable, BasicAppendValue } from '@goast/core';
+import { KtArgument } from './argument';
+import { KtFunction } from './function';
+import { KtInitBlock } from './init-block';
+import { KtProperty } from './property';
+import { KtType, KtValue } from './types';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = 'modifiers' | 'name' | 'inheritList' | 'body' | 'members';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    data?: boolean;
+    name?: Nullable<string>;
+    class?: KtType<TBuilder>;
+    classArguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
+    implements?: Nullable<Nullable<KtType<TBuilder>>[]>;
+    members?: Nullable<Nullable<KtObjectMember<TBuilder>>[]>;
+    companion?: Nullable<boolean>;
+}>;
+export type KtObjectMember<TBuilder extends SourceBuilder> = KtInitBlock<TBuilder> | KtProperty<TBuilder> | KtFunction<TBuilder> | BasicAppendValue<TBuilder>;
+export declare class KtObject<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    data: boolean;
+    name: string | null;
+    class: KtType<TBuilder> | null;
+    classArguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[];
+    implements: KtType<TBuilder>[];
+    members: KtObjectMember<TBuilder>[];
+    companion: boolean;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const ktObject: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => KtObject<TBuilder, never>) & {
+    write: typeof writeKtNodes;
+};
+export {};

package/types/lib/ast/nodes/parameter.d.ts

@@ -0,0 +1,48 @@
+import { SourceBuilder, AstNodeOptions, Prettify, Nullable, BasicAppendValue } from '@goast/core';
+import { KtAnnotation } from './annotation';
+import { KtType, KtValue } from './types';
+import { KtAccessModifier } from '../common';
+import { KtNode } from '../node';
+import { writeKtParameters } from '../utils/write-kt-parameters';
+type Injects = 'modifiers' | 'annotations' | 'name' | 'type' | 'default';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    name: string;
+    type: KtType<TBuilder>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    default?: Nullable<KtValue<TBuilder>>;
+    vararg?: Nullable<boolean>;
+    description?: Nullable<BasicAppendValue<TBuilder>>;
+    accessModifier?: Nullable<KtAccessModifier>;
+    property?: Nullable<'readonly' | 'mutable'>;
+    propertyDescription?: Nullable<BasicAppendValue<TBuilder>>;
+    override?: Nullable<boolean>;
+}>;
+export declare class KtParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    name: string;
+    type: KtType<TBuilder>;
+    annotations: KtAnnotation<TBuilder>[];
+    default: KtValue<TBuilder> | null;
+    vararg: boolean;
+    description: BasicAppendValue<TBuilder> | null;
+    accessModifier: KtAccessModifier | null;
+    property: 'readonly' | 'mutable' | null;
+    propertyDescription: BasicAppendValue<TBuilder> | null;
+    override: boolean;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const ktParameter: (<TBuilder extends SourceBuilder<never>>(name: KtParameter<TBuilder>['name'], type: KtParameter<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type' | 'accessModifier' | 'property' | 'propertyDescription' | 'override'>>) => KtParameter<TBuilder, never>) & {
+    class: <TBuilder_1 extends SourceBuilder<never>>(name: string, type: KtType<TBuilder_1>, options?: {
+        default?: Nullable<KtValue<TBuilder_1>>;
+        description?: Nullable<BasicAppendValue<TBuilder_1>>;
+        inject?: import("@goast/core").AstNodeInject<TBuilder_1, "" | Injects> | undefined;
+        annotations?: Nullable<Nullable<KtAnnotation<TBuilder_1, never>>[]>;
+        property?: Nullable<'readonly' | 'mutable'>;
+        vararg?: Nullable<boolean>;
+        accessModifier?: Nullable<KtAccessModifier>;
+        propertyDescription?: Nullable<BasicAppendValue<TBuilder_1>>;
+        override?: Nullable<boolean>;
+    } | undefined) => KtParameter<TBuilder_1, never>;
+    write: typeof writeKtParameters;
+};
+export {};

package/types/lib/ast/nodes/property.d.ts

@@ -0,0 +1,87 @@
+import { SourceBuilder, AppendValue, AstNodeOptions, Prettify, Nullable } from '@goast/core';
+import { KtAnnotation } from './annotation';
+import { KtArgument } from './argument';
+import { KtDoc } from './doc';
+import { KtType, KtValue } from './types';
+import { KtAccessModifier } from '../common';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type AccessorInjects = 'annotations' | 'modifiers' | 'params' | 'body';
+type AccessorOptions<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | AccessorInjects>, {
+    accessModifier?: Nullable<KtAccessModifier>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    body?: Nullable<AppendValue<TBuilder>>;
+    singleExpression?: Nullable<boolean>;
+}>;
+export declare abstract class KtPropertyAccessor<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | AccessorInjects> {
+    abstract get kind(): 'get' | 'set';
+    accessModifier: KtAccessModifier | null;
+    annotations: KtAnnotation<TBuilder>[];
+    body: AppendValue<TBuilder> | null;
+    singleExpression: boolean;
+    constructor(options: AccessorOptions<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare class KtPropertyGetter<TBuilder extends SourceBuilder> extends KtPropertyAccessor<TBuilder> {
+    readonly kind = "get";
+}
+export declare class KtPropertySetter<TBuilder extends SourceBuilder> extends KtPropertyAccessor<TBuilder> {
+    readonly kind = "set";
+}
+type Injects = 'doc' | 'annotations' | 'modifiers' | 'name' | 'type' | 'default' | 'delegate';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    doc?: Nullable<KtDoc<TBuilder>>;
+    name: string;
+    type?: KtType<TBuilder>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    accessModifier?: Nullable<KtAccessModifier>;
+    getter?: Nullable<KtPropertyGetter<TBuilder>>;
+    setter?: Nullable<KtPropertySetter<TBuilder>>;
+    default?: Nullable<KtValue<TBuilder>>;
+    delegate?: Nullable<KtType<TBuilder>>;
+    delegateArguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
+    mutable?: Nullable<boolean>;
+    const?: Nullable<boolean>;
+    lateinit?: Nullable<boolean>;
+    open?: Nullable<boolean>;
+    override?: Nullable<boolean>;
+    abstract?: Nullable<boolean>;
+}>;
+export declare class KtProperty<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    doc: KtDoc<TBuilder> | null;
+    name: string;
+    type: KtType<TBuilder> | null;
+    annotations: KtAnnotation<TBuilder>[];
+    accessModifier: KtAccessModifier | null;
+    getter: KtPropertyGetter<TBuilder> | null;
+    setter: KtPropertySetter<TBuilder> | null;
+    default: KtValue<TBuilder> | null;
+    delegate: KtType<TBuilder> | null;
+    delegateArguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[] | null;
+    mutable: boolean;
+    const: boolean;
+    lateinit: boolean;
+    open: boolean;
+    override: boolean;
+    abstract: boolean;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const ktProperty: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtProperty<TBuilder, never>) & {
+    getter: <TBuilder_1 extends SourceBuilder<never>>(options?: {
+        accessModifier?: Nullable<KtAccessModifier>;
+        annotations?: Nullable<Nullable<KtAnnotation<TBuilder_1, never>>[]>;
+        body?: Nullable<AppendValue<TBuilder_1>>;
+        singleExpression?: Nullable<boolean>;
+        inject?: import("@goast/core").AstNodeInject<TBuilder_1, "" | AccessorInjects> | undefined;
+    } | undefined) => KtPropertyGetter<TBuilder_1>;
+    setter: <TBuilder_2 extends SourceBuilder<never>>(options?: {
+        accessModifier?: Nullable<KtAccessModifier>;
+        annotations?: Nullable<Nullable<KtAnnotation<TBuilder_2, never>>[]>;
+        body?: Nullable<AppendValue<TBuilder_2>>;
+        singleExpression?: Nullable<boolean>;
+        inject?: import("@goast/core").AstNodeInject<TBuilder_2, "" | AccessorInjects> | undefined;
+    } | undefined) => KtPropertySetter<TBuilder_2>;
+    write: typeof writeKtNodes;
+};
+export {};

package/types/lib/ast/nodes/reference.d.ts

@@ -0,0 +1,63 @@
+import { SourceBuilder, AstNodeOptions, Nullable, Prettify, TupleWithCount } from '@goast/core';
+import { KtType } from './types';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+import type { KtCall } from './call';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    name: string;
+    packageName?: Nullable<string>;
+    generics?: Nullable<Nullable<KtType<TBuilder>>[]>;
+    nullable?: Nullable<boolean>;
+    classReference?: Nullable<boolean>;
+    subReference?: Nullable<KtReference<TBuilder> | KtCall<TBuilder>>;
+}>;
+type _AddImportHandler<T> = {
+    builderClass: abstract new (...args: any) => T;
+    handler: (builder: T, reference: KtReference<any>) => void;
+};
+export declare class KtReference<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    private static readonly addImportHandlers;
+    name: string;
+    packageName: string | null;
+    generics: KtType<TBuilder>[];
+    nullable: boolean;
+    classReference: boolean;
+    subReference: KtReference<TBuilder> | KtCall<TBuilder> | null;
+    constructor(options: Options<TBuilder, TInjects>);
+    addImport(builder: TBuilder): void;
+    protected onWrite(builder: TBuilder): void;
+    static registerAddImportHandler<TBuilder extends SourceBuilder>(builderClass: _AddImportHandler<TBuilder>['builderClass'], handler: _AddImportHandler<TBuilder>['handler']): void;
+}
+export declare const ktReference: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], packageName?: Options<TBuilder>['packageName'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName'>>) => KtReference<TBuilder, never>) & {
+    factory: (name: string, packageName?: Nullable<string>) => (<TBuilder_1 extends SourceBuilder<never>>(options?: {
+        nullable?: Nullable<boolean>;
+        inject?: import("@goast/core").AstNodeInject<TBuilder_1, ""> | undefined;
+        generics?: Nullable<Nullable<KtType<TBuilder_1>>[]>;
+        classReference?: Nullable<boolean>;
+        subReference?: Nullable<KtReference<TBuilder_1, never> | KtCall<TBuilder_1, never>>;
+    } | undefined) => KtReference<TBuilder_1, never>) & {
+        refName: string;
+        packageName: Nullable<string>;
+        matches: (value: unknown) => value is KtReference<never, never>;
+    };
+    genericFactory: <TGenericCount extends number | number[]>(name: string, packageName?: Nullable<string>) => (<TBuilder_2 extends SourceBuilder<never>>(generics: TupleWithCount<KtType<TBuilder_2>, TGenericCount>, options?: {
+        nullable?: Nullable<boolean>;
+        inject?: import("@goast/core").AstNodeInject<TBuilder_2, ""> | undefined;
+        classReference?: Nullable<boolean>;
+        subReference?: Nullable<KtReference<TBuilder_2, never> | KtCall<TBuilder_2, never>>;
+    } | undefined) => KtReference<TBuilder_2, never>) & {
+        refName: string;
+        packageName: Nullable<string>;
+        infer: <TBuilder_3 extends SourceBuilder<never>>(options?: {
+            nullable?: Nullable<boolean>;
+            inject?: import("@goast/core").AstNodeInject<TBuilder_3, ""> | undefined;
+            classReference?: Nullable<boolean>;
+            subReference?: Nullable<KtReference<TBuilder_3, never> | KtCall<TBuilder_3, never>>;
+        } | undefined) => KtReference<TBuilder_3, never>;
+        matches: (value: unknown) => value is KtReference<never, never>;
+    };
+    write: typeof writeKtNodes;
+    import: <TBuilder_4 extends SourceBuilder<never>>(builder: TBuilder_4, references: KtReference<TBuilder_4, never>[]) => void;
+};
+export {};

package/types/lib/ast/nodes/string.d.ts

@@ -0,0 +1,30 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    value?: Nullable<string>;
+    template?: Nullable<boolean>;
+    multiline?: Nullable<boolean>;
+    trimMargin?: Nullable<boolean>;
+    marginPrefix?: Nullable<string>;
+    autoAddMarginPrefix?: Nullable<boolean>;
+}>;
+export declare class KtString<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    value: string | null;
+    template: boolean;
+    multiline: boolean;
+    trimMargin: boolean;
+    marginPrefix: string | null;
+    autoAddMarginPrefix: boolean;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+    protected findTemplateParts(value: string): {
+        value: string;
+        index: number;
+    }[];
+}
+export declare const ktString: (<TBuilder extends SourceBuilder<never>>(value: Options<TBuilder>['value'], options?: Prettify<Omit<Options<TBuilder>, 'value'>>) => KtString<TBuilder, never>) & {
+    write: typeof writeKtNodes;
+};
+export {};

package/types/lib/ast/nodes/types.d.ts

@@ -0,0 +1,10 @@
+import type { KtCall } from './call';
+import type { KtCollectionLiteral } from './collection-literal';
+import type { KtLambda } from './lambda';
+import type { KtLambdaType } from './lambda-type';
+import type { KtObject } from './object';
+import type { KtReference } from './reference';
+import type { KtString } from './string';
+import type { BasicAppendValue, SourceBuilder } from '@goast/core';
+export type KtType<TBuilder extends SourceBuilder> = KtReference<TBuilder> | KtLambdaType<TBuilder> | BasicAppendValue<TBuilder>;
+export type KtValue<TBuilder extends SourceBuilder> = KtReference<TBuilder> | KtString<TBuilder> | KtCall<TBuilder> | KtObject<TBuilder> | KtLambda<TBuilder> | KtCollectionLiteral<TBuilder> | BasicAppendValue<TBuilder>;

package/types/lib/ast/references/index.d.ts

@@ -0,0 +1,8 @@
+export * as jackson from './jackson';
+export * as jakarta from './jakarta';
+export * as java from './java';
+export * from './kotlin';
+export * as okhttp3 from './okhttp3';
+export * as reactor from './reactor';
+export * as spring from './spring';
+export * as swagger from './swagger';

package/types/lib/ast/references/jackson.d.ts

@@ -0,0 +1,77 @@
+export declare const jsonTypeInfo: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const jsonSubTypes: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const jsonProperty: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const jsonInclude: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const jsonIgnore: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const jsonAnySetter: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const jsonAnyGetter: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};

package/types/lib/ast/references/jakarta.d.ts

@@ -0,0 +1,33 @@
+export declare const generated: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const valid: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const pattern: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};

package/types/lib/ast/references/java.d.ts

@@ -0,0 +1,71 @@
+export declare const system: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const illegalStateException: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const unsupportedOperationException: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const ioException: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const offsetDateTime: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};
+export declare const optional: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>], options?: {
+    nullable?: import("@goast/core").Nullable<boolean>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>(options?: {
+        nullable?: import("@goast/core").Nullable<boolean>;
+        inject?: import("@goast/core").AstNodeInject<TBuilder_1, ""> | undefined;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder_1, never> | import("../_index").Call<TBuilder_1, never>>;
+    } | undefined) => import("../nodes/reference").KtReference<TBuilder_1, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+};