@luna-park/plugin 1.3.1 → 1.4.1

package/dist/index.d.mts

@@ -0,0 +1,941 @@
+import { a as LogicUtil, c as TObject, d as makeLogicNode, f as CVector, h as TVector, i as LogicType, l as TSchema, m as MaybePromise, n as ELogicType, o as Static, p as DeepPartial, r as EVarType, s as TLogicNode, t as ELogicScope, u as TVoid } from "./index-X3hhfmWd.mjs";
+import * as _$vue from "vue";
+import { Component, ComputedRef } from "vue";
+import { IconDefinition } from "@fortawesome/fontawesome-svg-core";
+import { PGliteWorker } from "@electric-sql/pglite/worker";
+import { Cron } from "lite-cron";
+
+//#region src/components/LSettingsStoryWrapper.vue.d.ts
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: _$vue.DefineComponent<{}, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/types/component.d.ts
+type TSlot = TSchema<TObject> | TSchema<TVoid>;
+type StaticOfProps<T extends Record<string, TSchema>> = { [K in keyof T]: {
+  schema: TSchema;
+  value: Static<T[K]>;
+} };
+type TComponent<TProps extends Record<string, TSchema> = Record<string, TSchema>, TInternals = unknown> = {
+  build?: {
+    imports?: Array<{
+      default?: boolean;
+      from: string;
+      name: string;
+    }>;
+    name?: string;
+  };
+  component: Component;
+  documentation?: {
+    description?: string;
+    link?: string;
+  };
+  emits?: Record<string, TSchema>;
+  icon?: IconDefinition | string;
+  internals?: TInternals;
+  models?: Record<string, TSchema>;
+  name: string;
+  preview?: {
+    properties?: Partial<{ [TKey in keyof TProps]: Static<TProps[TKey]> }>;
+    slots?: Record<string, string>;
+    style?: string;
+  };
+  properties?: TProps;
+  slots?: Record<string, TSlot> | ((attributes: StaticOfProps<TProps> & {
+    internals: TInternals;
+  }) => Record<string, TSlot>);
+};
+//#endregion
+//#region src/types/hooks.d.ts
+declare enum EPluginHooks {
+  BackendMiddleware = "backend/middleware",
+  BackendInputNode = "backend/input-node"
+}
+type THookParams = {
+  [EPluginHooks.BackendMiddleware]: {
+    cookies: Record<string, {
+      options?: Record<string, unknown>;
+      value: string;
+    }>;
+    setContextVar: (key: string, value: unknown) => void;
+  };
+  [EPluginHooks.BackendInputNode]: {
+    addInput: (key: string, schema: TSchema) => void;
+  };
+};
+//#endregion
+//#region ../shared/dist/layout-w4K7EDPE.d.mts
+declare enum ELayoutElement {
+  input = "input",
+  div = "div",
+  media = "media",
+  customText = "customText",
+  component = "component",
+  package = "package",
+  customHtml = "customHtml",
+  slot = "slot",
+  template = "template",
+  variable = "variable",
+  link = "link"
+}
+declare enum ELayoutEvent {
+  click = "click",
+  keydown = "keydown",
+  mouseenter = "mouseenter",
+  mouseleave = "mouseleave",
+  mousedown = "mousedown",
+  mouseup = "mouseup",
+  mousemove = "mousemove",
+  wheel = "wheel"
+}
+//#endregion
+//#region src/layout/template.d.ts
+declare enum EElementTemplate {
+  If = "if",
+  For = "for"
+} //#endregion
+//#endregion
+//#region ../logic-dts/dist/nodes.d.ts
+type TExportNodeFunction = {
+  name?: string;
+  description?: string;
+  parameters?: Array<TSchema>;
+  return?: TSchema;
+};
+type TExportNodeResult = {
+  components: Record<string, {
+    properties: Record<string, TSchema>;
+    slots: Record<string, TSchema>;
+  }>;
+  functions: Record<string, TExportNodeFunction>;
+  types: Record<string, TSchema>;
+};
+//#endregion
+//#region ../shared/dist/index.d.mts
+//#endregion
+//#region src/types/editor/node.d.ts
+type TBaseNode = {
+  id: string;
+  data?: object;
+  dbNode: TGeneratedNode;
+  inputs: Record<string, CNodeAnchor>;
+  location: TVector;
+  outputs: Record<string, CNodeAnchor>;
+};
+type TGeneratedNode<TLogic extends TLogicNode = TLogicNode> = TLogic & {
+  node?: CNode;
+  origin: TLogic;
+  proxy: any;
+};
+type TNodeData = {
+  config?: Record<string, unknown>;
+  multiple?: {
+    isArray?: boolean;
+    number: number;
+  };
+  optionals?: Record<string, boolean>;
+  size?: TVector;
+} & Record<string, unknown>;
+declare class CNode {
+  id: string;
+  dbNode: TGeneratedNode;
+  element?: HTMLElement;
+  invert: boolean;
+  parent?: TAnyLogic;
+  config: {
+    animate: boolean;
+    processing: boolean;
+  };
+  inputs: Record<string, CNodeAnchor>;
+  outputs: Record<string, CNodeAnchor>;
+  cache: {
+    location?: CVector;
+    relativeLocation?: CVector;
+    reloadKey: number;
+    size?: CVector;
+  };
+  _data: TNodeData;
+  constructor(node: TBaseNode);
+  get orderedInputs(): Array<CNodeAnchor>;
+  get orderedOutputs(): Array<CNodeAnchor>;
+  set location(location: TVector);
+  get location(): TVector;
+  reload(): void;
+  getSafeInputs(): Record<string, CNodeAnchor>;
+  getSafeOutputs(): Record<string, CNodeAnchor>;
+  set data(data: Record<string, unknown>);
+  get data(): TNodeData;
+  reset(): void;
+  setLocation(location: TVector): CNode;
+  getAnchorLocation(anchor: CNodeAnchor): CVector;
+  getRelativeAnchorLocation(anchor: CNodeAnchor): CVector;
+  getRelativeAnchorLocation_internal(anchor: CNodeAnchor): CVector;
+  getLocation(): CVector;
+  getSize(): TVector;
+  execute(outputKey: string, stack?: TStack): MaybePromise<void>;
+  get isAsync(): boolean;
+  getInput(inputKey: string, stack?: TStack): unknown;
+  setOutput(outputKey: string, value: unknown, stack?: TStack): void;
+}
+type TNode<TExport extends boolean = false> = TExport extends true ? {
+  data?: Record<string, unknown>;
+  internal?: {
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+  };
+  location: TVector;
+  logic: string;
+} : CNode; //#endregion
+//#region src/types/editor/wire.d.ts
+declare class CPathPoint {
+  direction: CVector;
+  location: CVector;
+  constructor({
+    direction,
+    location
+  }: {
+    direction: TVector;
+    location: TVector;
+  });
+  move(offset: TVector, config?: {
+    reverse: boolean;
+  }): CPathPoint;
+}
+type Path = Array<CPathPoint>;
+declare class CWire {
+  id: string;
+  from: CAnchor;
+  to: CAnchor;
+  animate: boolean;
+  constructor(wire: {
+    id: string;
+    from: CAnchor;
+    temp?: boolean;
+    to: CAnchor;
+  });
+  get type(): TSchema;
+  get toType(): TSchema;
+  getPoints(): string;
+  registerRibbon(path: Path): void;
+}
+type TWire<TExport extends boolean = false> = TExport extends true ? {
+  from: {
+    key: string;
+    node: string;
+  };
+  to: {
+    key: string;
+    node: string;
+  };
+} : CWire; //#endregion
+//#region src/types/editor/anchor.d.ts
+type TDBAnchor = {
+  id?: string;
+  schema: TSchema;
+};
+declare enum EAnchorDirection {
+  input = "input",
+  output = "output",
+  none = "none"
+}
+declare class CAnchor {
+  connections: Array<CWire>;
+  dbAnchor: TDBAnchor;
+  padding?: number;
+  protected constructor(anchor: {
+    connections?: Array<CWire>;
+    dbAnchor: TDBAnchor;
+    padding?: number;
+  });
+  getLocation(): TVector;
+  getPadding(): number;
+  get schema(): TSchema;
+  get schemaRaw(): TSchema;
+  get toSchema(): TSchema;
+}
+declare class CNodeAnchor extends CAnchor {
+  key: string;
+  index: number;
+  node: CNode;
+  direction: EAnchorDirection;
+  value: unknown;
+  element?: HTMLElement;
+  cache: {
+    preview?: unknown;
+    relativeLocation?: CVector;
+  };
+  constructor(anchor: {
+    connections?: Array<CWire>;
+    dbAnchor: TDBAnchor;
+    direction: EAnchorDirection;
+    element?: HTMLElement;
+    index: number;
+    key: string;
+    node: CNode;
+    padding?: number;
+  });
+  get schema(): TSchema;
+  get toSchema(): TSchema;
+  get schemaRaw(): TSchema;
+  getLocation(): CVector;
+  getRelativeLocation(): CVector;
+  resetCache(): void;
+  getPadding(): number;
+  isDisabled(): boolean;
+  errorMessage(): string | undefined;
+  setValue(value: string | number | boolean): void;
+  resetValue(): void;
+} //#endregion
+//#region src/types/file.d.ts
+declare enum EElementType {
+  Script = "script",
+  Standalone = "standalone",
+  Folder = "folder",
+  MainLogic = "main",
+  Logic = "logic",
+  Config = "config",
+  Text = "text",
+  Store = "store",
+  Database = "database",
+  Component = "component",
+  Route = "route",
+  Type = "type",
+  Cron = "cron",
+  Media = "media"
+}
+/**
+ * Check if the source scope is compatible with the target scope
+ * @param source - The source scope (from)
+ * @param target - The target scope (to)
+ */
+//#endregion
+//#region src/types/files/folder.d.ts
+type TFolder<TExport extends boolean = false> = TFileBase<TExport> & {
+  type: EElementType.Folder;
+  children: Record<string, TFile<TExport>>;
+  color?: string;
+}; //#endregion
+//#region src/types/files/common.d.ts
+type TFileState = {
+  expand?: boolean;
+  isEditing?: boolean;
+  logic?: {
+    location: TVector;
+    zoom: number;
+  };
+  opened?: boolean;
+  panel?: string;
+};
+type TFileBase<TExport extends boolean = false> = {
+  name: string;
+  state: TFileState;
+} & (TExport extends false ? {
+  id: string;
+  parent?: TFolder<TExport>;
+} : {}); //#endregion
+//#region src/types/files/database.d.ts
+type TFileDatabase<TExport extends boolean = false> = TFileBase<TExport> & {
+  type: EElementType.Database;
+  data: Array<Record<string, unknown>>;
+  schema: TSchema<TObject>;
+} & (TExport extends false ? {
+  db: CDatabase;
+  scope: ELogicScope.Backend;
+} : {}); //#endregion
+//#region src/types/editor/database.d.ts
+type TQueryValue = string | number | boolean;
+type TQueryOperation = Record<string, {
+  $eq?: TQueryValue;
+  $exists?: boolean;
+  $gt?: TQueryValue;
+  $gte?: TQueryValue;
+  $ilike?: string;
+  $in?: Array<TQueryValue>;
+  $like?: string;
+  $lt?: TQueryValue;
+  $lte?: TQueryValue;
+  $neq?: TQueryValue;
+  $nin?: Array<TQueryValue>;
+}>;
+type TQuery = TQueryOperation | {
+  $and?: Array<TQuery>;
+  $not?: TQuery;
+  $or?: Array<TQuery>;
+};
+type TQueryOptions = {
+  limit?: number;
+  offset?: number;
+  order?: Array<TOrder>;
+};
+type TOrder = {
+  column: string;
+  direction: "asc" | "desc";
+};
+declare class CDatabase {
+  file: TFileDatabase;
+  db: PGliteWorker;
+  ready: boolean;
+  exist: boolean;
+  constructor(file: TFileDatabase);
+  init(): Promise<void>;
+  findById(id: string): Promise<Record<string, unknown> | undefined>;
+  find(filter: Record<string, unknown>): Promise<Array<Record<string, unknown>>>;
+  findWithQuery(query: TQuery, options?: TQueryOptions): Promise<Array<Record<string, unknown>>>;
+  updateById(id: string, data: Record<string, unknown>): Promise<void>;
+  update(filter: Record<string, unknown>, data: Record<string, unknown>): Promise<void>;
+  updateWithQuery(query: TQuery, data: Record<string, unknown>): Promise<void>;
+  deleteById(id: string): Promise<Record<string, unknown> | undefined>;
+  delete(filter: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+  deleteWithQuery(query: TQuery): Promise<Record<string, unknown> | undefined>;
+  insert(data: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+  toRealKey(row: Record<string, unknown>): Record<string, unknown>;
+  toSchemaKey(row: Record<string, unknown>): Record<string, unknown>;
+  updateColumns(init: boolean): Promise<void>;
+  save(): Promise<Array<Record<string, unknown>> | unknown>;
+  load(): Promise<void>;
+  getUpdate(data: Record<string, unknown>): unknown;
+  getQueryFilter(filter: Record<string, unknown>): unknown;
+  getQueryOptions(options?: TQueryOptions): unknown;
+  getQuery(query: TQuery): unknown;
+  getOperation(query: TQueryOperation): unknown;
+} //#endregion
+//#region src/types/editor/stack.d.ts
+type TStackParent = {
+  logic?: TLogic;
+  node?: CNode;
+  stack: TStack;
+};
+type TStack = {
+  id: string;
+  config?: Record<string, unknown>;
+  context: object;
+  parent?: TStackParent;
+  variables: Record<string, unknown>;
+}; //#endregion
+//#region src/types/logic.d.ts
+declare enum ELogicMode {
+  Pure = "pure",
+  Macro = "macro",
+  Code = "code"
+}
+type TLogicBase<TExport extends boolean = false> = {
+  name: string;
+  type: EElementType;
+  graph: TGraph<TExport>;
+  values: {
+    variables: Record<string, TValue<TExport>>;
+  };
+} & (TExport extends false ? {
+  id: string;
+  db: Record<string, TLogicNode>;
+  isEditing?: boolean;
+  parent: TFile<TExport>;
+} : {});
+type TLogic<TExport extends boolean = false> = TLogicBase<TExport> & {
+  type: EElementType.Logic | EElementType.Standalone;
+  async: boolean;
+  code?: string;
+  export: boolean;
+  inputs: Record<string, TAnchor<TExport>>;
+  mode: ELogicMode;
+  outputs: Record<string, TAnchor<TExport>>;
+  packages?: Array<string>;
+} & (TExport extends false ? {
+  id: string;
+} : {});
+type TLogicMain<TExport extends boolean = false> = TLogicBase<TExport> & {
+  name: "Main";
+  type: EElementType.MainLogic;
+} & (TExport extends false ? {
+  id: "main";
+} : {});
+type TCanvas = {
+  location: TVector;
+  zoom: number;
+};
+type TGraph<TExport extends boolean = false> = {
+  canvas: TCanvas;
+  nodes: Record<string, TNode<TExport>>;
+  wires: Record<string, TWire<TExport>>;
+};
+type TAnchor<TExport extends boolean = false> = TExport extends true ? TSchema : {
+  id: string;
+  parent?: TLogic<TExport>;
+  schema: TSchema;
+};
+type TAnyLogic<TExport extends boolean = false> = TLogic<TExport> | TLogicMain<TExport>; //#endregion
+//#region src/types/value.d.ts
+declare enum ELayoutValueType {
+  variable = "variable",
+  property = "property",
+  attribute = "attribute",
+  context = "context",
+  computed = "computed",
+  event = "event",
+  file = "file",
+  model = "model",
+  logic = "logic"
+}
+type TContextValue = {
+  schema: TSchema;
+  value: unknown;
+};
+type TLayoutContext = Record<string, TContextValue>;
+type TLayoutValue<TExport extends boolean = false> = {
+  id: string;
+  type?: ELayoutValueType;
+  baseType?: ELayoutValueType;
+  child: Array<string>;
+  component: TFileComponent<TExport>;
+  context: TLayoutContext;
+  stackId: string;
+  get value(): unknown;
+  set value(value: unknown);
+  get schema(): TSchema;
+  get baseSchema(): TSchema;
+}; //#endregion
+//#region src/types/variable.d.ts
+declare enum EDynamicVariableType {
+  Constant = "constant",
+  Dynamic = "dynamic",
+  Token = "token"
+}
+declare enum EDynamicVariableOperation {
+  Equal = "equal",
+  Greater = "greater",
+  Less = "less",
+  StartsWith = "starts-with",
+  EndsWith = "ends-with",
+  Contains = "contains"
+}
+type TBaseDynamicVariable<TExport extends boolean = false> = {
+  type: EDynamicVariableType;
+  _dynamic: true;
+  access: Array<string>;
+  target: {
+    invert?: boolean;
+    operation: EDynamicVariableOperation;
+    variable?: TDynamicVariable<TExport>;
+  };
+  token: string;
+  value: unknown;
+};
+type TDynamicVariable<TExport extends boolean = false> = (TExport extends true ? TBaseDynamicVariable<TExport> : TBaseDynamicVariable<TExport> & {
+  getComputed(component: TFileComponent, options: {
+    context?: TLayoutContext;
+    stackId?: string;
+  }): ComputedRef<TContextValue | TLayoutValue>;
+  getValue(component: TFileComponent, options: {
+    base?: boolean;
+    context?: TLayoutContext;
+    stackId?: string;
+  }): TContextValue;
+  getRawValue(): unknown;
+  toJSON(): unknown;
+}) | unknown;
+type TValue<TExport extends boolean = false> = TExport extends false ? {
+  id: string;
+  isEditing?: boolean;
+  parent?: TLogic<TExport>;
+  schema: TSchema;
+} : TSchema; //#endregion
+//#region src/types/layout.d.ts
+type TTextBlock = {
+  content: string;
+  key: string;
+};
+type TLayoutContentType<TElement extends ELayoutElement, TExport extends boolean = false> = TElement extends ELayoutElement.variable ? {
+  var: TDynamicVariable | unknown;
+} : TElement extends ELayoutElement.component ? {
+  id: string;
+  slot: boolean;
+  slots: Record<string, TLayoutSchema<TElement, TExport>>;
+} : TElement extends ELayoutElement.customText ? {
+  text: TTextBlock;
+  variables: Array<string>;
+} : TElement extends ELayoutElement.customHtml ? {
+  html: string;
+  variables: Array<string>;
+} : TElement extends ELayoutElement.template ? {
+  preview: string;
+  template: EElementTemplate;
+  var: TDynamicVariable | unknown;
+} : TElement extends ELayoutElement.package ? {
+  slot: boolean;
+  slots: Record<string, TLayoutSchema<TElement, TExport>>;
+  target: Array<string>;
+} : Record<string, unknown>;
+type TLayoutSchema<TElement extends ELayoutElement = ELayoutElement, TExport extends boolean = false> = { [TInnerElement in TElement]: {
+  id: string;
+  name: string;
+  children: Array<TLayoutSchema<ELayoutElement, TExport>>;
+  classes: Array<TDynamicVariable<TExport>>;
+  collapsed?: boolean;
+  component: TFileComponent<TExport>;
+  content: TLayoutContentType<TInnerElement>;
+  element: TInnerElement;
+  events: Array<ELayoutEvent | string>;
+  model?: Array<string>;
+  properties: Record<string, TDynamicVariable<TExport>>;
+  style: { [key in "base" | string]: { [key in "default" | "hover"]: { [key in string]: TDynamicVariable<TExport> } } } & {
+    quick?: Array<string>;
+  };
+  tag?: string;
+} }[TElement] & (TExport extends false ? {
+  parent?: TLayoutSchema<ELayoutElement, TExport>;
+} : {}); //#endregion
+//#region src/types/files/component.d.ts
+declare enum EComponentType {
+  Component = "component",
+  Page = "page"
+}
+declare enum EComponentPreview {
+  Compact = "compact",
+  Stretch = "stretch",
+  Full = "full"
+}
+type TComponentOptions = {
+  type: EComponentType;
+  path: string;
+  preview: EComponentPreview;
+  previewSize: string;
+};
+type TFileComponent<TExport extends boolean = false> = TFileBase<TExport> & {
+  type: EElementType.Component;
+  collapsed?: boolean;
+  layout: TLayoutSchema<ELayoutElement, TExport>;
+  logics: Record<string, TLogic<TExport> | TLogicMain<TExport>>;
+  options: TComponentOptions;
+  values: {
+    computed: Record<string, TValue<TExport>>;
+    events: Record<string, TValue<TExport>>;
+    model?: TSchema;
+    properties: Record<string, TValue<TExport>>;
+    variables: Record<string, TValue<TExport>>;
+  };
+} & (TExport extends false ? {
+  flat: Record<string, TLayoutSchema>;
+} : {}); //#endregion
+//#region src/types/files/config.d.ts
+type TFileConfig<TExport extends boolean = false> = TFileBase<TExport> & {
+  type: EElementType.Config;
+  content: unknown;
+  display: EConfigDisplay;
+  schema: TSchema;
+  scope: ELogicScope;
+};
+declare enum EConfigDisplay {
+  Smart = "smart",
+  Performance = "performance"
+} //#endregion
+//#region src/types/files/cron.d.ts
+type TFileCron<TExport extends boolean = false> = TFileBase<TExport> & {
+  type: EElementType.Cron;
+  active: boolean;
+  editorTrigger: boolean;
+  logics: Record<string, TAnyLogic<TExport>>;
+  time: string;
+} & (TExport extends false ? {
+  cron?: Cron;
+  scope: ELogicScope.Backend;
+} : {}); //#endregion
+//#region src/types/files/media.d.ts
+type TFileMedia<TExport extends boolean = false> = TFileBase<TExport> & {
+  type: EElementType.Media;
+  mimeType: string;
+  target: string;
+}; //#endregion
+//#region src/types/files/route.d.ts
+declare enum ERouteMethod {
+  Get = "get",
+  Post = "post",
+  Put = "put",
+  Delete = "delete"
+}
+type TFileRoute<TExport extends boolean = false> = TFileBase<TExport> & {
+  type: EElementType.Route;
+  dev?: boolean;
+  input: {
+    body: TSchema;
+    headers: TSchema;
+    query: TSchema;
+  };
+  logics: Record<string, TAnyLogic<TExport>>;
+  method: ERouteMethod;
+  output: TSchema;
+  path: string;
+} & (TExport extends false ? {
+  scope: ELogicScope.Backend;
+} : {}); //#endregion
+//#region src/types/files/script.d.ts
+type TFileScript<TExport extends boolean = false> = TFileBase<TExport> & {
+  type: EElementType.Script;
+  logics: Record<string, TAnyLogic<TExport>>;
+  options?: {
+    autoReload?: boolean;
+  };
+  scope: ELogicScope;
+}; //#endregion
+//#region src/types/files/store.d.ts
+declare enum EStoreType {
+  Memory = "memory",
+  Session = "session",
+  Local = "local"
+}
+type TStoreOptions = {
+  type: EStoreType;
+};
+type TFileStore<TExport extends boolean = false> = TFileBase<TExport> & {
+  type: EElementType.Store;
+  default: unknown;
+  logics: Record<string, TLogic<TExport>>;
+  options: TStoreOptions;
+  schema: TSchema;
+} & (TExport extends false ? {
+  proxy: TSchema;
+  scope: ELogicScope.Frontend;
+  value: Record<string, unknown>;
+} : {}); //#endregion
+//#region src/types/files/text.d.ts
+type TFileText<TExport extends boolean = false> = TFileBase<TExport> & {
+  type: EElementType.Text;
+  blocks: Array<{
+    content: string;
+    key: string;
+  }>;
+} & (TExport extends false ? {
+  scope: ELogicScope.Frontend;
+} : {}); //#endregion
+//#region src/types/files/type.d.ts
+type TFileType<TExport extends boolean = false> = TFileBase<TExport> & {
+  name: string;
+  type: EElementType.Type;
+  schemas: Record<string, TSchema>;
+} & (TExport extends false ? {
+  scope: ELogicScope.Shared;
+} : {}); //#endregion
+//#region src/types/files/index.d.ts
+type TApplication<TExport extends boolean = false> = {
+  name: string;
+  config: TApplicationConfig;
+  tree: TFile<TExport>;
+  version: number;
+};
+declare enum EHistoryMode {
+  Hash = "hash",
+  Web = "web",
+  Memory = "memory"
+}
+declare enum EResponsiveStrategy {
+  DesktopFirst = "desktop-first",
+  MobileFirst = "mobile-first"
+}
+declare enum EFileSortStrategy {
+  Name = "name",
+  Type = "type"
+}
+type TApplicationConfig = {
+  backend: {
+    proxy: string;
+    salt: string;
+  };
+  database: {
+    type: string;
+  };
+  description?: string;
+  desktop: {
+    fullscreen: boolean;
+    height: number;
+    resizable: boolean;
+    version: string;
+    width: number;
+  };
+  libraries: Record<string, boolean>;
+  packages: Record<string, {
+    name: string;
+    components: TExportNodeResult["components"];
+    description?: string;
+    functions: TExportNodeResult["functions"];
+    types: TExportNodeResult["types"];
+  }>;
+  palette: {
+    inject: {
+      css: string;
+      head: string;
+      html: string;
+      js: string;
+    };
+    tokens: {
+      colors: Array<{
+        id: string;
+        name: string;
+        value: string;
+      }>;
+      fonts: Array<{
+        id: string;
+        name: string;
+        value: string;
+      }>;
+      lengths: Array<{
+        id: string;
+        name: string;
+        value: string;
+      }>;
+    };
+  };
+  plugins: Record<string, {
+    config?: unknown;
+    internals?: unknown;
+    target: string;
+  }>;
+  state: {
+    currentTab: string;
+    explorerSort: EFileSortStrategy;
+    tabs: Array<string>;
+  };
+  style: {
+    strategy: EResponsiveStrategy;
+  };
+  web: {
+    history: EHistoryMode;
+    pwa: boolean;
+  };
+};
+type TFile<TExport extends boolean = false> = (TFolder<TExport> | TFileComponent<TExport> | TFileConfig<TExport> | TFileCron<TExport> | TFileDatabase<TExport> | TFileRoute<TExport> | TFileScript<TExport> | TFileStore<TExport> | TFileText<TExport> | TFileType<TExport> | TFileMedia<TExport>) & {
+  isEditing?: boolean;
+};
+//#endregion
+//#region src/types/interface.d.ts
+type TInterface = {
+  arguments?: Array<TSchema>;
+  class?: new (...args: Array<unknown>) => unknown;
+  methods?: Array<{
+    name: string;
+    parameters?: Array<TSchema>;
+    return: TSchema;
+  }>;
+  name: string;
+};
+//#endregion
+//#region src/types/template.d.ts
+type TTemplate = {
+  name: string;
+  preview?: string;
+  template: TFile<true>;
+};
+//#endregion
+//#region src/types/token.d.ts
+declare enum ETokenType {
+  Color = "color",
+  FontSize = "font-size",
+  FontWeight = "font-weight",
+  FontFamily = "font-family",
+  Length = "length",
+  Time = "time"
+}
+type TToken = {
+  id: string;
+  name?: string;
+  type: ETokenType;
+  value: string;
+};
+//#endregion
+//#region src/types/plugin.d.ts
+declare enum EInjectionKey {
+  ViteImport = "viteImport",
+  VitePlugin = "vitePlugin",
+  AppImport = "appImport",
+  AppBody = "appBody",
+  AppSetup = "appSetup",
+  Style = "style",
+  ServerImport = "serverImport",
+  ServerBody = "serverBody"
+}
+type TBasePlugin<TConfig extends TSchema = TSchema, TInternals = unknown> = {
+  build?: {
+    backImports?: Array<{
+      name: string;
+      version?: string;
+    }>;
+    frontImports?: Array<{
+      name: string;
+      version?: string;
+    }>;
+    injections?: Partial<Record<EInjectionKey, string>>;
+  };
+  color?: string;
+  config?: TConfig;
+  dependencies?: Array<{
+    id: string;
+    name: string;
+    target: string;
+  }>;
+  description?: string;
+  editor?: {
+    components?: Array<TComponent>;
+    interfaces?: Array<TInterface>;
+    nodes?: Array<TLogicNode>;
+    templates?: Array<TTemplate>;
+    tokens?: Array<TToken>;
+    wrapper?: TComponent & {
+      attributes?: Record<string, unknown>;
+    };
+  };
+  hooks?: { [THook in EPluginHooks]?: (params: THookParams[THook]) => MaybePromise<void> };
+  icon: string;
+  id: string;
+  inject?: {
+    css?: string;
+    js?: string;
+  };
+  interface?: Component;
+  internals?: TInternals;
+  lifecycle?: {
+    mount?: (env: TEnv<TConfig, TInternals>) => Promise<void> | void;
+    unmount?: (env: TEnv<TConfig, TInternals>) => Promise<void> | void;
+    update?: (env: TEnv<TConfig, TInternals>) => Promise<void> | void;
+  };
+  name: string;
+  settings?: Array<{
+    component: Component;
+    icon?: IconDefinition | string;
+    label: string;
+  }>;
+  windows?: Record<string, Component>;
+};
+type TPlugin<TConfig extends TSchema = TSchema, TInternal = unknown, TBase extends TBasePlugin<TConfig, TInternal> = TBasePlugin<TConfig, TInternal>> = Omit<TBase, "build" | "editor" | "inject"> & { [TCategory in "build" | "editor" | "inject"]?: { [TKey in keyof NonNullable<TBase[TCategory]>]: TOption<TEnv<TConfig, TInternal>, NonNullable<TBase[TCategory]>[TKey]> } };
+type TProxyPlugin<TConfig extends TSchema = TSchema, TInternal = unknown, TBase extends TBasePlugin<TConfig, TInternal> = TBasePlugin<TConfig, TInternal>> = Omit<TBase, "build" | "editor" | "inject"> & { [TCategory in "build" | "editor" | "inject"]?: { [TKey in keyof NonNullable<TBase[TCategory]>]: Promise<NonNullable<TBase[TCategory]>[TKey]> } };
+type TEnv<TConfig extends TSchema = TSchema, TInternals = unknown> = {
+  addFile: (file: DeepPartial<TFile<true>> & {
+    type: EElementType;
+  }, parentId?: string) => TFile;
+  app: TApplication;
+  backend: {
+    cookies: Record<string, {
+      options?: Record<string, string>;
+      value: string;
+    }>;
+  };
+  config: Static<TConfig>;
+  getFile: (id: string) => TFile | undefined;
+  internals: TInternals;
+  mode: "build" | "editor";
+};
+type TOption<TParams = unknown, TResult = unknown> = TResult | ((env: TParams) => Promise<TResult> | TResult);
+//#endregion
+//#region src/index.d.ts
+declare function makePlugin<TConfig extends TSchema, TInternal>(plugin: TPlugin<TConfig, TInternal>): TPlugin<TConfig, TInternal>;
+declare function makeComponent<TProps extends Record<string, TSchema>>(component: TComponent<TProps>): TComponent<TProps>;
+declare function loadPlugin<TConfig extends TSchema, TInternal>(plugin: TPlugin<TConfig, TInternal>, env: Partial<TEnv>): Promise<TBasePlugin<TConfig, TInternal>>;
+declare function getPluginParam<T>(target: TOption<TEnv, T>, env: Partial<TEnv>): Promise<T>;
+//#endregion
+export { EElementType, EInjectionKey, ELogicScope, ELogicType, EPluginHooks, ETokenType, EVarType, _default as LSettingsStoryWrapper, LogicType, LogicUtil, type Static, type TAnyLogic, type TApplication, type TBasePlugin, type TComponent, type TEnv, type TFile, type TFileComponent, type TFileConfig, type TFileCron, type TFileDatabase, type TFileMedia, type TFileRoute, type TFileScript, type TFileStore, type TFileText, type TFileType, type TFolder, type THookParams, type TLogic, type TLogicMain, type TLogicNode, type TOption, type TPlugin, type TProxyPlugin, type TSchema, type TSlot, type TTemplate, type TToken, getPluginParam, loadPlugin, makeComponent, makeLogicNode, makePlugin };