@luna-park/plugin 1.7.0 → 2.0.0

package/dist/{index-76yMHag4.d.mts → index-B4kxQtaL.d.mts}

@@ -1,9 +1,7 @@
 import { IconDefinition } from "@fortawesome/fontawesome-svg-core";
-//#region ../utils/dist/index.d.mts
-type DeepPartial<T> = { [K in keyof T]?: T[K] extends Array<unknown> ? Array<DeepPartial<T[K][number]>> : T[K] extends Record<string, unknown> ? DeepPartial<T[K]> : T[K]; };
+type TDeepPartialValue<T> = T extends Array<infer TItem> ? Array<TDeepPartialValue<TItem>> : T extends ((...args: Array<never>) => unknown) ? T : T extends object ? DeepPartial<T> : T;
+type DeepPartial<T> = { [K in keyof T]?: TDeepPartialValue<T[K]>; };
 type MaybePromise<T> = T | Promise<T>;
-//#endregion
-//#region src/vector.d.ts
 type TVector = {
   x: number;
   y: number;
@@ -27,10 +25,6 @@ declare class CVector {
   getPointString(): string;
   getMagnitude(): number;
 }
-//#endregion
-//#endregion
-//#region ../logicnodes/dist/index.d.mts
-//#region src/logic/type.d.ts
 declare enum EVarType {
   exec = "exec",
   number = "number",
@@ -43,15 +37,46 @@ declare enum EVarType {
   type = "type",
   function = "function",
   union = "union",
+  intersection = "intersection",
   unknown = "unknown",
   undefined = "undefined",
   void = "void"
 }
 type TProperties = Record<string, TSchema>;
+/** Schema options, augmentable by the packages that own each option with `declare module "@luna-park/logicnodes"`. */
+interface TSchemaOptions {
+  access?: TSchema<TObject>;
+  clamp?: boolean;
+  clean?: boolean;
+  fixed?: number;
+  foreignKey?: boolean;
+  format?: (value: string) => string | number;
+  freeze?: boolean;
+  hidden?: boolean | TSchemaHiddenCallback;
+  index?: boolean;
+  input?: string;
+  insert?: number | "last";
+  max?: number;
+  min?: number;
+  multiplier?: number;
+  notNull?: boolean;
+  onDelete?: string;
+  readonly?: boolean;
+  search?: boolean;
+  step?: number;
+  suffix?: string;
+  template?: Array<TSchema>;
+  token?: string;
+  type?: string;
+  unique?: boolean;
+  watch?: boolean;
+}
+type TSchemaHiddenCallback = {
+  hidden(values: Record<string, unknown>): boolean;
+}["hidden"];
 interface TArguments<TType = unknown> {
-  build?: (arg: unknown) => unknown;
+  build?(arg: unknown): unknown;
   customizable?: boolean;
-  default?: TType | (() => TType);
   defaultType?: TSchema;
   description?: string;
   dynamic?: ((arg: {
@@ -61,16 +86,13 @@ interface TArguments<TType = unknown> {
   }) => TSchema);
   enum?: TEnum<TType>;
   example?: unknown;
-  format?: "date-time" | "email" | "color";
+  format?: "date-time" | "email" | "color" | "password";
   multiple?: boolean;
   name?: string;
+  nullable?: boolean;
   optional?: boolean;
-  options?: {
-    access?: TSchema<TObject>;
-    freeze?: boolean;
-    readonly?: boolean;
-  } & Record<string, unknown>;
-  parse?: (arg: unknown) => unknown;
+  options?: TSchemaOptions;
+  parse?(arg: unknown): unknown;
   placeholder?: string;
   priority?: boolean;
   promise?: boolean;
@@ -79,89 +101,116 @@ interface TArguments<TType = unknown> {
   sub?: TSchema;
 }
 type TEnum<TEnumType> = Array<TEnumType> | Record<string, TEnumType>;
+type TSchemaArguments<TType = unknown> = TArguments<TType> & {
+  default?: TType;
+};
 interface TExec {
+  default?: never;
   type: EVarType.exec;
 }
 interface TNumber {
+  default?: number;
   static: number;
   type: EVarType.number;
 }
-interface TString {
-  static: string;
+interface TString<T extends string = string> {
+  default?: T;
+  static: T;
   type: EVarType.string;
 }
 interface TBoolean {
+  default?: boolean;
   static: boolean;
   type: EVarType.boolean;
 }
-interface TUnknown {
-  static: unknown;
+interface TUnknown<T = unknown> {
+  default?: T;
+  static: T;
   type: EVarType.unknown;
 }
 interface TUndefined {
+  default?: undefined;
   static: undefined;
   type: EVarType.undefined;
 }
 interface TVoid {
+  default?: never;
   static: void;
   type: EVarType.void;
 }
 interface TObject<T extends TProperties = TProperties> {
+  default?: StaticObject<T>;
   properties: T;
   static: StaticObject<T>;
   type: EVarType.object;
 }
 type TRecordKey = TString | TNumber;
 interface TRecord<TKey extends TRecordKey = TString, TValue extends TSchema = TSchema> {
+  default?: StaticRecord<TKey, TValue>;
   key: TKey;
   static: StaticRecord<TKey, TValue>;
   type: EVarType.record;
   value: TValue;
 }
 interface TInterface<T = unknown> {
-  class?: new (...args: Array<unknown>) => T;
+  class?: new (...args: Array<never>) => T;
   className: string;
+  default?: T;
   static: T;
   type: EVarType.interface;
 }
 interface TType<T = unknown> {
+  default?: T;
+  path?: Array<string>;
   static: T;
   target: Array<string>;
   type: EVarType.type;
 }
 interface TArray<T extends TSchema = TSchema> {
+  default?: Array<StaticSchema<T>>;
   items: T;
   static: Array<StaticSchema<T>>;
   type: EVarType.array;
 }
 interface TUnion<T extends ReadonlyArray<TSchema> = ReadonlyArray<TSchema>> {
+  default?: StaticUnion<T>;
   elements: T;
   static: StaticUnion<T>;
   type: EVarType.union;
 }
-type TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TSchema, TPromise extends boolean = false, TParameters extends ReadonlyArray<TSchema> = ReadonlyArray<TSchema>> = {
+interface TIntersection<T extends ReadonlyArray<TSchema> = ReadonlyArray<TSchema>> {
+  default?: StaticIntersection<T>;
+  elements: T;
+  static: StaticIntersection<T>;
+  type: EVarType.intersection;
+}
+interface TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TSchema, TPromise extends boolean = false, TParameters extends ReadonlyArray<TSchema> = ReadonlyArray<TSchema>> {
+  default?: never;
   inputs: TInputs;
   output: TOutput;
   static: StaticFunction<TParameters, TOutput, TPromise>;
   type: EVarType.function;
-};
-type TAnyLogic = TExec | TObject | TRecord<TRecordKey> | TInterface | TType | TArray | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion | TFunction<TObject, TSchema, boolean, ReadonlyArray<never>> | TVoid;
+}
+type TAnyLogic = TExec | TObject | TRecord<TRecordKey> | TInterface | TType | TArray | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion | TIntersection | TFunction<TObject, TAnyLogic & TArguments, boolean, ReadonlyArray<never>> | TVoid;
 type TSchema<TLogic extends TAnyLogic = TAnyLogic> = TLogic & TArguments;
 declare const LogicType: {
-  array: <T extends TSchema, TArgs extends TArguments<Array<StaticSchema<T>>>>(items: T, args?: TArgs) => TArray<T> & TArgs;
-  boolean: <TArgs extends TArguments<boolean>>(args?: TArgs) => TBoolean & TArgs;
-  exec: <const TArgs extends TArguments = {}>(args?: TArgs) => TExec & TArgs;
+  array: <T extends TSchema, TArgs extends TSchemaArguments<Array<StaticSchema<T>>>>(items: T, args?: TArgs) => TSchema<TArray<T>> & NoInfer<TArgs>;
+  boolean: <TArgs extends TSchemaArguments<boolean>>(args?: TArgs) => TSchema<TBoolean> & NoInfer<TArgs>;
+  exec: <const TArgs extends TArguments = {}>(args?: TArgs) => TSchema<TExec> & NoInfer<TArgs>;
   function: typeof createFunction;
-  interface: <T = unknown, TArgs extends TArguments<T> = TArguments<T>>(interfaceClass: (new (...args: Array<unknown>) => T) | string, args?: TArgs) => TInterface<T> & TArgs;
-  number: <TArgs extends TArguments<number>>(args?: TArgs) => TNumber & TArgs;
-  object: <T extends TProperties, TArgs extends TArguments<object>>(properties?: T, args?: TArgs) => TObject<T> & TArgs;
-  record: <TKey extends TRecordKey, TValue extends TSchema, const TArgs extends TArguments<StaticRecord<TKey, TValue>> = {}>(key: TKey, value: TValue, args?: TArgs) => TRecord<TKey, TValue> & TArgs;
-  string: <TArgs extends TArguments<string>>(args?: TArgs) => TString & TArgs;
+  interface: <T = unknown, TArgs extends TSchemaArguments<T> = TSchemaArguments<T>>(interfaceClass: (new (...args: Array<never>) => T) | string, args?: TArgs) => TSchema<TInterface<T>> & NoInfer<TArgs>;
+  intersection: <const T extends ReadonlyArray<TSchema>, const TArgs extends TSchemaArguments<StaticIntersection<T>> = {}>(elements: T, args?: TArgs) => TSchema<TIntersection<T>> & NoInfer<TArgs>;
+  number: <TArgs extends TSchemaArguments<number>>(args?: TArgs) => TSchema<TNumber> & NoInfer<TArgs>;
+  object: <T extends TProperties, TArgs extends TSchemaArguments<object>>(properties?: T, args?: TArgs) => TSchema<TObject<T>> & NoInfer<TArgs>;
+  record: <TKey extends TRecordKey, TValue extends TSchema, const TArgs extends TSchemaArguments<StaticRecord<TKey, TValue>> = {}>(key: TKey, value: TValue, args?: TArgs) => TSchema<TRecord<TKey, TValue>> & NoInfer<TArgs>;
+  string: <const TValue extends string = string, TArgs extends TSchemaArguments<string> = TSchemaArguments<string>>(args?: TArgs & {
+    enum?: TEnum<TValue>;
+  }) => TSchema<TString<TValue>> & NoInfer<TArgs>;
   type: typeof createType;
-  undefined: <const TArgs extends TArguments<undefined> = {}>(args?: TArgs) => TUndefined & TArgs;
-  union: <const T extends ReadonlyArray<TSchema>, const TArgs extends TArguments<StaticUnion<T>> = {}>(elements: T, args?: TArgs) => TUnion<T> & TArgs;
-  unknown: <TArgs extends TArguments>(args?: TArgs) => TUnknown & TArgs;
-  void: <const TArgs extends TArguments<void> = {}>(args?: TArgs) => TVoid & TArgs;
+  undefined: <const TArgs extends TSchemaArguments<undefined> = {}>(args?: TArgs) => TSchema<TUndefined> & NoInfer<TArgs>;
+  union: <const T extends ReadonlyArray<TSchema>, const TArgs extends TSchemaArguments<StaticUnion<T>> = {}>(elements: T, args?: TArgs) => TSchema<TUnion<T>> & NoInfer<TArgs>;
+  unknown: <T = unknown, TArgs extends TSchemaArguments<T> = TSchemaArguments<T>>(args?: TArgs) => TSchema<TUnknown<T>> & NoInfer<TArgs>;
+  void: <const TArgs extends TSchemaArguments<void> = {}>(args?: TArgs) => TSchema<TVoid> & NoInfer<TArgs>;
 };
 type OptionalKeys<T extends TProperties> = { [K in keyof T]: T[K] extends {
   optional: true;
@@ -170,9 +219,11 @@ type RequiredKeys<T extends TProperties> = Exclude<keyof T, OptionalKeys<T>>;
 type StaticSchema<T extends TSchema> = [TSchema] extends [T] ? unknown : T extends {
   static: unknown;
 } ? Static<T> : unknown;
-type StaticObject<T extends TProperties> = string extends keyof T ? Record<string, unknown> : { [K in RequiredKeys<T>]: StaticSchema<T[K]>; } & { [K in OptionalKeys<T>]?: StaticSchema<T[K]>; };
-type StaticRecord<TKey extends TSchema<TRecordKey>, TValue extends TSchema> = Record<StaticSchema<TKey> & (string | number), StaticSchema<TValue>>;
+type StaticObject<T extends TProperties> = string extends keyof T ? Record<string, unknown> : keyof T extends never ? Record<string, unknown> : { [K in RequiredKeys<T>]: StaticSchema<T[K]>; } & { [K in OptionalKeys<T>]?: StaticSchema<T[K]>; };
+type StaticRecord<TKey extends TRecordKey, TValue extends TSchema> = Record<TKey["static"] & (string | number), StaticSchema<TValue>>;
 type StaticUnion<T extends ReadonlyArray<TSchema>> = StaticSchema<T[number]>;
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends ((value: infer TResult) => void) ? TResult : never;
+type StaticIntersection<T extends ReadonlyArray<TSchema>> = UnionToIntersection<StaticSchema<T[number]>>;
 type TStaticParameters<T extends ReadonlyArray<TSchema>> = number extends T["length"] ? Array<StaticSchema<T[number]>> : T extends readonly [...infer TRest extends ReadonlyArray<TSchema>, infer TLast extends TSchema] ? TLast extends {
   optional: true;
 } ? [...TStaticParameters<TRest>, StaticSchema<TLast>?] : [...TStaticParameters<TRest>, StaticSchema<TLast>] : [];
@@ -184,23 +235,30 @@ type TObjectParameters<T extends TObject> = keyof T["properties"] extends never
 type TFunctionPromise<T extends TArguments> = "promise" extends keyof T ? Exclude<T["promise"], undefined> : false;
 declare function createFunction<const TEntries extends TFunctionEntries = [], TOutput extends TSchema = TVoid, const TArgs extends TArguments = {}>(inputs?: TEntries, output?: TOutput, args?: TArgs): TFunction<TObject<TEntryProperties<TEntries>>, TOutput, TFunctionPromise<TArgs>, TEntryParameters<TEntries>> & TArgs;
 declare function createFunction<TInputs extends TObject, TOutput extends TSchema = TVoid, const TArgs extends TArguments = {}>(inputs: TInputs, output?: TOutput, args?: TArgs): TFunction<TInputs, TOutput, TFunctionPromise<TArgs>, TObjectParameters<TInputs>> & TArgs;
-declare function createType<T, const TArgs extends TArguments<T> & {
+declare function createType<T, const TArgs extends TSchemaArguments<T> & {
   optional: true;
-} = TArguments<T> & {
+} = TSchemaArguments<T> & {
   optional: true;
 }>(target: Array<string>, args: TArgs): TType<T> & TArgs;
-declare function createType<T, const TArgs extends TArguments<T> = TArguments<T>>(target: Array<string>, args?: TArgs): TType<T> & TArgs;
+declare function createType<T, const TArgs extends TSchemaArguments<T> = TSchemaArguments<T>>(target: Array<string>, args?: TArgs): TType<T> & TArgs;
 type Static<T extends {
+  nullable?: boolean;
   optional?: boolean;
-  static: unknown;
+  static?: unknown;
 }> = T extends {
   optional: true;
-} ? (T["static"] | undefined) : T["static"];
+} ? (T["static"] | undefined) : T extends {
+  nullable: true;
+} ? (T["static"] | null | undefined) : T["static"];
 type TTransformedObject<TTarget extends TObject, T extends TProperties> = Omit<TTarget, "properties" | "static"> & TObject<T>;
 type TWithOptional<T extends TSchema, TOptional extends boolean> = T extends TSchema ? Omit<T, "optional"> & {
   optional: TOptional;
 } : never;
-type TPartialOptional<T extends TSchema> = T["required"] extends true ? false : true extends T["required"] ? boolean : true;
+type TPartialOptional<T extends TSchema> = T extends {
+  required: true;
+} ? false : T extends {
+  required: boolean;
+} ? (true extends T["required"] ? boolean : true) : true;
 type TPartialProperties<T extends TProperties, TForce extends boolean> = TForce extends true ? { [K in keyof T]: TWithOptional<T[K], TPartialOptional<T[K]>>; } : { [K in keyof T]: TWithOptional<T[K], true>; };
 type TRequiredProperties<T extends TProperties> = { [K in keyof T]: TWithOptional<T[K], false>; };
 type TPickedProperties<T extends TProperties, TKeys extends ReadonlyArray<string>> = number extends TKeys["length"] ? TProperties : Pick<T, Extract<TKeys[number], keyof T>>;
@@ -212,8 +270,6 @@ declare const LogicUtil: {
   promise(target: TSchema): TSchema;
   required<TTarget extends TObject>(target: TTarget): TTransformedObject<TTarget, TRequiredProperties<TTarget["properties"]>>;
 };
-//#endregion
-//#region src/logic/interface.d.ts
 type TInterfaceConstantValue = string | number | boolean | object;
 type TInterfaceConstantConfig<TEditor = unknown> = {
   build?: {
@@ -224,20 +280,18 @@ type TInterfaceConstantConfig<TEditor = unknown> = {
     }>;
   };
   editor?: TEditor;
-  parse?: (value: TInterfaceConstantValue) => unknown;
+  parse?(value: TInterfaceConstantValue): unknown;
   schema?: TSchema;
-  serialize?: (instance: unknown) => TInterfaceConstantValue;
+  serialize?(instance: unknown): TInterfaceConstantValue;
 };
 type TInterfaceConfig<TEditor = unknown> = {
-  class?: new (...args: Array<unknown>) => unknown;
+  class?: new (...args: Array<never>) => unknown;
   constant?: TInterfaceConstantConfig<TEditor>;
   extends?: Array<string>;
   name: string;
 };
-//#endregion
-//#region src/logic/node.d.ts
 type Component = {
-  name: string;
+  name?: string;
 };
 type TNodeInterfaceDescriptor = Record<string, TSchema>;
 declare enum ELogicType {
@@ -290,23 +344,19 @@ type TNodeIOSchema<TInterface extends TNodeInterfaceDescriptor> = { [TKey in key
   schema: TOnlyVarsOf<TInterface>[TKey];
   value: Static<TOnlyVarsOf<TInterface>[TKey]>;
 }; };
-type TNodeOptionals<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = { [TKey in keyof (TOnlyVarsOf<TInputs> | TOnlyVarsOf<TOutputs>)]: boolean; };
+type TNodeOptionals<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = { [TKey in keyof TOnlyVarsOf<TInputs> | keyof TOnlyVarsOf<TOutputs>]: boolean; };
 type TNodeConfigSchema<TConfig extends TNodeConfigDescriptor> = {
   internal?: unknown;
 } & { [TKey in keyof TConfig]: Static<TConfig[TKey]>; };
-type TNodeDynamics<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = {
-  inputs?: (ioSchema: {
-    config: TNodeConfigSchema<TConfig>;
-    inputs: TNodeIOSchema<TInputs>;
-    optionals: TNodeOptionals<TInputs, TOutputs>;
-    outputs: TNodeIOSchema<TOutputs>;
-  }) => Partial<TNodeInterfaceDescriptor>;
-  outputs?: (ioSchema: {
-    config: TNodeConfigSchema<TConfig>;
-    inputs: TNodeIOSchema<TInputs>;
-    optionals: TNodeOptionals<TInputs, TOutputs>;
-    outputs: TNodeIOSchema<TOutputs>;
-  }) => Partial<TNodeInterfaceDescriptor>;
+type TNodeDynamicsSchema<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor, TDynamicInputs extends TNodeInterfaceDescriptor, TDynamicOutputs extends TNodeInterfaceDescriptor> = {
+  config: TNodeConfigSchema<TConfig>;
+  inputs: TNodeIOSchema<TInputs> & Partial<TNodeIOSchema<TDynamicInputs>>;
+  optionals: TNodeOptionals<TInputs & TDynamicInputs, TOutputs & TDynamicOutputs>;
+  outputs: TNodeIOSchema<TOutputs> & Partial<TNodeIOSchema<TDynamicOutputs>>;
+};
+type TNodeDynamics<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor, TDynamicInputs extends TNodeInterfaceDescriptor = {}, TDynamicOutputs extends TNodeInterfaceDescriptor = {}> = {
+  inputs?(ioSchema: TNodeDynamicsSchema<TInputs, TOutputs, TConfig, TDynamicInputs, TDynamicOutputs>): Partial<TNodeInterfaceDescriptor>;
+  outputs?(ioSchema: TNodeDynamicsSchema<TInputs, TOutputs, TConfig, TDynamicInputs, TDynamicOutputs>): Partial<TNodeInterfaceDescriptor>;
 };
 type TDocumentation = {
   description?: string;
@@ -329,99 +379,67 @@ type TDocumentation = {
 };
 type TOnlyExecOf<TNodeInterfaceDescriptor> = { [TAnchor in keyof TNodeInterfaceDescriptor as TNodeInterfaceDescriptor[TAnchor] extends TExec ? TAnchor : never]: TNodeInterfaceDescriptor[TAnchor]; };
 type TOnlyVarsOf<TNodeInterfaceDescriptor> = { [TAnchor in keyof TNodeInterfaceDescriptor as TNodeInterfaceDescriptor[TAnchor] extends TExec ? never : TAnchor]: TNodeInterfaceDescriptor[TAnchor]; };
-type MethodsFrom<TInterface extends TNodeInterfaceDescriptor> = { [TKey in keyof TInterface]: (() => MaybePromise<Static<TInterface[TKey]>>) | {
-  async: () => Promise<Static<TInterface[TKey]>>;
-  sync: () => MaybePromise<Static<TInterface[TKey]>>;
-}; };
-type TMethodsOf<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = MethodsFrom<TOnlyExecOf<TInputs>> & MethodsFrom<TOnlyVarsOf<TOutputs>>;
-type TNodeDescriptor<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = TNodeGenerated<TInputs, TOutputs, TConfig> & ThisType<{ [TKey in keyof TOnlyExecOf<TOutputs>]: (stack?: unknown) => Promise<void>; } & { [TKey in keyof TOnlyVarsOf<TInputs>]: Static<TInputs[TKey]>; } & { [TKey in keyof TOnlyVarsOf<TOutputs>]: Static<TOutputs[TKey]>; } & Record<`internal_${string}`, unknown> & {
+/** A node method, either a plain function or a pair of async/sync implementations. */
+type TNodeMethod<T = unknown> = (() => MaybePromise<T>) | {
+  async: () => Promise<T>;
+  sync: () => MaybePromise<T>;
+};
+type TMethodsFrom<TInterface extends TNodeInterfaceDescriptor> = { [TKey in keyof TInterface]: TNodeMethod<Static<TInterface[TKey]>>; };
+type TMethodsOf<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = TMethodsFrom<TOnlyExecOf<TInputs>> & TMethodsFrom<TOnlyVarsOf<TOutputs>>;
+type TNodeMethods<TInputs extends TNodeInterfaceDescriptor = TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor = TNodeInterfaceDescriptor, TDynamicInputs extends TNodeInterfaceDescriptor = {}, TDynamicOutputs extends TNodeInterfaceDescriptor = {}> = string extends keyof TInputs ? Record<string, TNodeMethod> : Partial<TMethodsOf<TInputs, TOutputs> & TMethodsOf<TDynamicInputs, TDynamicOutputs>>;
+type TExecCallbacksOf<TOutputs extends TNodeInterfaceDescriptor> = { [TKey in keyof TOnlyExecOf<TOutputs>]: (stack?: unknown) => Promise<void>; };
+type TValuesOf<TInterface extends TNodeInterfaceDescriptor> = { [TKey in keyof TOnlyVarsOf<TInterface>]: Static<TInterface[TKey]>; };
+type TNodeThis<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor, TDynamicInputs extends TNodeInterfaceDescriptor = {}, TDynamicOutputs extends TNodeInterfaceDescriptor = {}> = TExecCallbacksOf<TOutputs> & Partial<TExecCallbacksOf<TDynamicOutputs>> & TValuesOf<TInputs> & TValuesOf<TOutputs> & Partial<TValuesOf<TDynamicInputs>> & Partial<TValuesOf<TDynamicOutputs>> & Record<`internal_${string}` | `in_${string}` | `out_${string}`, unknown> & Record<`out_${string}exec`, (stack?: unknown) => Promise<void>> & {
   arguments: Array<unknown>;
   cache: Record<string, unknown>;
-  config: { [TKey in keyof TConfig]: Static<TConfig[TKey]>; };
+  config: TNodeConfigSchema<TConfig>;
   instance: <TValue>(deps: Array<unknown>, factory: () => TValue, key?: string) => TValue;
   properties: Record<string, {
     name: string;
     value: Promise<unknown>;
   }>;
   stack: any;
-}>;
-type TNodeGenerated<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = {
-  build?: {
-    define?: Array<{
-      id: (data: {
-        input?: TOnlyVarsOf<TInputs>;
-      }) => string;
-      values: (data: {
-        input?: TOnlyVarsOf<TInputs>;
-      }) => string;
-    }>;
-    entry?: boolean;
-    generate?: (data: {
-      config?: { [TKey in keyof TConfig]: Static<TConfig[TKey]>; };
-      id?: string;
-      inputKeys: Array<string>;
-      key?: string;
-    }) => string;
-    imports?: Array<{
-      name: string;
-      target: string;
-    }>;
-  };
+};
+type TNodeDescriptor<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor, TDynamicInputs extends TNodeInterfaceDescriptor = {}, TDynamicOutputs extends TNodeInterfaceDescriptor = {}> = TNodeGenerated<TInputs, TOutputs, TConfig, TDynamicInputs, TDynamicOutputs> & ThisType<TNodeThis<TInputs, TOutputs, TConfig, TDynamicInputs, TDynamicOutputs>>;
+type TNodeBuild<TInputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = {
+  define?: Array<{
+    id(data: {
+      input?: TOnlyVarsOf<TInputs>;
+    }): string;
+    values(data: {
+      input?: TOnlyVarsOf<TInputs>;
+    }): string;
+  }>;
+  entry?: boolean;
+  generate?(data: {
+    config: TNodeConfigSchema<TConfig>;
+    id?: string;
+    inputKeys: Array<string>;
+    key?: string;
+  }): string;
+  imports?: Array<{
+    name: string;
+    target: string;
+  }>;
+};
+type TNodeShape<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor, TDynamicInputs extends TNodeInterfaceDescriptor, TDynamicOutputs extends TNodeInterfaceDescriptor> = {
+  build?: TNodeBuild<TInputs, TConfig>;
   config?: TConfig;
   display?: TNodeDisplay;
   documentation?: TDocumentation;
-  dynamics?: TNodeDynamics<TInputs, TOutputs, TConfig>;
+  dynamicInputs?: TDynamicInputs;
+  dynamicOutputs?: TDynamicOutputs;
+  dynamics?: TNodeDynamics<TInputs, TOutputs, TConfig, TDynamicInputs, TDynamicOutputs>;
   inputs: TInputs;
-  methods: Partial<TMethodsOf<TInputs, TOutputs>>;
-  name?: string;
+  methods: TNodeMethods<TInputs, TOutputs, NoInfer<TDynamicInputs>, NoInfer<TDynamicOutputs>>;
   outputs: TOutputs;
   type?: ELogicType;
 };
-type TLogicNode = {
-  build?: {
-    define?: Array<{
-      id: (data: {
-        input?: Record<string, unknown>;
-      }) => string;
-      values: (data: {
-        input?: Record<string, unknown>;
-      }) => string;
-    }>;
-    entry?: boolean;
-    generate?: (options: {
-      config: Record<string, unknown>;
-      id?: string;
-      inputKeys: Array<string>;
-      key: string;
-    }) => string;
-    imports?: Array<{
-      name: string;
-      target: string;
-    }>;
-  };
-  config?: TNodeConfigDescriptor;
-  display?: TNodeDisplay;
-  documentation?: TDocumentation;
-  dynamics?: {
-    inputs?: (ioSchema: {
-      config: Record<string, unknown>;
-      inputs: Record<string, unknown>;
-      optionals: Record<string, boolean>;
-      outputs: Record<string, unknown>;
-    }) => TNodeInterfaceDescriptor;
-    outputs?: (ioSchema: {
-      config: Record<string, unknown>;
-      inputs: Record<string, unknown>;
-      optionals: Record<string, boolean>;
-      outputs: Record<string, unknown>;
-    }) => TNodeInterfaceDescriptor;
-  };
-  inputs: TNodeInterfaceDescriptor;
-  methods: Record<string, () => unknown>;
+type TNodeGenerated<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor, TDynamicInputs extends TNodeInterfaceDescriptor = {}, TDynamicOutputs extends TNodeInterfaceDescriptor = {}> = TNodeShape<TInputs, TOutputs, TConfig, TDynamicInputs, TDynamicOutputs> & {
+  name?: string;
+};
+type TLogicNode<TInputs extends TNodeInterfaceDescriptor = TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor = TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor = TNodeConfigDescriptor, TDynamicInputs extends TNodeInterfaceDescriptor = TNodeInterfaceDescriptor, TDynamicOutputs extends TNodeInterfaceDescriptor = TNodeInterfaceDescriptor> = TNodeShape<TInputs, TOutputs, TConfig, TDynamicInputs, TDynamicOutputs> & {
   name: string;
-  outputs: TNodeInterfaceDescriptor;
-  type?: ELogicType;
 };
-declare function makeLogicNode<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor>(node: TNodeDescriptor<TInputs, TOutputs, TConfig>): TLogicNode;
-//#endregion
+declare function makeLogicNode<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor, TDynamicInputs extends TNodeInterfaceDescriptor = {}, TDynamicOutputs extends TNodeInterfaceDescriptor = {}>(node: TNodeDescriptor<TInputs, TOutputs, TConfig, TDynamicInputs, TDynamicOutputs>): TLogicNode<TInputs, TOutputs, TConfig, NoInfer<TDynamicInputs>, NoInfer<TDynamicOutputs>>;
 export { TVector as _, LogicUtil as a, TInterfaceConstantValue as c, TSchema as d, TVoid as f, MaybePromise as g, DeepPartial as h, LogicType as i, TLogicNode as l, CVector as m, ELogicType as n, Static as o, makeLogicNode as p, EVarType as r, TInterfaceConfig as s, ELogicScope as t, TObject as u };