@goast/kotlin 0.3.13 → 0.4.0-beta2

package/esm/lib/ast/references/kotlin.d.ts

@@ -0,0 +1,301 @@
+export declare const any: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const nothing: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const unit: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const string: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const int: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const long: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const float: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const double: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const boolean: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const lazyFun: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index.js").Type<TBuilder>], options?: {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+        nullable?: import("@goast/core").Nullable<boolean>;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    } | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const throws: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const deprecated: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const list: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index.js").Type<TBuilder>], options?: {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+        nullable?: import("@goast/core").Nullable<boolean>;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    } | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const mutableList: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index.js").Type<TBuilder>], options?: {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+        nullable?: import("@goast/core").Nullable<boolean>;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    } | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const map: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index.js").Type<TBuilder>, import("../_index.js").Type<TBuilder>], options?: {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+        nullable?: import("@goast/core").Nullable<boolean>;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    } | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const mutableMap: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index.js").Type<TBuilder>, import("../_index.js").Type<TBuilder>], options?: {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+        nullable?: import("@goast/core").Nullable<boolean>;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    } | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const listOf: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index.js").Type<TBuilder>], options?: {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+        nullable?: import("@goast/core").Nullable<boolean>;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    } | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const mutableListOf: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index.js").Type<TBuilder>], options?: {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+        nullable?: import("@goast/core").Nullable<boolean>;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    } | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const mapOf: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index.js").Type<TBuilder>, import("../_index.js").Type<TBuilder>], options?: {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+        nullable?: import("@goast/core").Nullable<boolean>;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    } | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const mutableMapOf: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index.js").Type<TBuilder>, import("../_index.js").Type<TBuilder>], options?: {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+        nullable?: import("@goast/core").Nullable<boolean>;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    } | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const jvmStatic: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+//# sourceMappingURL=kotlin.d.ts.map

package/esm/lib/ast/references/kotlin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kotlin.d.ts","sourceRoot":"","sources":["../../../../src/lib/ast/references/kotlin.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,GAAG;;;;;;;;;;;;CAAuC,CAAC;AACxD,eAAO,MAAM,OAAO;;;;;;;;;;;;CAA2C,CAAC;AAChE,eAAO,MAAM,IAAI;;;;;;;;;;;;CAAwC,CAAC;AAC1D,eAAO,MAAM,MAAM;;;;;;;;;;;;CAA0C,CAAC;AAC9D,eAAO,MAAM,GAAG;;;;;;;;;;;;CAAuC,CAAC;AACxD,eAAO,MAAM,IAAI;;;;;;;;;;;;CAAwC,CAAC;AAC1D,eAAO,MAAM,KAAK;;;;;;;;;;;;CAAyC,CAAC;AAC5D,eAAO,MAAM,MAAM;;;;;;;;;;;;CAA0C,CAAC;AAC9D,eAAO,MAAM,OAAO;;;;;;;;;;;;CAA2C,CAAC;AAChE,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;CAAkD,CAAC;AACvE,eAAO,MAAM,MAAM;;;;;;;;;;;;CAA0C,CAAC;AAC9D,eAAO,MAAM,UAAU;;;;;;;;;;;;CAA8C,CAAC;AAGtE,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;CAA8D,CAAC;AAChF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;CAAqE,CAAC;AAC9F,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;CAA6D,CAAC;AAC9E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;CAAoE,CAAC;AAC5F,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;CAAgE,CAAC;AACpF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;CAAuE,CAAC;AAClG,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;CAA+D,CAAC;AAClF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;CAAsE,CAAC;AAGhG,eAAO,MAAM,SAAS;;;;;;;;;;;;CAAiD,CAAC"}

package/esm/lib/ast/references/okhttp3.d.ts

@@ -0,0 +1,27 @@
+export declare const okHttpClient: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const httpUrl: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+//# sourceMappingURL=okhttp3.d.ts.map

package/esm/lib/ast/references/okhttp3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"okhttp3.d.ts","sourceRoot":"","sources":["../../../../src/lib/ast/references/okhttp3.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;CAAiD,CAAC;AAC3E,eAAO,MAAM,OAAO;;;;;;;;;;;;CAA4C,CAAC"}

package/esm/lib/ast/references/reactor.d.ts

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

package/esm/lib/ast/references/reactor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactor.d.ts","sourceRoot":"","sources":["../../../../src/lib/ast/references/reactor.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;CAAkE,CAAC;AACpF,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;CAAkE,CAAC"}

package/esm/lib/ast/references/spring.d.ts

@@ -0,0 +1,173 @@
+export declare const autowired: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const httpStatus: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const responseEntity: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index.js").Type<TBuilder>], options?: {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+} | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+        nullable?: import("@goast/core").Nullable<boolean>;
+        classReference?: import("@goast/core").Nullable<boolean>;
+        subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    } | undefined) => import("../nodes/reference.js").KtReference<TBuilder, never>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const filePart: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const controller: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const validated: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const pathVariable: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const requestBody: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const requestMapping: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const requestMethod: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const requestParam: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const requestPart: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+export declare const nativeWebRequest: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
+    generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index.js").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
+    classReference?: import("@goast/core").Nullable<boolean>;
+    subReference?: import("@goast/core").Nullable<import("../nodes/reference.js").KtReference<TBuilder, never> | import("../_index.js").Call<TBuilder, never>>;
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference.js").KtReference<TBuilder, never>) & {
+    refName: string;
+    packageName: import("@goast/core").Nullable<string>;
+    matches: (value: unknown) => value is import("../nodes/reference.js").KtReference<never>;
+};
+//# sourceMappingURL=spring.d.ts.map

package/esm/lib/ast/references/spring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring.d.ts","sourceRoot":"","sources":["../../../../src/lib/ast/references/spring.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,SAAS;;;;;;;;;;;;CAAmF,CAAC;AAG1G,eAAO,MAAM,UAAU;;;;;;;;;;;;CAAgE,CAAC;AACxF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;CAA8E,CAAC;AAG1G,eAAO,MAAM,QAAQ;;;;;;;;;;;;CAA8E,CAAC;AAGpG,eAAO,MAAM,UAAU;;;;;;;;;;;;CAAsE,CAAC;AAG9F,eAAO,MAAM,SAAS;;;;;;;;;;;;CAAgF,CAAC;AAGvG,eAAO,MAAM,YAAY;;;;;;;;;;;;CAAiF,CAAC;AAC3G,eAAO,MAAM,WAAW;;;;;;;;;;;;CAAgF,CAAC;AACzG,eAAO,MAAM,cAAc;;;;;;;;;;;;CAAmF,CAAC;AAC/G,eAAO,MAAM,aAAa;;;;;;;;;;;;CAAkF,CAAC;AAC7G,eAAO,MAAM,YAAY;;;;;;;;;;;;CAAiF,CAAC;AAC3G,eAAO,MAAM,WAAW;;;;;;;;;;;;CAAgF,CAAC;AAGzG,eAAO,MAAM,gBAAgB;;;;;;;;;;;;CAAqF,CAAC"}