@luna-park/plugin 1.1.0 → 1.2.1

package/dist/extractor.d.ts

@@ -54,7 +54,7 @@ declare type Static<T extends TSchema> = T extends {
     optional: true;
 } ? (T["static"] | undefined) : T["static"];
 
-declare type StaticFunction<TInputs extends TObject, TOutput extends TSchema> = (...args: Array<Static<TInputs>[string]>) => Promise<Static<TOutput>>;
+declare type StaticFunction<TInputs extends TObject, TOutput extends TSchema, TPromise extends boolean = false> = TPromise extends true ? (...args: Array<Static<TInputs>[string]>) => Promise<Static<TOutput>> : (...args: Array<Static<TInputs>[string]>) => Static<TOutput>;
 
 declare type StaticObject<T extends TProperties> = {
     [K in RequiredKeys<T>]: Static<T[K]>;
@@ -71,7 +71,6 @@ declare type StaticUnion<T extends Array<TSchema>> = {
 declare type TAnyLogic = TExec | TObject | TRecord<any, any> | TInterface | TType | TArray<any> | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion<any> | TFunction<any, any> | TVoid;
 
 declare interface TArguments<TType = any> {
-    name?: string;
     build?: (arg: unknown) => unknown;
     customizable?: boolean;
     default?: TType;
@@ -86,6 +85,7 @@ declare interface TArguments<TType = any> {
     example?: unknown;
     format?: "date-time" | "email" | "color";
     multiple?: boolean;
+    name?: string;
     optional?: boolean;
     options?: {
         format?: (arg: TType) => TType;
@@ -101,14 +101,14 @@ declare interface TArguments<TType = any> {
 }
 
 declare interface TArray<T extends TSchema = TSchema> {
-    type: EVarType.array;
     items: T;
     static: Array<Static<T>>;
+    type: EVarType.array;
 }
 
 declare interface TBoolean {
-    type: EVarType.boolean;
     static: boolean;
+    type: EVarType.boolean;
 }
 
 declare type TEnum<TEnumType> = Array<TEnumType> | Record<string, TEnumType>;
@@ -174,72 +174,72 @@ declare type TExportType = {
     type: string | Record<string, TExportType>;
 };
 
-declare interface TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TUnknown> {
-    type: EVarType.function;
+declare interface TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TUnknown, TPromise extends boolean = false> {
     inputs: TInputs;
     output: TOutput;
-    static: StaticFunction<TInputs, TOutput>;
+    static: StaticFunction<TInputs, TOutput, TPromise>;
+    type: EVarType.function;
 }
 
 declare interface TInterface<T = unknown> {
-    type: EVarType.interface;
     class?: new (...args: any) => T;
     className: string;
     static: T;
+    type: EVarType.interface;
 }
 
 declare interface TNumber {
-    type: EVarType.number;
     static: number;
+    type: EVarType.number;
 }
 
 declare interface TObject<T extends TProperties = TProperties> {
-    type: EVarType.object;
     properties: T;
     static: StaticObject<T>;
+    type: EVarType.object;
 }
 
 declare type TProperties = Record<string, TSchema>;
 
 declare interface TRecord<TKey extends TString | TNumber = TString, TValue extends TSchema = TSchema> {
-    type: EVarType.record;
     key: TKey;
     static: StaticRecord<TKey, TValue>;
+    type: EVarType.record;
     value: TValue;
 }
 
 declare type TSchema<TLogic extends TAnyLogic = TAnyLogic> = TArguments & TLogic;
 
 declare interface TString {
-    type: EVarType.string;
     static: string;
+    type: EVarType.string;
 }
 
 declare interface TType<T extends TSchema = TSchema> {
-    type: EVarType.type;
     static: T;
     target: Array<string>;
+    type: EVarType.type;
 }
 
 declare interface TUndefined {
-    type: EVarType.undefined;
     static: undefined;
+    type: EVarType.undefined;
 }
 
 declare interface TUnion<T extends Array<TSchema> = Array<TSchema>> {
-    type: EVarType.union;
     elements: T;
     static: StaticUnion<T>;
+    type: EVarType.union;
 }
 
 declare interface TUnknown {
-    type: EVarType.unknown;
     static: unknown;
+    type: EVarType.unknown;
 }
 
 declare interface TVoid {
-    type: EVarType.void;
     static: void;
+    type: EVarType.void;
 }
 
 export { }