@goast/kotlin 0.1.18 → 0.2.0

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

@@ -0,0 +1,265 @@
+export declare const any: (<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 nothing: (<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 unit: (<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 string: (<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 int: (<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 long: (<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 float: (<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 double: (<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 boolean: (<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 lazyFun: (<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>;
+};
+export declare const throws: (<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 list: (<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>;
+};
+export declare const mutableList: (<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>;
+};
+export declare const map: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, 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>;
+};
+export declare const mutableMap: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, 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>;
+};
+export declare const listOf: (<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>;
+};
+export declare const mutableListOf: (<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>;
+};
+export declare const mapOf: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, 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>;
+};
+export declare const mutableMapOf: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, 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>;
+};
+export declare const jvmStatic: (<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/okhttp3.d.ts

@@ -0,0 +1,22 @@
+export declare const okHttpClient: (<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 httpUrl: (<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/reactor.d.ts

@@ -0,0 +1,16 @@
+export declare const flux: (<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>;
+};

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

@@ -0,0 +1,126 @@
+export declare const requestMapping: (<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 requestBody: (<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 requestParam: (<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 requestMethod: (<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 pathVariable: (<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 nativeWebRequest: (<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 autowired: (<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 validated: (<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 responseEntity: (<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>;
+};
+export declare const httpStatus: (<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 controller: (<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/swagger.d.ts

@@ -0,0 +1,44 @@
+export declare const parameter: (<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 operation: (<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 schema: (<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 apiResponse: (<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/utils/get-kotlin-builder-options.d.ts

@@ -0,0 +1,3 @@
+import { SourceBuilder } from '@goast/core';
+import { KotlinGeneratorConfig } from '../../config';
+export declare function getKotlinBuilderOptions(builder: SourceBuilder): KotlinGeneratorConfig;

package/types/lib/ast/utils/to-kt-node.d.ts

@@ -0,0 +1,7 @@
+import { BasicAppendValue, SourceBuilder } from '@goast/core';
+import { KtCall } from '../nodes/call';
+import { KtString } from '../nodes/string';
+export declare function toKtNode<TBuilder extends SourceBuilder>(object: Record<string | number, unknown>): KtCall<TBuilder>;
+export declare function toKtNode<TBuilder extends SourceBuilder>(list: unknown[]): KtCall<TBuilder>;
+export declare function toKtNode<TBuilder extends SourceBuilder>(string: string): KtString<TBuilder>;
+export declare function toKtNode<TBuilder extends SourceBuilder>(value: unknown): BasicAppendValue<TBuilder>;

package/types/lib/ast/utils/write-kt-annotations.d.ts

@@ -0,0 +1,5 @@
+import { SourceBuilder, SingleOrMultiple, Nullable } from '@goast/core';
+import { KtAppendValue } from './write-kt-node';
+export declare function writeKtAnnotations<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>, options?: {
+    multiline: boolean;
+}): void;

package/types/lib/ast/utils/write-kt-arguments.d.ts

@@ -0,0 +1,3 @@
+import { Nullable, SingleOrMultiple, SourceBuilder } from '@goast/core';
+import { KtAppendValue } from './write-kt-node';
+export declare function writeKtArguments<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>): void;

package/types/lib/ast/utils/write-kt-enum-values.d.ts

@@ -0,0 +1,3 @@
+import { SourceBuilder, SingleOrMultiple, Nullable } from '@goast/core';
+import { KtAppendValue } from './write-kt-node';
+export declare function writeKtEnumValues<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>): void;

package/types/lib/ast/utils/write-kt-generic-parameters.d.ts

@@ -0,0 +1,3 @@
+import { SourceBuilder, SingleOrMultiple, Nullable } from '@goast/core';
+import { KtAppendValue } from './write-kt-node';
+export declare function writeKtGenericParameters<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>): void;

package/types/lib/ast/utils/write-kt-members.d.ts

@@ -0,0 +1,5 @@
+import { SourceBuilder, Nullable } from '@goast/core';
+import { KtAppendValue } from './write-kt-node';
+export declare function writeKtMembers<TBuilder extends SourceBuilder>(builder: TBuilder, members: Nullable<KtAppendValue<TBuilder>>[], options?: {
+    alreadyHasMembers?: boolean;
+}): void;

package/types/lib/ast/utils/write-kt-node.d.ts

@@ -0,0 +1,7 @@
+import { SourceBuilder, Nullable, AppendValue, Separator, SingleOrMultiple } from '@goast/core';
+import { KtNode } from '../node';
+export type KtAppendValue<TBuilder extends SourceBuilder> = AppendValue<TBuilder> | KtNode<TBuilder>;
+export declare function writeKtNode<TBuilder extends SourceBuilder>(builder: TBuilder, node: Nullable<KtAppendValue<TBuilder>>): void;
+export declare function writeKtNodes<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>, options?: {
+    separator?: Separator<TBuilder, KtAppendValue<TBuilder>>;
+}): void;

package/types/lib/ast/utils/write-kt-parameters.d.ts

@@ -0,0 +1,3 @@
+import { SourceBuilder, SingleOrMultiple, Nullable } from '@goast/core';
+import { KtAppendValue } from './write-kt-node';
+export declare function writeKtParameters<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>): void;

package/types/lib/config.d.ts

@@ -1,6 +1,10 @@
 import { DefaultGenerationProviderConfig, OpenApiGeneratorConfig, StringCasing, StringCasingWithOptions } from '@goast/core';
 export type KotlinGeneratorConfig = OpenApiGeneratorConfig & {
+    typeNameCasing: StringCasing | StringCasingWithOptions;
+    parameterNameCasing: StringCasing | StringCasingWithOptions;
+    functionNameCasing: StringCasing | StringCasingWithOptions;
     propertyNameCasing: StringCasing | StringCasingWithOptions;
     enumValueNameCasing: StringCasing | StringCasingWithOptions;
+    globalImports: string[];
 };
 export declare const defaultKotlinGeneratorConfig: DefaultGenerationProviderConfig<KotlinGeneratorConfig>;

package/types/lib/file-builder.d.ts

@@ -1,14 +1,21 @@
-import { SourceBuilder, SourceBuilderOptions } from '@goast/core';
+import { AppendParam, AppendValue, SourceBuilder } from '@goast/core';
+import { KtNode } from './ast/node';
+import { KotlinGeneratorConfig } from './config';
 import { ImportCollection } from './import-collection';
 type AnnotationArgumentValue<T extends SourceBuilder> = string | ((builder: T) => void);
 type AnnotationArgument<T extends SourceBuilder> = AnnotationArgumentValue<T> | [key: string, value: AnnotationArgumentValue<T>] | [value: AnnotationArgumentValue<T>, condition: boolean] | [key: string, value: AnnotationArgumentValue<T>, condition: boolean];
-export declare class KotlinFileBuilder extends SourceBuilder {
+export type KotlinAppends<TAdditionalAppends> = KtNode<KotlinFileBuilder> | TAdditionalAppends;
+export type KotlinAppendParam<TBuilder extends KotlinFileBuilder, TAdditionalAppends> = AppendParam<TBuilder, KotlinAppends<TAdditionalAppends>>;
+export declare function isKotlinAppendValue<TBuilder extends KotlinFileBuilder>(value: unknown): value is AppendValue<TBuilder>;
+export declare class KotlinFileBuilder<TAdditionalAppends = never> extends SourceBuilder<KotlinAppends<TAdditionalAppends>> {
     readonly packageName: string | undefined;
     readonly imports: ImportCollection;
-    constructor(packageName: string | undefined, options: SourceBuilderOptions);
+    get options(): KotlinGeneratorConfig;
+    constructor(packageName?: string, options?: KotlinGeneratorConfig);
     addImport(name: string, packageName?: string): this;
     appendAnnotation(name: string, packageName?: string, args?: AnnotationArgument<this>[]): this;
     clear(): void;
     toString(addPadding?: boolean): string;
+    protected appendSingle(value: KotlinAppendParam<this, TAdditionalAppends>): void;
 }
 export {};