@goast/kotlin 0.3.10 → 0.3.12

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

@@ -1,32 +1,32 @@
-export declare const flux: (<TBuilder extends import("@goast/core").SourceBuilder>(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>>;
+export declare const flux: (<TBuilder extends import("../../..").SourceBuilder>(generics: [import("../_index").Type<TBuilder>], options?: {
+    nullable?: import("../../..").Nullable<boolean>;
+    inject?: import("../../..").AstNodeInject<TBuilder, ""> | undefined;
+    classReference?: import("../../..").Nullable<boolean>;
+    subReference?: import("../../..").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 extends import("@goast/core").SourceBuilder>(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>>;
+    packageName: import("../../..").Nullable<string>;
+    infer: <TBuilder extends import("../../..").SourceBuilder>(options?: {
+        nullable?: import("../../..").Nullable<boolean>;
+        inject?: import("../../..").AstNodeInject<TBuilder, ""> | undefined;
+        classReference?: import("../../..").Nullable<boolean>;
+        subReference?: import("../../..").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
     } | undefined) => import("../nodes/reference").KtReference<TBuilder, never>;
     matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };
-export declare const mono: (<TBuilder extends import("@goast/core").SourceBuilder>(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>>;
+export declare const mono: (<TBuilder extends import("../../..").SourceBuilder>(generics: [import("../_index").Type<TBuilder>], options?: {
+    nullable?: import("../../..").Nullable<boolean>;
+    inject?: import("../../..").AstNodeInject<TBuilder, ""> | undefined;
+    classReference?: import("../../..").Nullable<boolean>;
+    subReference?: import("../../..").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 extends import("@goast/core").SourceBuilder>(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>>;
+    packageName: import("../../..").Nullable<string>;
+    infer: <TBuilder extends import("../../..").SourceBuilder>(options?: {
+        nullable?: import("../../..").Nullable<boolean>;
+        inject?: import("../../..").AstNodeInject<TBuilder, ""> | undefined;
+        classReference?: import("../../..").Nullable<boolean>;
+        subReference?: import("../../..").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
     } | undefined) => import("../nodes/reference").KtReference<TBuilder, never>;
     matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };

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

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

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

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

package/types/lib/ast/utils/get-kotlin-builder-options.d.ts

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

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

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

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

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

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

@@ -1,3 +1,3 @@
-import { Nullable, SingleOrMultiple, SourceBuilder } from '@goast/core';
+import { Nullable, SingleOrMultiple, SourceBuilder } from '../../..';
 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

@@ -1,3 +1,3 @@
-import { SourceBuilder, SingleOrMultiple, Nullable } from '@goast/core';
+import { SourceBuilder, SingleOrMultiple, Nullable } from '../../..';
 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

@@ -1,3 +1,3 @@
-import { SourceBuilder, SingleOrMultiple, Nullable } from '@goast/core';
+import { SourceBuilder, SingleOrMultiple, Nullable } from '../../..';
 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

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

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

@@ -1,4 +1,4 @@
-import { SourceBuilder, Nullable, AppendValue, Separator, SingleOrMultiple } from '@goast/core';
+import { SourceBuilder, Nullable, AppendValue, Separator, SingleOrMultiple } from '../../..';
 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;

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

@@ -1,3 +1,3 @@
-import { SourceBuilder, SingleOrMultiple, Nullable } from '@goast/core';
+import { SourceBuilder, SingleOrMultiple, Nullable } from '../../..';
 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,4 +1,4 @@
-import { DefaultGenerationProviderConfig, OpenApiGeneratorConfig, StringCasing, StringCasingWithOptions } from '@goast/core';
+import { DefaultGenerationProviderConfig, OpenApiGeneratorConfig, StringCasing, StringCasingWithOptions } from '..';
 export type KotlinGeneratorConfig = OpenApiGeneratorConfig & {
     typeNameCasing: StringCasing | StringCasingWithOptions;
     parameterNameCasing: StringCasing | StringCasingWithOptions;

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

@@ -1,4 +1,4 @@
-import { AppendParam, AppendValue, SourceBuilder } from '@goast/core';
+import { AppendParam, AppendValue, SourceBuilder } from '..';
 import { KtNode } from './ast/node';
 import { KotlinGeneratorConfig } from './config';
 import { ImportCollection } from './import-collection';

package/types/lib/generators/file-generator.d.ts

@@ -1,4 +1,4 @@
-import { Nullable, OpenApiGenerationProviderContext, OpenApiGeneratorInput } from '@goast/core';
+import { Nullable, OpenApiGenerationProviderContext, OpenApiGeneratorInput } from '../..';
 import { KotlinGeneratorConfig } from '../config';
 export declare abstract class KotlinFileGenerator<TContext extends OpenApiGenerationProviderContext<OpenApiGeneratorInput, KotlinGeneratorConfig>, TOutput> {
     abstract generate(context: TContext): TOutput;

package/types/lib/generators/models/args.d.ts

@@ -1,4 +1,4 @@
-import { ApiSchema, ApiSchemaProperty } from '@goast/core';
+import { ApiSchema, ApiSchemaProperty } from '../../..';
 export type GetFileContent = {};
 export type GetSchemaDeclaration = {
     schema: ApiSchema;

package/types/lib/generators/models/model-generator.d.ts

@@ -1,4 +1,4 @@
-import { ApiSchema, ApiSchemaProperty, AppendValue, AppendValueGroup, SourceBuilder } from '@goast/core';
+import { ApiSchema, ApiSchemaProperty, AppendValue, AppendValueGroup, SourceBuilder } from '../../..';
 import { DefaultKotlinModelGeneratorArgs as Args } from '.';
 import { KotlinModelGeneratorContext, KotlinModelGeneratorOutput } from './models';
 import { kt } from '../../ast';
@@ -36,7 +36,7 @@ export declare class DefaultKotlinModelGenerator extends KotlinFileGenerator<Con
     protected getPackageName(ctx: Context, args: Args.GetPackageName): string;
     protected shouldGenerateTypeDeclaration(ctx: Context, args: Args.ShouldGenerateTypeDeclaration): boolean;
     protected getDeclarationTypeName(ctx: Context, args: Args.GetDeclarationTypeName): string;
-    protected getInheritedSchemas(ctx: Context, args: Args.GetInheritedSchemas): (ApiSchema<import("@goast/core").ApiSchemaKind> & {
+    protected getInheritedSchemas(ctx: Context, args: Args.GetInheritedSchemas): (ApiSchema<import("../../..").ApiSchemaKind> & {
         discriminator: NonNullable<ApiSchema["discriminator"]>;
     })[];
     protected getClassProperties(ctx: Context, args: Args.GetClassProperties): ApiSchemaProperty[];

package/types/lib/generators/models/models-generator.d.ts

@@ -1,4 +1,4 @@
-import { ApiSchema, Factory, OpenApiGeneratorContext, OpenApiSchemasGenerationProviderBase } from '@goast/core';
+import { ApiSchema, Factory, OpenApiGeneratorContext, OpenApiSchemasGenerationProviderBase } from '../../..';
 import { KotlinModelGenerator } from './model-generator';
 import { KotlinModelsGeneratorInput, KotlinModelsGeneratorOutput, KotlinModelsGeneratorConfig, KotlinModelGeneratorOutput, KotlinModelsGeneratorContext } from './models';
 type Input = KotlinModelsGeneratorInput;

package/types/lib/generators/models/models.d.ts

@@ -1,4 +1,4 @@
-import { ApiSchema, DefaultGenerationProviderConfig, OpenApiSchemasGenerationProviderContext, SourceBuilder } from '@goast/core';
+import { ApiSchema, DefaultGenerationProviderConfig, OpenApiSchemasGenerationProviderContext, SourceBuilder } from '../../..';
 import { kt } from '../../ast';
 import { KotlinGeneratorConfig } from '../../config';
 export type KotlinModelsGeneratorConfig = KotlinGeneratorConfig & {

package/types/lib/generators/services/okhttp3-clients/args.d.ts

@@ -1,4 +1,4 @@
-import { ApiEndpoint, ApiParameter, ApiSchema, SourceBuilder } from '@goast/core';
+import { ApiEndpoint, ApiParameter, ApiSchema, SourceBuilder } from '../../../..';
 import { kt } from '../../../ast';
 import { ApiParameterWithMultipartInfo } from '../../../types';
 export type GetClientFileContent = {};

package/types/lib/generators/services/okhttp3-clients/models.d.ts

@@ -1,4 +1,4 @@
-import { ApiEndpoint, ApiService, DefaultGenerationProviderConfig, OpenApiServicesGenerationProviderContext } from '@goast/core';
+import { ApiEndpoint, ApiService, DefaultGenerationProviderConfig, OpenApiServicesGenerationProviderContext } from '../../../..';
 import { getReferenceFactories } from './refs';
 import { KotlinImport } from '../../../common-results';
 import { KotlinGeneratorConfig } from '../../../config';