@pipelab/shared 2.0.1-beta.20

package/dist/index.d.mts

@@ -0,0 +1,3603 @@
+/// <reference types="node" />
+import * as valibot from "valibot";
+import { GenericSchema, InferInput, InferOutput } from "valibot";
+import { ILogObjMeta, Logger } from "tslog";
+import { RELEASE_SYNC, newVariant } from "quickjs-emscripten";
+import * as _supabase_supabase_js0 from "@supabase/supabase-js";
+import { User, UserResponse } from "@supabase/supabase-js";
+import { ConditionalPick, Simplify, Tagged } from "type-fest";
+import { WebSocket } from "ws";
+import { IncomingMessage as IncomingMessage$1 } from "http";
+
+//#region src/config/migrators.d.ts
+interface Migrator<T> {
+  migrate: (data: any, options?: any) => Promise<T>;
+  defaultValue: T;
+}
+//#endregion
+//#region ../../node_modules/electron/electron.d.ts
+declare module 'electron' {
+  export = Electron.CrossProcessExports;
+}
+declare module 'electron/main' {
+  export = Electron.Main;
+}
+declare module 'electron/common' {
+  export = Electron.Common;
+}
+declare module 'electron/renderer' {
+  export = Electron.Renderer;
+}
+declare module 'electron/utility' {
+  export = Electron.Utility;
+}
+declare module 'original-fs' {
+  import * as fs from 'fs';
+  export = fs;
+}
+declare module 'node:original-fs' {
+  import * as fs from 'fs';
+  export = fs;
+}
+//#endregion
+//#region src/plugins/definitions.d.ts
+type PathOptions = {
+  filter?: RegExp;
+  type?: "file" | "folder";
+};
+type PropType = "string" | "number" | "boolean" | "array" | {
+  type: "array";
+  of: PropType;
+} | "any" | PropType[];
+interface ControlTypeBase {
+  type: string;
+}
+interface ControlTypeInput extends ControlTypeBase {
+  type: "input";
+  options: {
+    kind: "number" | "text";
+    validator?: string;
+    placeholder?: string;
+    password?: boolean;
+  };
+}
+interface ControlTypeExpression extends ControlTypeBase {
+  type: "expression";
+  options: {};
+}
+interface ControlTypeNetlifySite extends ControlTypeBase {
+  type: "netlify-site";
+  options: {
+    allowCreate?: boolean;
+    placeholder?: string;
+    tokenKey: string;
+  };
+}
+interface PipelabSelectOption {
+  label: string;
+  value: string;
+}
+interface ControlTypeSelect extends ControlTypeBase {
+  type: "select";
+  options: {
+    options: Array<PipelabSelectOption>;
+    placeholder: string;
+  };
+}
+interface ControlTypeMultiSelect extends ControlTypeBase {
+  type: "multi-select";
+  options: {
+    options: Array<PipelabSelectOption>;
+    placeholder: string;
+  };
+}
+interface ControlTypeBoolean extends ControlTypeBase {
+  type: "boolean";
+}
+interface ControlTypeCheckbox extends ControlTypeBase {
+  type: "checkbox";
+}
+interface ControlTypePath extends ControlTypeBase {
+  type: "path";
+  options: OpenDialogOptions$1;
+  label?: string;
+}
+interface ControlTypeJSON extends ControlTypeBase {
+  type: "json";
+}
+interface ControlTypeArray extends ControlTypeBase {
+  type: "array";
+  options: {
+    kind: "number" | "text";
+  };
+}
+interface ControlTypeColor extends ControlTypeBase {
+  type: "color";
+}
+interface ControlTypeElectronConfigureV2 extends ControlTypeBase {
+  type: "electron:configure:v2";
+}
+type ControlType = ControlTypeInput | ControlTypeSelect | ControlTypeMultiSelect | ControlTypeBoolean | ControlTypeCheckbox | ControlTypePath | ControlTypeJSON | ControlTypeExpression | ControlTypeNetlifySite | ControlTypeArray | ControlTypeColor | ControlTypeElectronConfigureV2;
+type InputDefinition<T extends ControlType = ControlType> = {
+  label: string;
+  description?: string;
+  validator?: () => any;
+  required: boolean;
+  control: T;
+  value: unknown;
+  platforms?: NodeJS.Platform[];
+  onNodeUpdate?: (value: any, settings: InputDefinition<any>) => void;
+};
+type InputsDefinition = Record<string, InputDefinition>;
+type Meta = Record<string, unknown>;
+interface OutputDefinition {
+  label: string;
+  description?: string;
+  deprecated?: boolean;
+  validator?: (value: any) => any;
+  control?: ControlType;
+  value: unknown;
+}
+type OutputsDefinition = Record<string, OutputDefinition>;
+type InputOutputDefinition = InputDefinition | OutputDefinition;
+type IconType = {
+  type: "image";
+  /**
+   * base64 image
+   */
+  image: string;
+} | {
+  type: "icon";
+  icon: string;
+};
+interface PluginDefinition {
+  id: string;
+  name: string;
+  icon: IconType;
+  description: string;
+}
+type RendererNodeDefinition = {
+  node: PipelabNode;
+};
+interface RendererPluginDefinition extends PluginDefinition {
+  nodes: Array<RendererNodeDefinition>;
+}
+interface MainPluginDefinition extends PluginDefinition {
+  nodes: ({
+    runner: any;
+  } & RendererNodeDefinition)[];
+  validators?: Array<{
+    id: string;
+    description: string;
+    validator: (options: any) => any;
+  }>;
+}
+declare const createNodeDefinition: (def: MainPluginDefinition) => MainPluginDefinition;
+type InputsOutputsDefinition = InputsDefinition | OutputsDefinition;
+type GetFlowEntries<T extends InputsOutputsDefinition> = ConditionalPick<T, {
+  type: "flow";
+}>;
+type GetDataEntries<T extends InputsOutputsDefinition> = ConditionalPick<T, {
+  type: "data";
+}>;
+type GetFlowKeys<T extends InputsOutputsDefinition> = keyof GetFlowEntries<T>;
+type GetDataKeys<T extends InputsOutputsDefinition> = keyof GetDataEntries<T>;
+type DataResult = Record<string, any>;
+type SetOutputActionFn<T extends Action> = (key: keyof T["outputs"], value: T["outputs"][typeof key]["value"]) => void;
+type SetOutputLoopFn<T extends Loop> = (key: keyof T["outputs"], value: T["outputs"][typeof key]["value"]) => void;
+type SetOutputExpressionFn<T extends Expression> = (key: keyof T["outputs"], value: T["outputs"][typeof key]["value"]) => void;
+type ParamsToInput<PARAMS extends InputsDefinition> = { [index in keyof PARAMS]: PARAMS[index]["required"] extends true ? PARAMS[index]["value"] : PARAMS[index]["value"] | null };
+interface BaseNode {
+  disabled?: boolean | string;
+  advanced?: boolean | string;
+  updateAvailable?: boolean | string;
+}
+interface Action extends BaseNode {
+  id: string;
+  type: "action";
+  version?: number;
+  displayString: string;
+  icon: string;
+  name: string;
+  description: string;
+  params: InputsDefinition;
+  meta: Meta;
+  outputs: OutputsDefinition;
+  platforms?: NodeJS.Platform[];
+  deprecated?: boolean;
+  deprecatedMessage?: string;
+}
+type ExtractInputsFromAction<ACTION extends Action> = { [index in keyof ACTION["params"]]: ACTION["params"][index]["value"] };
+type ExtractInputsFromCondition<CONDITION extends Condition> = { [index in keyof CONDITION["params"]]: CONDITION["params"][index]["value"] };
+type ExtractInputsFromLoop<LOOP extends Loop> = { [index in keyof LOOP["params"]]: LOOP["params"][index]["value"] };
+type ExtractInputsFromEvent<EVENT extends Event$1> = { [index in keyof EVENT["params"]]: EVENT["params"][index]["value"] };
+type ExtractInputsFromExpression<EXPRESSION extends Expression> = { [index in keyof EXPRESSION["params"]]: EXPRESSION["params"][index]["value"] };
+interface Condition extends BaseNode {
+  id: string;
+  type: "condition";
+  version?: number;
+  displayString: string;
+  icon: string;
+  name: string;
+  description: string;
+  params: InputsDefinition;
+  meta?: Meta;
+  platforms?: NodeJS.Platform[];
+}
+interface Loop extends BaseNode {
+  id: string;
+  type: "loop";
+  version?: number;
+  displayString: string;
+  icon: string;
+  name: string;
+  description: string;
+  params: InputsDefinition;
+  meta?: Meta;
+  outputs: OutputsDefinition;
+}
+interface Expression extends BaseNode {
+  id: string;
+  type: "expression";
+  displayString: string;
+  version?: number;
+  icon: string;
+  name: string;
+  description: string;
+  params: InputsDefinition;
+  meta?: Meta;
+  outputs: OutputsDefinition;
+}
+interface Event$1 extends BaseNode {
+  id: string;
+  type: "event";
+  version?: number;
+  displayString: string;
+  icon: string;
+  name: string;
+  description: string;
+  params: InputsDefinition;
+  meta?: Meta;
+  platforms?: NodeJS.Platform[];
+}
+type PipelabNode = Event$1 | Condition | Expression | Action | Loop;
+declare const createDefinition: <T extends MainPluginDefinition>(definition: T) => T;
+declare const createAction: <T extends Omit<Action, "type">>(action: T) => T & {
+  type: "action";
+};
+declare const createStringParam: (value: string, definition: Omit<InputDefinition<ControlTypeInput>, "value" | "control">) => {
+  control: {
+    type: "input";
+    options: {
+      kind: "text";
+    };
+  };
+  value: string;
+  description?: string;
+  platforms?: NodeJS.Platform[];
+  label: string;
+  validator?: () => any;
+  required: boolean;
+  onNodeUpdate?: (value: any, settings: InputDefinition<any>) => void;
+};
+declare const createColorPicker: (value: string, definition: Omit<InputDefinition<ControlTypeColor>, "value" | "control">) => {
+  control: {
+    type: "color";
+  };
+  value: string;
+  description?: string;
+  platforms?: NodeJS.Platform[];
+  label: string;
+  validator?: () => any;
+  required: boolean;
+  onNodeUpdate?: (value: any, settings: InputDefinition<any>) => void;
+};
+declare const createPasswordParam: (value: string, definition: Omit<InputDefinition<ControlTypeInput>, "value" | "control">) => {
+  control: {
+    type: "input";
+    options: {
+      kind: "text";
+      password: true;
+    };
+  };
+  value: string;
+  description?: string;
+  platforms?: NodeJS.Platform[];
+  label: string;
+  validator?: () => any;
+  required: boolean;
+  onNodeUpdate?: (value: any, settings: InputDefinition<any>) => void;
+};
+declare const createPathParam: (value: string | undefined, definition: Omit<InputDefinition<ControlTypePath>, "value">) => {
+  value: string;
+  description?: string;
+  platforms?: NodeJS.Platform[];
+  control: ControlTypePath;
+  label: string;
+  validator?: () => any;
+  required: boolean;
+  onNodeUpdate?: (value: any, settings: InputDefinition<any>) => void;
+};
+declare const createArray: <T extends unknown[]>(value: string | Array<unknown>, definition: Omit<InputDefinition<ControlTypeArray>, "value">) => {
+  value: T;
+  description?: string;
+  platforms?: NodeJS.Platform[];
+  control: ControlTypeArray;
+  label: string;
+  validator?: () => any;
+  required: boolean;
+  onNodeUpdate?: (value: any, settings: InputDefinition<any>) => void;
+};
+declare const createNetlifySiteParam: (value: string, tokenKey: string, definition: Omit<InputDefinition<ControlTypeNetlifySite>, "value" | "control">) => {
+  control: {
+    type: "netlify-site";
+    options: {
+      allowCreate: true;
+      placeholder: string;
+      tokenKey: string;
+    };
+  };
+  value: string;
+  description?: string;
+  platforms?: NodeJS.Platform[];
+  label: string;
+  validator?: () => any;
+  required: boolean;
+  onNodeUpdate?: (value: any, settings: InputDefinition<any>) => void;
+};
+declare const createNumberParam: (value: number, definition: Omit<InputDefinition<ControlTypeInput>, "value" | "control">) => {
+  control: {
+    type: "input";
+    options: {
+      kind: "number";
+    };
+  };
+  value: number;
+  description?: string;
+  platforms?: NodeJS.Platform[];
+  label: string;
+  validator?: () => any;
+  required: boolean;
+  onNodeUpdate?: (value: any, settings: InputDefinition<any>) => void;
+};
+declare const createBooleanParam: (value: boolean, definition: Omit<InputDefinition<ControlTypeBoolean>, "value" | "control">) => {
+  control: {
+    type: "boolean";
+  };
+  value: boolean;
+  description?: string;
+  platforms?: NodeJS.Platform[];
+  label: string;
+  validator?: () => any;
+  required: boolean;
+  onNodeUpdate?: (value: any, settings: InputDefinition<any>) => void;
+};
+declare const createRawParam: <T>(value: T, definition: Omit<InputDefinition, "value">) => {
+  value: T;
+  description?: string;
+  platforms?: NodeJS.Platform[];
+  control: ControlType;
+  label: string;
+  validator?: () => any;
+  required: boolean;
+  onNodeUpdate?: (value: any, settings: InputDefinition<any>) => void;
+};
+declare const createExpression: <T extends Omit<Expression, "type">>(expression: T) => T & {
+  type: "expression";
+};
+declare const createCondition: <T extends Omit<Condition, "type">>(condition: T) => T & {
+  type: "condition";
+};
+declare const createLoop: <T extends Omit<Loop, "type">>(loop: T) => T & {
+  type: "loop";
+};
+declare const createEvent: <T extends Omit<Event$1, "type">>(event: T) => T & {
+  type: "event";
+};
+//#endregion
+//#region src/quickjs.d.ts
+/**
+ * Creates a QuickJS instance from an already-resolved variant.
+ * Callers are responsible for importing and passing the correct variant
+ * for their environment (Node vs browser) using a static import.
+ */
+declare const createQuickJsFromVariant: (variant: any) => Promise<{
+  run: (code: string, params: Record<string, unknown>) => any;
+  createContext: () => {
+    run: (code: string, params: Record<string, unknown>) => any;
+    dispose: () => void;
+  };
+}>;
+declare const createQuickJs: () => Promise<{
+  run: (code: string, params: Record<string, unknown>) => any;
+  createContext: () => {
+    run: (code: string, params: Record<string, unknown>) => any;
+    dispose: () => void;
+  };
+}>;
+type CreateQuickJSFn = ReturnType<typeof createQuickJs>;
+//#endregion
+//#region src/variables.d.ts
+interface VariableBase {
+  value: string;
+  id: string;
+  name: string;
+  description: string;
+}
+type Variable = VariableBase;
+declare const variableToFormattedVariable: (vm: Awaited<CreateQuickJSFn>, variables: Variable[]) => Promise<Record<string, string>>;
+//#endregion
+//#region src/utils.d.ts
+declare const foo = "bar";
+type WithId<T> = T extends string | number ? never : T & {
+  id: string;
+};
+//#endregion
+//#region src/save-location.d.ts
+declare const SaveLocationInternalValidator: valibot.ObjectSchema<{
+  readonly id: valibot.StringSchema<undefined>;
+  readonly project: valibot.StringSchema<undefined>;
+  readonly lastModified: valibot.StringSchema<undefined>;
+  readonly type: valibot.LiteralSchema<"internal", undefined>;
+  readonly configName: valibot.StringSchema<undefined>;
+}, undefined>;
+type SaveLocationInternal = InferInput<typeof SaveLocationInternalValidator>;
+/** @deprecated External pipeline files are deprecated and will be removed in future versions. */
+declare const SaveLocationExternalValidator: valibot.ObjectSchema<{
+  readonly id: valibot.StringSchema<undefined>;
+  readonly project: valibot.StringSchema<undefined>;
+  readonly path: valibot.StringSchema<undefined>;
+  readonly lastModified: valibot.StringSchema<undefined>;
+  readonly type: valibot.LiteralSchema<"external", undefined>;
+  readonly summary: valibot.ObjectSchema<{
+    readonly plugins: valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>;
+    readonly name: valibot.StringSchema<undefined>;
+    readonly description: valibot.StringSchema<undefined>;
+  }, undefined>;
+}, undefined>;
+/** @deprecated External pipeline files are deprecated and will be removed in future versions. */
+type SaveLocationExternal = InferInput<typeof SaveLocationExternalValidator>;
+declare const SaveLocationPipelabCloudValidator: valibot.ObjectSchema<{
+  readonly id: valibot.StringSchema<undefined>;
+  readonly project: valibot.StringSchema<undefined>;
+  readonly type: valibot.LiteralSchema<"pipelab-cloud", undefined>;
+}, undefined>;
+type SaveLocationPipelabCloud = InferInput<typeof SaveLocationPipelabCloudValidator>;
+declare const SaveLocationValidator: valibot.UnionSchema<[valibot.ObjectSchema<{
+  readonly id: valibot.StringSchema<undefined>;
+  readonly project: valibot.StringSchema<undefined>;
+  readonly path: valibot.StringSchema<undefined>;
+  readonly lastModified: valibot.StringSchema<undefined>;
+  readonly type: valibot.LiteralSchema<"external", undefined>;
+  readonly summary: valibot.ObjectSchema<{
+    readonly plugins: valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>;
+    readonly name: valibot.StringSchema<undefined>;
+    readonly description: valibot.StringSchema<undefined>;
+  }, undefined>;
+}, undefined>, valibot.ObjectSchema<{
+  readonly id: valibot.StringSchema<undefined>;
+  readonly project: valibot.StringSchema<undefined>;
+  readonly lastModified: valibot.StringSchema<undefined>;
+  readonly type: valibot.LiteralSchema<"internal", undefined>;
+  readonly configName: valibot.StringSchema<undefined>;
+}, undefined>, valibot.ObjectSchema<{
+  readonly id: valibot.StringSchema<undefined>;
+  readonly project: valibot.StringSchema<undefined>;
+  readonly type: valibot.LiteralSchema<"pipelab-cloud", undefined>;
+}, undefined>], undefined>;
+type SaveLocation = InferInput<typeof SaveLocationValidator>;
+//#endregion
+//#region src/model.d.ts
+type Position = {
+  x: number;
+  y: number;
+};
+declare const OriginValidator: valibot.ObjectSchema<{
+  readonly pluginId: valibot.StringSchema<undefined>;
+  readonly nodeId: valibot.StringSchema<undefined>;
+}, undefined>;
+type Origin = InferOutput<typeof OriginValidator>;
+declare const EditorParamValidatorV3: valibot.UnionSchema<[valibot.LiteralSchema<"simple", undefined>, valibot.LiteralSchema<"editor", undefined>], undefined>;
+type EditorParam = InferOutput<typeof EditorParamValidatorV3>;
+declare const BlockActionValidatorV3: valibot.ObjectSchema<{
+  readonly type: valibot.LiteralSchema<"action", undefined>;
+  readonly uid: valibot.StringSchema<undefined>;
+  readonly name: valibot.SchemaWithPipe<[valibot.OptionalSchema<valibot.StringSchema<undefined>, never>, valibot.DescriptionAction<string, "A custom name provided by the user">]>;
+  readonly disabled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+  readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.ObjectSchema<{
+    readonly editor: valibot.UnionSchema<[valibot.LiteralSchema<"simple", undefined>, valibot.LiteralSchema<"editor", undefined>], undefined>;
+    readonly value: valibot.UnknownSchema;
+  }, undefined>, undefined>;
+  readonly origin: valibot.ObjectSchema<{
+    readonly pluginId: valibot.StringSchema<undefined>;
+    readonly nodeId: valibot.StringSchema<undefined>;
+  }, undefined>;
+}, undefined>;
+type BlockCondition = {
+  type: "condition";
+  uid: string;
+  origin: Origin;
+  params: Record<string, any>;
+  branchTrue: Array<Block>;
+  branchFalse: Array<Block>;
+};
+type BlockLoop = {
+  type: "loop";
+  uid: string;
+  origin: Origin;
+  params: Record<string, any>;
+  children: Array<Block>;
+};
+declare const BlockEventValidator: valibot.ObjectSchema<{
+  readonly type: valibot.LiteralSchema<"event", undefined>;
+  readonly uid: valibot.StringSchema<undefined>;
+  readonly origin: valibot.ObjectSchema<{
+    readonly pluginId: valibot.StringSchema<undefined>;
+    readonly nodeId: valibot.StringSchema<undefined>;
+  }, undefined>;
+  readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.AnySchema, undefined>;
+}, undefined>;
+declare const BlockCommentValidator: valibot.ObjectSchema<{
+  readonly type: valibot.LiteralSchema<"comment", undefined>;
+  readonly uid: valibot.StringSchema<undefined>;
+  readonly origin: valibot.ObjectSchema<{
+    readonly pluginId: valibot.StringSchema<undefined>;
+    readonly nodeId: valibot.StringSchema<undefined>;
+  }, undefined>;
+  readonly comment: valibot.StringSchema<undefined>;
+}, undefined>;
+declare const BlockValidatorV3: valibot.VariantSchema<"type", [valibot.ObjectSchema<{
+  readonly type: valibot.LiteralSchema<"action", undefined>;
+  readonly uid: valibot.StringSchema<undefined>;
+  readonly name: valibot.SchemaWithPipe<[valibot.OptionalSchema<valibot.StringSchema<undefined>, never>, valibot.DescriptionAction<string, "A custom name provided by the user">]>;
+  readonly disabled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+  readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.ObjectSchema<{
+    readonly editor: valibot.UnionSchema<[valibot.LiteralSchema<"simple", undefined>, valibot.LiteralSchema<"editor", undefined>], undefined>;
+    readonly value: valibot.UnknownSchema;
+  }, undefined>, undefined>;
+  readonly origin: valibot.ObjectSchema<{
+    readonly pluginId: valibot.StringSchema<undefined>;
+    readonly nodeId: valibot.StringSchema<undefined>;
+  }, undefined>;
+}, undefined>], undefined>;
+type BlockAction = Simplify<InferOutput<typeof BlockActionValidatorV3>>;
+type BlockEvent = InferOutput<typeof BlockEventValidator>;
+type BlockComment = InferOutput<typeof BlockCommentValidator>;
+type Block = InferOutput<typeof BlockValidatorV3>;
+declare const VariableValidatorV1: valibot.CustomSchema<VariableBase, undefined>;
+declare const SavedFileValidatorV1: valibot.ObjectSchema<{
+  readonly version: valibot.LiteralSchema<"1.0.0", undefined>;
+  readonly name: valibot.StringSchema<undefined>;
+  readonly description: valibot.StringSchema<undefined>;
+  readonly canvas: valibot.ObjectSchema<{
+    readonly blocks: valibot.ArraySchema<valibot.VariantSchema<"type", [valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"action", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly disabled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.AnySchema, undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>, valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"event", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.AnySchema, undefined>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>;
+  readonly variables: valibot.ArraySchema<valibot.CustomSchema<VariableBase, undefined>, undefined>;
+}, undefined>;
+declare const SavedFileValidatorV2: valibot.ObjectSchema<{
+  readonly version: valibot.LiteralSchema<"2.0.0", undefined>;
+  readonly name: valibot.StringSchema<undefined>;
+  readonly description: valibot.StringSchema<undefined>;
+  readonly canvas: valibot.ObjectSchema<{
+    readonly blocks: valibot.ArraySchema<valibot.VariantSchema<"type", [valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"action", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly disabled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.AnySchema, undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>], undefined>, undefined>;
+    readonly triggers: valibot.ArraySchema<valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"event", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.AnySchema, undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly variables: valibot.ArraySchema<valibot.CustomSchema<VariableBase, undefined>, undefined>;
+}, undefined>;
+declare const SavedFileValidatorV3: valibot.ObjectSchema<{
+  readonly version: valibot.LiteralSchema<"3.0.0", undefined>;
+  readonly name: valibot.StringSchema<undefined>;
+  readonly description: valibot.StringSchema<undefined>;
+  readonly canvas: valibot.ObjectSchema<{
+    readonly blocks: valibot.ArraySchema<valibot.VariantSchema<"type", [valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"action", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly name: valibot.SchemaWithPipe<[valibot.OptionalSchema<valibot.StringSchema<undefined>, never>, valibot.DescriptionAction<string, "A custom name provided by the user">]>;
+      readonly disabled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.ObjectSchema<{
+        readonly editor: valibot.UnionSchema<[valibot.LiteralSchema<"simple", undefined>, valibot.LiteralSchema<"editor", undefined>], undefined>;
+        readonly value: valibot.UnknownSchema;
+      }, undefined>, undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>], undefined>, undefined>;
+    readonly triggers: valibot.ArraySchema<valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"event", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.AnySchema, undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly variables: valibot.ArraySchema<valibot.CustomSchema<VariableBase, undefined>, undefined>;
+}, undefined>;
+declare const SavedFileDefaultValidator: valibot.ObjectSchema<{
+  readonly version: valibot.LiteralSchema<"4.0.0", undefined>;
+  readonly type: valibot.LiteralSchema<"default", undefined>;
+  readonly name: valibot.StringSchema<undefined>;
+  readonly description: valibot.StringSchema<undefined>;
+  readonly canvas: valibot.ObjectSchema<{
+    readonly blocks: valibot.ArraySchema<valibot.VariantSchema<"type", [valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"action", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly name: valibot.SchemaWithPipe<[valibot.OptionalSchema<valibot.StringSchema<undefined>, never>, valibot.DescriptionAction<string, "A custom name provided by the user">]>;
+      readonly disabled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.ObjectSchema<{
+        readonly editor: valibot.UnionSchema<[valibot.LiteralSchema<"simple", undefined>, valibot.LiteralSchema<"editor", undefined>], undefined>;
+        readonly value: valibot.UnknownSchema;
+      }, undefined>, undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>], undefined>, undefined>;
+    readonly triggers: valibot.ArraySchema<valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"event", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.AnySchema, undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly variables: valibot.ArraySchema<valibot.CustomSchema<VariableBase, undefined>, undefined>;
+}, undefined>;
+declare const SavedFileSimpleValidator: valibot.ObjectSchema<{
+  readonly version: valibot.LiteralSchema<"4.0.0", undefined>;
+  readonly type: valibot.LiteralSchema<"simple", undefined>;
+  readonly name: valibot.StringSchema<undefined>;
+  readonly description: valibot.StringSchema<undefined>;
+  readonly source: valibot.ObjectSchema<{
+    readonly type: valibot.UnionSchema<[valibot.LiteralSchema<"c3-html", undefined>, valibot.LiteralSchema<"c3-nwjs", undefined>, valibot.LiteralSchema<"godot", undefined>, valibot.LiteralSchema<"html", undefined>], undefined>;
+    readonly path: valibot.StringSchema<undefined>;
+  }, undefined>;
+  readonly packaging: valibot.ObjectSchema<{
+    readonly enabled: valibot.BooleanSchema<undefined>;
+  }, undefined>;
+  readonly publishing: valibot.ObjectSchema<{
+    readonly steam: valibot.ObjectSchema<{
+      readonly enabled: valibot.BooleanSchema<undefined>;
+      readonly appId: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    }, undefined>;
+    readonly itch: valibot.ObjectSchema<{
+      readonly enabled: valibot.BooleanSchema<undefined>;
+      readonly project: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    }, undefined>;
+    readonly poki: valibot.ObjectSchema<{
+      readonly enabled: valibot.BooleanSchema<undefined>;
+      readonly gameId: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    }, undefined>;
+  }, undefined>;
+}, undefined>;
+type SavedFileDefault = InferOutput<typeof SavedFileDefaultValidator>;
+type SavedFileSimple = InferOutput<typeof SavedFileSimpleValidator>;
+declare const SavedFileValidatorV4: valibot.UnionSchema<[valibot.ObjectSchema<{
+  readonly version: valibot.LiteralSchema<"4.0.0", undefined>;
+  readonly type: valibot.LiteralSchema<"default", undefined>;
+  readonly name: valibot.StringSchema<undefined>;
+  readonly description: valibot.StringSchema<undefined>;
+  readonly canvas: valibot.ObjectSchema<{
+    readonly blocks: valibot.ArraySchema<valibot.VariantSchema<"type", [valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"action", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly name: valibot.SchemaWithPipe<[valibot.OptionalSchema<valibot.StringSchema<undefined>, never>, valibot.DescriptionAction<string, "A custom name provided by the user">]>;
+      readonly disabled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.ObjectSchema<{
+        readonly editor: valibot.UnionSchema<[valibot.LiteralSchema<"simple", undefined>, valibot.LiteralSchema<"editor", undefined>], undefined>;
+        readonly value: valibot.UnknownSchema;
+      }, undefined>, undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>], undefined>, undefined>;
+    readonly triggers: valibot.ArraySchema<valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"event", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.AnySchema, undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly variables: valibot.ArraySchema<valibot.CustomSchema<VariableBase, undefined>, undefined>;
+}, undefined>, valibot.ObjectSchema<{
+  readonly version: valibot.LiteralSchema<"4.0.0", undefined>;
+  readonly type: valibot.LiteralSchema<"simple", undefined>;
+  readonly name: valibot.StringSchema<undefined>;
+  readonly description: valibot.StringSchema<undefined>;
+  readonly source: valibot.ObjectSchema<{
+    readonly type: valibot.UnionSchema<[valibot.LiteralSchema<"c3-html", undefined>, valibot.LiteralSchema<"c3-nwjs", undefined>, valibot.LiteralSchema<"godot", undefined>, valibot.LiteralSchema<"html", undefined>], undefined>;
+    readonly path: valibot.StringSchema<undefined>;
+  }, undefined>;
+  readonly packaging: valibot.ObjectSchema<{
+    readonly enabled: valibot.BooleanSchema<undefined>;
+  }, undefined>;
+  readonly publishing: valibot.ObjectSchema<{
+    readonly steam: valibot.ObjectSchema<{
+      readonly enabled: valibot.BooleanSchema<undefined>;
+      readonly appId: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    }, undefined>;
+    readonly itch: valibot.ObjectSchema<{
+      readonly enabled: valibot.BooleanSchema<undefined>;
+      readonly project: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    }, undefined>;
+    readonly poki: valibot.ObjectSchema<{
+      readonly enabled: valibot.BooleanSchema<undefined>;
+      readonly gameId: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    }, undefined>;
+  }, undefined>;
+}, undefined>], undefined>;
+type SavedFileV1 = InferOutput<typeof SavedFileValidatorV1>;
+type SavedFileV2 = InferOutput<typeof SavedFileValidatorV2>;
+type SavedFileV3 = InferOutput<typeof SavedFileValidatorV3>;
+type SavedFileV4 = InferOutput<typeof SavedFileValidatorV4>;
+type SavedFile = SavedFileV4;
+declare const SavedFileValidator: valibot.UnionSchema<[valibot.ObjectSchema<{
+  readonly version: valibot.LiteralSchema<"4.0.0", undefined>;
+  readonly type: valibot.LiteralSchema<"default", undefined>;
+  readonly name: valibot.StringSchema<undefined>;
+  readonly description: valibot.StringSchema<undefined>;
+  readonly canvas: valibot.ObjectSchema<{
+    readonly blocks: valibot.ArraySchema<valibot.VariantSchema<"type", [valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"action", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly name: valibot.SchemaWithPipe<[valibot.OptionalSchema<valibot.StringSchema<undefined>, never>, valibot.DescriptionAction<string, "A custom name provided by the user">]>;
+      readonly disabled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.ObjectSchema<{
+        readonly editor: valibot.UnionSchema<[valibot.LiteralSchema<"simple", undefined>, valibot.LiteralSchema<"editor", undefined>], undefined>;
+        readonly value: valibot.UnknownSchema;
+      }, undefined>, undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>], undefined>, undefined>;
+    readonly triggers: valibot.ArraySchema<valibot.ObjectSchema<{
+      readonly type: valibot.LiteralSchema<"event", undefined>;
+      readonly uid: valibot.StringSchema<undefined>;
+      readonly origin: valibot.ObjectSchema<{
+        readonly pluginId: valibot.StringSchema<undefined>;
+        readonly nodeId: valibot.StringSchema<undefined>;
+      }, undefined>;
+      readonly params: valibot.RecordSchema<valibot.StringSchema<undefined>, valibot.AnySchema, undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly variables: valibot.ArraySchema<valibot.CustomSchema<VariableBase, undefined>, undefined>;
+}, undefined>, valibot.ObjectSchema<{
+  readonly version: valibot.LiteralSchema<"4.0.0", undefined>;
+  readonly type: valibot.LiteralSchema<"simple", undefined>;
+  readonly name: valibot.StringSchema<undefined>;
+  readonly description: valibot.StringSchema<undefined>;
+  readonly source: valibot.ObjectSchema<{
+    readonly type: valibot.UnionSchema<[valibot.LiteralSchema<"c3-html", undefined>, valibot.LiteralSchema<"c3-nwjs", undefined>, valibot.LiteralSchema<"godot", undefined>, valibot.LiteralSchema<"html", undefined>], undefined>;
+    readonly path: valibot.StringSchema<undefined>;
+  }, undefined>;
+  readonly packaging: valibot.ObjectSchema<{
+    readonly enabled: valibot.BooleanSchema<undefined>;
+  }, undefined>;
+  readonly publishing: valibot.ObjectSchema<{
+    readonly steam: valibot.ObjectSchema<{
+      readonly enabled: valibot.BooleanSchema<undefined>;
+      readonly appId: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    }, undefined>;
+    readonly itch: valibot.ObjectSchema<{
+      readonly enabled: valibot.BooleanSchema<undefined>;
+      readonly project: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    }, undefined>;
+    readonly poki: valibot.ObjectSchema<{
+      readonly enabled: valibot.BooleanSchema<undefined>;
+      readonly gameId: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    }, undefined>;
+  }, undefined>;
+}, undefined>], undefined>;
+type Preset = SavedFile;
+type PresetResult = {
+  data: SavedFile;
+  hightlight?: boolean;
+  disabled?: boolean;
+};
+type PresetFn = () => Promise<PresetResult>;
+type Steps = Record<string, {
+  outputs: Record<string, unknown>;
+}>;
+type EnhancedFile<T extends SavedFile = SavedFile> = WithId<SaveLocation> & {
+  content: T;
+};
+//#endregion
+//#region src/websocket.types.d.ts
+type WebSocketConnectionState = "connecting" | "connected" | "disconnected" | "error" | "reconnecting";
+interface WebSocketServerConfig {
+  port?: number;
+  host?: string;
+  maxReconnectAttempts?: number;
+  reconnectDelay?: number;
+}
+interface WebSocketServerEvents {
+  connection: (ws: WebSocket, request: IncomingMessage$1) => void;
+  message: (ws: WebSocket, data: Buffer) => void;
+  close: (ws: WebSocket) => void;
+  error: (ws: WebSocket, error: Error) => void;
+}
+interface WebSocketClientConfig {
+  url?: string;
+  maxReconnectAttempts?: number;
+  reconnectDelay?: number;
+  timeout?: number;
+}
+interface WebSocketClientEvents {
+  open: () => void;
+  message: (event: MessageEvent) => void;
+  close: (event: CloseEvent) => void;
+  error: (error: Event) => void;
+}
+interface WebSocketEvent {
+  sender: string;
+  timestamp?: number;
+}
+interface WebSocketRequestMessage {
+  channel: Channels;
+  requestId: RequestId$1;
+  data: any;
+}
+interface WebSocketResponseMessage {
+  type: "response";
+  requestId: RequestId$1;
+  events: Events<any>;
+}
+interface WebSocketErrorMessage {
+  type: "error";
+  requestId: RequestId$1;
+  error: string;
+  code?: string;
+}
+type WebSocketMessage = WebSocketRequestMessage | WebSocketResponseMessage | WebSocketErrorMessage;
+interface WebSocketConnectionInfo {
+  id: string;
+  state: WebSocketConnectionState;
+  url: string;
+  connectedAt?: Date;
+  lastActivity?: Date;
+}
+interface Agent {
+  id: string;
+  name: string;
+  isSelf: boolean;
+  connectedAt?: number;
+}
+type WebSocketHandler<KEY extends Channels> = (event: WebSocketEvent, data: {
+  value: Data$1<KEY>;
+  send: WebSocketSendFunction<KEY>;
+}) => Promise<void>;
+type WebSocketSendFunction<KEY extends Channels> = (events: Events<KEY>) => Promise<void>;
+type WebSocketListener<KEY extends Channels> = (event: Events<KEY>) => Promise<void>;
+interface WebSocketAPI {
+  execute: <KEY extends Channels>(channel: KEY, data?: Data$1<KEY>, listener?: WebSocketListener<KEY>) => Promise<End<KEY>>;
+  send: <KEY extends Channels>(channel: KEY, data?: Data$1<KEY>) => Promise<End<KEY>>;
+  on: <KEY extends Channels>(channel: KEY, listener: (event: WebSocketEvent, data: Events<KEY>) => void) => () => void;
+  isConnected: () => boolean;
+  disconnect: () => void;
+}
+interface WebSocketManager {
+  connect: (url?: string) => Promise<void>;
+  disconnect: () => void;
+  send: <KEY extends Channels>(channel: KEY, data?: Data$1<KEY>) => Promise<End<KEY>>;
+  isConnected: () => boolean;
+  getConnectionState: () => WebSocketConnectionState;
+  onStateChange: (callback: (state: WebSocketConnectionState) => void) => () => void;
+}
+declare class WebSocketError extends Error {
+  code?: string;
+  requestId?: RequestId$1;
+  constructor(message: string, code?: string, requestId?: RequestId$1);
+}
+declare class WebSocketConnectionError extends WebSocketError {
+  url?: string;
+  constructor(message: string, url?: string);
+}
+declare class WebSocketTimeoutError extends WebSocketError {
+  timeout: number;
+  constructor(message: string, timeout: number, requestId?: RequestId$1);
+}
+declare const isWebSocketRequestMessage: (message: any) => message is WebSocketRequestMessage;
+declare const isWebSocketResponseMessage: (message: any) => message is WebSocketResponseMessage;
+declare const isWebSocketErrorMessage: (message: any) => message is WebSocketErrorMessage;
+type WebSocketMessageType<T extends Channels> = {
+  channel: T;
+  requestId: RequestId$1;
+  data: Data$1<T>;
+};
+type WebSocketResponseType<T extends Channels> = {
+  type: "response";
+  requestId: RequestId$1;
+  events: Events<T>;
+};
+//#endregion
+//#region src/build-history.d.ts
+interface ExecutionStep {
+  id: string;
+  name: string;
+  status: "pending" | "running" | "completed" | "failed" | "cancelled";
+  startTime: number;
+  endTime?: number;
+  duration?: number;
+  logs: LogEntry[];
+  error?: ExecutionError;
+  output?: Record<string, unknown>;
+}
+interface ExecutionError {
+  message: string;
+  stack?: string;
+  code?: string;
+  timestamp: number;
+}
+interface LogEntry {
+  id: string;
+  timestamp: number;
+  level: "debug" | "info" | "warn" | "error";
+  message: string;
+  source?: string;
+  data?: Record<string, unknown>;
+}
+interface BuildHistoryEntry {
+  id: string;
+  pipelineId: string;
+  projectName: string;
+  projectPath: string;
+  status: "running" | "completed" | "failed" | "cancelled";
+  startTime: number;
+  endTime?: number;
+  duration?: number;
+  steps: ExecutionStep[];
+  totalSteps: number;
+  completedSteps: number;
+  failedSteps: number;
+  cancelledSteps: number;
+  logs: LogEntry[];
+  error?: ExecutionError;
+  output?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  userId?: string;
+  createdAt: number;
+  updatedAt: number;
+}
+interface BuildHistoryQuery {
+  pipelineId?: string;
+}
+interface BuildHistoryResponse {
+  entries: BuildHistoryEntry[];
+  total: number;
+}
+interface IBuildHistoryStorage {
+  save(entry: BuildHistoryEntry): Promise<void>;
+  get(id: string, pipelineId?: string): Promise<BuildHistoryEntry | undefined>;
+  getAll(): Promise<BuildHistoryEntry[]>;
+  getByPipeline(pipelineId: string): Promise<BuildHistoryEntry[]>;
+  update(id: string, updates: Partial<BuildHistoryEntry>, pipelineId?: string): Promise<void>;
+  delete(id: string, pipelineId?: string): Promise<void>;
+  clear(): Promise<void>;
+  getStorageInfo(): Promise<{
+    totalEntries: number;
+    totalSize: number;
+    oldestEntry?: number;
+    newestEntry?: number;
+  }>;
+}
+interface RetentionPolicy {
+  enabled: boolean;
+  maxEntries: number;
+  maxAge: number;
+  maxSize: number;
+  keepFailedBuilds: boolean;
+  keepSuccessfulBuilds: boolean;
+}
+interface BuildHistoryConfig {
+  storagePath: string;
+  indexFileName: string;
+  entryFilePrefix: string;
+  retentionPolicy: RetentionPolicy;
+}
+interface SubscriptionBenefit {
+  id: string;
+  name: string;
+  description?: string;
+}
+interface SubscriptionError extends Error {
+  code: "SUBSCRIPTION_REQUIRED" | "SUBSCRIPTION_EXPIRED" | "BENEFIT_NOT_FOUND" | "UNAUTHORIZED";
+  benefit?: string;
+  userMessage: string;
+}
+interface AuthorizationContext {
+  userId?: string;
+  hasBenefit: (benefitId: string) => boolean;
+  isPaidUser: boolean;
+}
+type AuthorizationCheck = (context: AuthorizationContext) => void;
+//#endregion
+//#region src/apis.d.ts
+type Event$2<TYPE extends string, DATA> = {
+  type: TYPE;
+  data: DATA;
+} | {
+  type: "log";
+  data: {
+    decorator: string;
+    message: unknown[];
+    time: number;
+  };
+};
+type EndEvent$1<DATA> = {
+  type: "end";
+  data: {
+    type: "success";
+    result: DATA;
+  } | {
+    type: "error";
+    ipcError: string;
+    code?: string;
+  };
+};
+type Presets = Record<string, PresetResult>;
+type IpcDefinition$1 = {
+  "fs:read": [{
+    path: string;
+  }, EndEvent$1<{
+    content: string;
+  }>];
+  "fs:remove": [{
+    path: string;
+  }, EndEvent$1<boolean>];
+  "fs:write": [{
+    path: string;
+    content: string;
+  }, EndEvent$1<{
+    ok: boolean;
+  }>];
+  "fs:rm": [{
+    path: string;
+    recursive: boolean;
+    force: boolean;
+  }, EndEvent$1<{
+    ok: boolean;
+  }>];
+  "fs:listDirectory": [{
+    path: string;
+  }, EndEvent$1<{
+    files: {
+      name: string;
+      isDirectory: boolean;
+      isSymbolicLink: boolean;
+      size: number;
+      mtime: number;
+    }[];
+  }>];
+  "fs:getHomeDirectory": [void, EndEvent$1<{
+    path: string;
+  }>];
+  "dialog:showOpenDialog": [Electron.OpenDialogOptions, EndEvent$1<{
+    canceled: boolean;
+    filePaths: string[];
+  }>];
+  "dialog:showSaveDialog": [Electron.SaveDialogOptions, EndEvent$1<{
+    canceled: boolean;
+    filePath: string | undefined;
+  }>];
+  "nodes:get": [void, EndEvent$1<{
+    nodes: RendererPluginDefinition[];
+  }>];
+  "presets:get": [void, EndEvent$1<Presets>];
+  "action:execute": [{
+    pluginId: string;
+    nodeId: string;
+    params: any;
+    steps: Steps;
+  }, (Event$2<"progress", unknown> | Event$2<"progress", unknown> | EndEvent$1<{
+    outputs: Record<string, unknown>;
+    tmp: string;
+  }>)];
+  "condition:execute": [{
+    pluginId: string;
+    nodeId: string;
+    params: any;
+    steps: Steps;
+  }, (Event$2<"progress", unknown> | Event$2<"progress", unknown> | EndEvent$1<{
+    outputs: Record<string, unknown>;
+    value: boolean;
+  }>)];
+  "constants:get": [void, EndEvent$1<{
+    result: {
+      userData: string;
+    };
+  }>];
+  "config:load": [{
+    config: string;
+  }, EndEvent$1<{
+    result: any;
+  }>];
+  "config:save": [{
+    data: any;
+    config: string;
+  }, EndEvent$1<{
+    result: "ok";
+  }>];
+  "config:reset": [{
+    config: string;
+    key: string;
+  }, EndEvent$1<{
+    result: "ok";
+  }>];
+  "action:cancel": [void, EndEvent$1<{
+    result: "ok" | "ko";
+  }>];
+  "build-history:save": [{
+    entry: BuildHistoryEntry;
+  }, EndEvent$1<{
+    result: "ok" | "ko";
+  }>];
+  "build-history:get": [{
+    id: string;
+    pipelineId?: string;
+  }, EndEvent$1<{
+    entry?: BuildHistoryEntry;
+  }>];
+  "build-history:get-all": [{
+    query?: BuildHistoryQuery;
+  }, EndEvent$1<BuildHistoryResponse>];
+  "build-history:update": [{
+    id: string;
+    updates: Partial<BuildHistoryEntry>;
+    pipelineId?: string;
+  }, EndEvent$1<{
+    result: "ok" | "ko";
+  }>];
+  "build-history:delete": [{
+    id: string;
+    pipelineId?: string;
+  }, EndEvent$1<{
+    result: "ok" | "ko";
+  }>];
+  "build-history:clear": [void, EndEvent$1<{
+    result: "ok" | "ko";
+  }>];
+  "build-history:get-storage-info": [void, EndEvent$1<{
+    totalEntries: number;
+    totalSize: number;
+    oldestEntry?: number;
+    newestEntry?: number;
+  }>];
+  "build-history:configure": [{
+    config: Partial<BuildHistoryConfig>;
+  }, EndEvent$1<{
+    result: "ok" | "ko";
+  }>];
+  "agents:get": [void, EndEvent$1<{
+    agents: Agent[];
+  }>];
+  "graph:execute": [{
+    graph: any[];
+    variables: any[];
+    pipelineId?: string;
+    projectId?: string;
+    projectName?: string;
+    projectPath?: string;
+  }, ({
+    type: "node-enter";
+    data: {
+      nodeUid: string;
+      nodeName: string;
+    };
+  } | {
+    type: "node-exit";
+    data: {
+      nodeUid: string;
+      nodeName: string;
+    };
+  } | {
+    type: "node-log";
+    data: {
+      nodeUid: string;
+      logData: any;
+    };
+  } | EndEvent$1<{
+    result: any;
+    buildId: string;
+  }>)];
+  "auth:getUser": [void, EndEvent$1<{
+    user: User | null;
+  }>];
+  "auth:signInWithPassword": [{
+    email: string;
+    password: string;
+  }, EndEvent$1<UserResponse>];
+  "auth:signUp": [{
+    email: string;
+    password: string;
+  }, EndEvent$1<UserResponse>];
+  "auth:signOut": [void, EndEvent$1<void>];
+  "auth:resetPasswordForEmail": [{
+    email: string;
+  }, EndEvent$1<{
+    error: any | null;
+  }>];
+  "auth:invoke": [{
+    name: string;
+    options?: any;
+  }, EndEvent$1<{
+    data: any | null;
+    error: any | null;
+  }>];
+  "agent:version:get": [void, EndEvent$1<{
+    version: string;
+  }>];
+};
+type Channels = keyof IpcDefinition$1;
+declare const ShellChannels: Channels[];
+type Data$1<KEY extends Channels> = IpcDefinition$1[KEY][0];
+type Events<KEY extends Channels> = IpcDefinition$1[KEY][1];
+type End<KEY extends Channels> = Extract<IpcDefinition$1[KEY][1], {
+  type: "end";
+}>["data"];
+type IpcMessage = {
+  requestId: RequestId$1;
+  data: any;
+};
+type RequestId$1 = Tagged<string, "request-id">;
+//#endregion
+//#region src/config.schema.d.ts
+declare const createVersionSchema: <T extends GenericSchema<any, any>>(schema: T) => T;
+declare const AppSettingsValidatorV1: valibot.ObjectSchema<{
+  readonly cacheFolder: valibot.StringSchema<undefined>;
+  readonly theme: valibot.UnionSchema<[valibot.LiteralSchema<"light", undefined>, valibot.LiteralSchema<"dark", undefined>], undefined>;
+  readonly version: valibot.LiteralSchema<"1.0.0", undefined>;
+}, undefined>;
+declare const AppSettingsValidatorV2: valibot.ObjectSchema<{
+  readonly cacheFolder: valibot.StringSchema<undefined>;
+  readonly theme: valibot.UnionSchema<[valibot.LiteralSchema<"light", undefined>, valibot.LiteralSchema<"dark", undefined>], undefined>;
+  readonly version: valibot.LiteralSchema<"2.0.0", undefined>;
+}, undefined>;
+declare const AppSettingsValidatorV3: valibot.ObjectSchema<{
+  readonly cacheFolder: valibot.StringSchema<undefined>;
+  readonly theme: valibot.UnionSchema<[valibot.LiteralSchema<"light", undefined>, valibot.LiteralSchema<"dark", undefined>], undefined>;
+  readonly version: valibot.LiteralSchema<"3.0.0", undefined>;
+  readonly clearTemporaryFoldersOnPipelineEnd: valibot.BooleanSchema<undefined>;
+}, undefined>;
+declare const AppSettingsValidatorV4: valibot.ObjectSchema<{
+  readonly theme: valibot.UnionSchema<[valibot.LiteralSchema<"light", undefined>, valibot.LiteralSchema<"dark", undefined>], undefined>;
+  readonly version: valibot.LiteralSchema<"4.0.0", undefined>;
+  readonly cacheFolder: valibot.StringSchema<undefined>;
+  readonly clearTemporaryFoldersOnPipelineEnd: valibot.BooleanSchema<undefined>;
+  readonly locale: valibot.UnionSchema<[valibot.LiteralSchema<"en-US", undefined>, valibot.LiteralSchema<"fr-FR", undefined>, valibot.LiteralSchema<"pt-BR", undefined>, valibot.LiteralSchema<"zh-CN", undefined>, valibot.LiteralSchema<"es-ES", undefined>, valibot.LiteralSchema<"de-DE", undefined>], undefined>;
+}, undefined>;
+declare const AppSettingsValidatorV5: valibot.ObjectSchema<{
+  readonly theme: valibot.UnionSchema<[valibot.LiteralSchema<"light", undefined>, valibot.LiteralSchema<"dark", undefined>], undefined>;
+  readonly version: valibot.LiteralSchema<"5.0.0", undefined>;
+  readonly cacheFolder: valibot.StringSchema<undefined>;
+  readonly clearTemporaryFoldersOnPipelineEnd: valibot.BooleanSchema<undefined>;
+  readonly locale: valibot.UnionSchema<[valibot.LiteralSchema<"en-US", undefined>, valibot.LiteralSchema<"fr-FR", undefined>, valibot.LiteralSchema<"pt-BR", undefined>, valibot.LiteralSchema<"zh-CN", undefined>, valibot.LiteralSchema<"es-ES", undefined>, valibot.LiteralSchema<"de-DE", undefined>], undefined>;
+  readonly tours: valibot.ObjectSchema<{
+    readonly dashboard: valibot.ObjectSchema<{
+      readonly step: valibot.NumberSchema<undefined>;
+      readonly completed: valibot.BooleanSchema<undefined>;
+    }, undefined>;
+    readonly editor: valibot.ObjectSchema<{
+      readonly step: valibot.NumberSchema<undefined>;
+      readonly completed: valibot.BooleanSchema<undefined>;
+    }, undefined>;
+  }, undefined>;
+}, undefined>;
+declare const AppSettingsValidatorV6: valibot.ObjectSchema<{
+  readonly theme: valibot.UnionSchema<[valibot.LiteralSchema<"light", undefined>, valibot.LiteralSchema<"dark", undefined>], undefined>;
+  readonly version: valibot.LiteralSchema<"6.0.0", undefined>;
+  readonly cacheFolder: valibot.StringSchema<undefined>;
+  readonly clearTemporaryFoldersOnPipelineEnd: valibot.BooleanSchema<undefined>;
+  readonly locale: valibot.UnionSchema<[valibot.LiteralSchema<"en-US", undefined>, valibot.LiteralSchema<"fr-FR", undefined>, valibot.LiteralSchema<"pt-BR", undefined>, valibot.LiteralSchema<"zh-CN", undefined>, valibot.LiteralSchema<"es-ES", undefined>, valibot.LiteralSchema<"de-DE", undefined>], undefined>;
+  readonly tours: valibot.ObjectSchema<{
+    readonly dashboard: valibot.ObjectSchema<{
+      readonly step: valibot.NumberSchema<undefined>;
+      readonly completed: valibot.BooleanSchema<undefined>;
+    }, undefined>;
+    readonly editor: valibot.ObjectSchema<{
+      readonly step: valibot.NumberSchema<undefined>;
+      readonly completed: valibot.BooleanSchema<undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly autosave: valibot.BooleanSchema<undefined>;
+}, undefined>;
+declare const AppSettingsValidatorV7: valibot.ObjectSchema<{
+  readonly theme: valibot.UnionSchema<[valibot.LiteralSchema<"light", undefined>, valibot.LiteralSchema<"dark", undefined>], undefined>;
+  readonly version: valibot.LiteralSchema<"7.0.0", undefined>;
+  readonly cacheFolder: valibot.StringSchema<undefined>;
+  readonly clearTemporaryFoldersOnPipelineEnd: valibot.BooleanSchema<undefined>;
+  readonly locale: valibot.UnionSchema<[valibot.LiteralSchema<"en-US", undefined>, valibot.LiteralSchema<"fr-FR", undefined>, valibot.LiteralSchema<"pt-BR", undefined>, valibot.LiteralSchema<"zh-CN", undefined>, valibot.LiteralSchema<"es-ES", undefined>, valibot.LiteralSchema<"de-DE", undefined>], undefined>;
+  readonly tours: valibot.ObjectSchema<{
+    readonly dashboard: valibot.ObjectSchema<{
+      readonly step: valibot.NumberSchema<undefined>;
+      readonly completed: valibot.BooleanSchema<undefined>;
+    }, undefined>;
+    readonly editor: valibot.ObjectSchema<{
+      readonly step: valibot.NumberSchema<undefined>;
+      readonly completed: valibot.BooleanSchema<undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly autosave: valibot.BooleanSchema<undefined>;
+  readonly agents: valibot.ArraySchema<valibot.ObjectSchema<{
+    readonly id: valibot.StringSchema<undefined>;
+    readonly name: valibot.StringSchema<undefined>;
+    readonly url: valibot.StringSchema<undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+type AppConfigV1 = InferInput<typeof AppSettingsValidatorV1>;
+type AppConfigV2 = InferInput<typeof AppSettingsValidatorV2>;
+type AppConfigV3 = InferInput<typeof AppSettingsValidatorV3>;
+type AppConfigV4 = InferInput<typeof AppSettingsValidatorV4>;
+type AppConfigV5 = InferInput<typeof AppSettingsValidatorV5>;
+type AppConfigV6 = InferInput<typeof AppSettingsValidatorV6>;
+type AppConfigV7 = InferInput<typeof AppSettingsValidatorV7>;
+type AppConfig = AppConfigV7;
+declare const AppSettingsValidator: valibot.ObjectSchema<{
+  readonly theme: valibot.UnionSchema<[valibot.LiteralSchema<"light", undefined>, valibot.LiteralSchema<"dark", undefined>], undefined>;
+  readonly version: valibot.LiteralSchema<"7.0.0", undefined>;
+  readonly cacheFolder: valibot.StringSchema<undefined>;
+  readonly clearTemporaryFoldersOnPipelineEnd: valibot.BooleanSchema<undefined>;
+  readonly locale: valibot.UnionSchema<[valibot.LiteralSchema<"en-US", undefined>, valibot.LiteralSchema<"fr-FR", undefined>, valibot.LiteralSchema<"pt-BR", undefined>, valibot.LiteralSchema<"zh-CN", undefined>, valibot.LiteralSchema<"es-ES", undefined>, valibot.LiteralSchema<"de-DE", undefined>], undefined>;
+  readonly tours: valibot.ObjectSchema<{
+    readonly dashboard: valibot.ObjectSchema<{
+      readonly step: valibot.NumberSchema<undefined>;
+      readonly completed: valibot.BooleanSchema<undefined>;
+    }, undefined>;
+    readonly editor: valibot.ObjectSchema<{
+      readonly step: valibot.NumberSchema<undefined>;
+      readonly completed: valibot.BooleanSchema<undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly autosave: valibot.BooleanSchema<undefined>;
+  readonly agents: valibot.ArraySchema<valibot.ObjectSchema<{
+    readonly id: valibot.StringSchema<undefined>;
+    readonly name: valibot.StringSchema<undefined>;
+    readonly url: valibot.StringSchema<undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+//#endregion
+//#region src/database.types.d.ts
+type Json = string | number | boolean | null | {
+  [key: string]: Json | undefined;
+} | Json[];
+type Database = {
+  public: {
+    Tables: { [_ in never]: never };
+    Views: { [_ in never]: never };
+    Functions: { [_ in never]: never };
+    Enums: { [_ in never]: never };
+    CompositeTypes: { [_ in never]: never };
+  };
+};
+type PublicSchema = Database[Extract<keyof Database, "public">];
+type Tables<PublicTableNameOrOptions extends keyof (PublicSchema["Tables"] & PublicSchema["Views"]) | {
+  schema: keyof Database;
+}, TableName extends (PublicTableNameOrOptions extends {
+  schema: keyof Database;
+} ? keyof (Database[PublicTableNameOrOptions["schema"]]["Tables"] & Database[PublicTableNameOrOptions["schema"]]["Views"]) : never) = never> = PublicTableNameOrOptions extends {
+  schema: keyof Database;
+} ? (Database[PublicTableNameOrOptions["schema"]]["Tables"] & Database[PublicTableNameOrOptions["schema"]]["Views"])[TableName] extends {
+  Row: infer R;
+} ? R : never : PublicTableNameOrOptions extends keyof (PublicSchema["Tables"] & PublicSchema["Views"]) ? (PublicSchema["Tables"] & PublicSchema["Views"])[PublicTableNameOrOptions] extends {
+  Row: infer R;
+} ? R : never : never;
+type TablesInsert<PublicTableNameOrOptions extends keyof PublicSchema["Tables"] | {
+  schema: keyof Database;
+}, TableName extends (PublicTableNameOrOptions extends {
+  schema: keyof Database;
+} ? keyof Database[PublicTableNameOrOptions["schema"]]["Tables"] : never) = never> = PublicTableNameOrOptions extends {
+  schema: keyof Database;
+} ? Database[PublicTableNameOrOptions["schema"]]["Tables"][TableName] extends {
+  Insert: infer I;
+} ? I : never : PublicTableNameOrOptions extends keyof PublicSchema["Tables"] ? PublicSchema["Tables"][PublicTableNameOrOptions] extends {
+  Insert: infer I;
+} ? I : never : never;
+type TablesUpdate<PublicTableNameOrOptions extends keyof PublicSchema["Tables"] | {
+  schema: keyof Database;
+}, TableName extends (PublicTableNameOrOptions extends {
+  schema: keyof Database;
+} ? keyof Database[PublicTableNameOrOptions["schema"]]["Tables"] : never) = never> = PublicTableNameOrOptions extends {
+  schema: keyof Database;
+} ? Database[PublicTableNameOrOptions["schema"]]["Tables"][TableName] extends {
+  Update: infer U;
+} ? U : never : PublicTableNameOrOptions extends keyof PublicSchema["Tables"] ? PublicSchema["Tables"][PublicTableNameOrOptions] extends {
+  Update: infer U;
+} ? U : never : never;
+type Enums<PublicEnumNameOrOptions extends keyof PublicSchema["Enums"] | {
+  schema: keyof Database;
+}, EnumName extends (PublicEnumNameOrOptions extends {
+  schema: keyof Database;
+} ? keyof Database[PublicEnumNameOrOptions["schema"]]["Enums"] : never) = never> = PublicEnumNameOrOptions extends {
+  schema: keyof Database;
+} ? Database[PublicEnumNameOrOptions["schema"]]["Enums"][EnumName] : PublicEnumNameOrOptions extends keyof PublicSchema["Enums"] ? PublicSchema["Enums"][PublicEnumNameOrOptions] : never;
+//#endregion
+//#region src/evaluator.d.ts
+declare const makeResolvedParams: (data: {
+  params: BlockAction["params"];
+  steps: Steps;
+  variables: Record<string, string>;
+  context: Record<string, unknown>;
+}, onItem?: (item: any) => string, _vm?: Awaited<CreateQuickJSFn> | undefined) => Promise<Record<string, any>>;
+//#endregion
+//#region src/fmt.d.ts
+declare const fmt: {
+  param: (value: string, variant?: "primary" | "secondary" | undefined, ifEmpty?: string) => string;
+};
+//#endregion
+//#region src/types.d.ts
+type Context = Record<string, unknown>;
+//#endregion
+//#region src/graph.d.ts
+declare const processGraph: (options: {
+  graph: Array<Block>;
+  definitions: Array<RendererPluginDefinition>;
+  variables: Array<Variable>;
+  steps: Steps;
+  context: Context;
+  onExecuteItem: (node: Block, params: Record<string, string>, steps: Steps) => Promise<End<"condition:execute"> | End<"action:execute">>;
+  onNodeEnter: (node: Block) => void;
+  onNodeExit: (node: Block) => void;
+  abortSignal?: AbortSignal;
+}) => Promise<{
+  graph: Array<Block>;
+  definitions: Array<RendererPluginDefinition>;
+  variables: Array<Variable>;
+  steps: Steps;
+  context: Context;
+  onExecuteItem: (node: Block, params: Record<string, string>, steps: Steps) => Promise<End<"condition:execute"> | End<"action:execute">>;
+  onNodeEnter: (node: Block) => void;
+  onNodeExit: (node: Block) => void;
+  abortSignal?: AbortSignal;
+}>;
+//#endregion
+//#region src/i18n/en_US.json.d.ts
+declare let settings$5: {
+  darkTheme: string;
+  autosave: string;
+  autosaveDescription: string;
+  language: string;
+  languageOptions: {
+    "en-US": string;
+    "fr-FR": string;
+    "pt-BR": string;
+    "zh-CN": string;
+    "es-ES": string;
+    "de-DE": string;
+  };
+  tabs: {
+    general: string;
+    storage: string;
+    integrations: string;
+    advanced: string;
+    billing: string;
+  };
+  clearTempFolders: string;
+  clearTempFoldersDescription: string;
+  "pipeline-cache-folder": string;
+  "enter-or-browse-for-a-folder": string;
+  browse: string;
+  "manage-where-the-app-stores-temporary-and-cache-files": string;
+  "clear-cache": string;
+  "reset-to-default": string;
+  "manage-subscription": string;
+  "renewal-date": string;
+  "start-date": string;
+  "cache-cleared-successfully": string;
+  "failed-to-clear-cache-error-message": string;
+  "failed-to-reset-cache-folder-error-message": string;
+  "select-cache-folder": string;
+  "restart-dashboard-tour": string;
+  "restart-editor-tour": string;
+  "tour-reset-success": string;
+};
+declare namespace headers$5 {
+  let dashboard: string;
+  let scenarios: string;
+  let editor: string;
+  let billing: string;
+  let team: string;
+}
+declare let navigation: {
+  "build-history": string;
+};
+declare namespace base$5 {
+  export let close: string;
+  export let save: string;
+  export let run: string;
+  export let cancel: string;
+  export let end: string;
+  let _delete: string;
+  export { _delete as delete };
+  export let logs: string;
+  export let ok: string;
+  export let add: string;
+  export let search: string;
+}
+declare let editor_1$5: {
+  "invalid-file-content": string;
+  "welcome-back": string;
+  "please-log-in-to-run-a-scenario": string;
+  "execution-done": string;
+  "your-project-has-been-executed-successfully": string;
+  "execution-failed": string;
+  "project-has-encountered-an-error": string;
+  "project-saved": string;
+  "your-project-has-be-saved-successfully": string;
+  "view-history": string;
+  "add-plugin": string;
+  "display-advanced-nodes": string;
+};
+declare let home$5: {
+  "invalid-preset": string;
+  "store-project-on-the-cloud": string;
+  cloud: string;
+  "store-project-locally": string;
+  local: string;
+  "invalid-number-of-paths-selected": string;
+  "pipelab-project": string;
+  "choose-a-new-path": string;
+  "invalid-file-type": string;
+  "create-project": string;
+  "duplicate-project": string;
+  "project-name": string;
+  "new-project": string;
+  "new-pipeline": string;
+  open: string;
+  import: string;
+  "pipeline-name": string;
+  "your-projects": string;
+  "no-projects-yet": string;
+  "no-pipelines-yet": string;
+  "delete-project": string;
+  "confirm-delete-project": string;
+  "cannot-delete-project": string;
+  "project-not-empty": string;
+  transfer: string;
+  "transfer-successful": string;
+  "pipeline-transferred": string;
+  "select-project": string;
+  "build-history": string;
+  duplicate: string;
+  "rename-project": string;
+  "new-project-name": string;
+  "premium-feature": string;
+  "migrate-warning": string;
+  "simple-pipeline": string;
+  "advanced-pipeline": string;
+  "new-simple-project": string;
+  "new-advanced-project": string;
+  "store-project-internally": string;
+  internal: string;
+  "confirm-migration-message": string;
+  "migrate-pipeline": string;
+  "migration-success": string;
+  "migrate-to-internal": string;
+};
+declare namespace scenarios_1$5 {
+  let scenarios_2: string;
+  export { scenarios_2 as scenarios };
+}
+declare let tour: {
+  "start-tour": string;
+  "projects-list-title": string;
+  "projects-list-description": string;
+  "add-project-title": string;
+  "add-project-description": string;
+  "new-pipeline-title": string;
+  "new-pipeline-description": string;
+  "project-actions-title": string;
+  "project-actions-description": string;
+  "editor-canvas-title": string;
+  "editor-canvas-description": string;
+  "editor-save-title": string;
+  "editor-save-description": string;
+  "editor-run-title": string;
+  "editor-run-description": string;
+  "editor-logs-title": string;
+  "editor-logs-description": string;
+  "editor-close-title": string;
+  "editor-close-description": string;
+};
+declare namespace __json_default_export$1 {
+  export { settings$5 as settings, headers$5 as headers, navigation, base$5 as base, home$5 as home, scenarios_1$5 as scenarios_1, tour, editor_1$5 as editor, scenarios_1$5 as scenarios };
+}
+//#endregion
+//#region src/i18n/fr_FR.json.d.ts
+declare let settings$4: {
+  darkTheme: string;
+  language: string;
+  languageOptions: {
+    "en-US": string;
+    "fr-FR": string;
+    "pt-BR": string;
+    "zh-CN": string;
+    "es-ES": string;
+    "de-DE": string;
+  };
+  tabs: {
+    general: string;
+    storage: string;
+    integrations: string;
+    advanced: string;
+    billing: string;
+  };
+  clearTempFolders: string;
+  clearTempFoldersDescription: string;
+  "pipeline-cache-folder": string;
+  "enter-or-browse-for-a-folder": string;
+  browse: string;
+  "manage-where-the-app-stores-temporary-and-cache-files": string;
+  "clear-cache": string;
+  "reset-to-default": string;
+  "manage-subscription": string;
+  "renewal-date": string;
+  "start-date": string;
+  "cache-cleared-successfully": string;
+  "failed-to-clear-cache-error-message": string;
+  "failed-to-reset-cache-folder-error-message": string;
+  "select-cache-folder": string;
+};
+declare namespace headers$4 {
+  let dashboard: string;
+  let scenarios: string;
+  let editor: string;
+  let billing: string;
+  let team: string;
+}
+declare namespace base$4 {
+  export let close: string;
+  export let save: string;
+  export let run: string;
+  export let cancel: string;
+  export let end: string;
+  let _delete: string;
+  export { _delete as delete };
+  export let logs: string;
+  export let ok: string;
+  export let add: string;
+  export let search: string;
+}
+declare let editor_1$4: {
+  "invalid-file-content": string;
+  "welcome-back": string;
+  "please-log-in-to-run-a-scenario": string;
+  "execution-done": string;
+  "your-project-has-been-executed-successfully": string;
+  "execution-failed": string;
+  "project-has-encountered-an-error": string;
+  "project-saved": string;
+  "your-project-has-be-saved-successfully": string;
+  "add-plugin": string;
+  "display-advanced-nodes": string;
+};
+declare let home$4: {
+  "invalid-preset": string;
+  "store-project-on-the-cloud": string;
+  cloud: string;
+  "store-project-locally": string;
+  local: string;
+  "invalid-number-of-paths-selected": string;
+  "pipelab-project": string;
+  "choose-a-new-path": string;
+  "invalid-file-type": string;
+  "create-project": string;
+  "duplicate-project": string;
+  "project-name": string;
+  "new-project": string;
+  open: string;
+  "your-projects": string;
+  "no-projects-yet": string;
+};
+declare namespace scenarios_1$4 {
+  let scenarios_2: string;
+  export { scenarios_2 as scenarios };
+}
+declare namespace __json_default_export$3 {
+  export { settings$4 as settings, headers$4 as headers, base$4 as base, home$4 as home, scenarios_1$4 as scenarios_1, editor_1$4 as editor, scenarios_1$4 as scenarios };
+}
+//#endregion
+//#region src/i18n/pt_BR.json.d.ts
+declare let settings$3: {
+  darkTheme: string;
+  language: string;
+  languageOptions: {
+    "en-US": string;
+    "fr-FR": string;
+    "pt-BR": string;
+    "zh-CN": string;
+    "es-ES": string;
+    "de-DE": string;
+  };
+  tabs: {
+    general: string;
+    storage: string;
+    integrations: string;
+    advanced: string;
+    billing: string;
+  };
+  clearTempFolders: string;
+  clearTempFoldersDescription: string;
+  "pipeline-cache-folder": string;
+  "enter-or-browse-for-a-folder": string;
+  browse: string;
+  "manage-where-the-app-stores-temporary-and-cache-files": string;
+  "clear-cache": string;
+  "reset-to-default": string;
+  "manage-subscription": string;
+  "renewal-date": string;
+  "start-date": string;
+  "cache-cleared-successfully": string;
+  "failed-to-clear-cache-error-message": string;
+  "failed-to-reset-cache-folder-error-message": string;
+  "select-cache-folder": string;
+};
+declare namespace headers$3 {
+  let dashboard: string;
+  let scenarios: string;
+  let editor: string;
+  let billing: string;
+  let team: string;
+}
+declare namespace base$3 {
+  export let close: string;
+  export let save: string;
+  export let run: string;
+  export let cancel: string;
+  export let end: string;
+  let _delete: string;
+  export { _delete as delete };
+  export let logs: string;
+  export let ok: string;
+  export let add: string;
+}
+declare let editor_1$3: {
+  "invalid-file-content": string;
+  "welcome-back": string;
+  "please-log-in-to-run-a-scenario": string;
+  "execution-done": string;
+  "your-project-has-been-executed-successfully": string;
+  "execution-failed": string;
+  "project-has-encountered-an-error": string;
+  "project-saved": string;
+  "your-project-has-be-saved-successfully": string;
+};
+declare let home$3: {
+  "invalid-preset": string;
+  "store-project-on-the-cloud": string;
+  cloud: string;
+  "store-project-locally": string;
+  local: string;
+  "invalid-number-of-paths-selected": string;
+  "pipelab-project": string;
+  "choose-a-new-path": string;
+  "invalid-file-type": string;
+  "create-project": string;
+  "duplicate-project": string;
+  "project-name": string;
+  "new-project": string;
+  open: string;
+  "your-projects": string;
+  "no-projects-yet": string;
+};
+declare namespace scenarios_1$3 {
+  let scenarios_2: string;
+  export { scenarios_2 as scenarios };
+}
+declare namespace __json_default_export$4 {
+  export { settings$3 as settings, headers$3 as headers, base$3 as base, home$3 as home, scenarios_1$3 as scenarios_1, editor_1$3 as editor, scenarios_1$3 as scenarios };
+}
+//#endregion
+//#region src/i18n/zh_CN.json.d.ts
+declare let settings$2: {
+  darkTheme: string;
+  language: string;
+  languageOptions: {
+    "en-US": string;
+    "fr-FR": string;
+    "pt-BR": string;
+    "zh-CN": string;
+    "es-ES": string;
+    "de-DE": string;
+  };
+  tabs: {
+    general: string;
+    storage: string;
+    integrations: string;
+    advanced: string;
+    billing: string;
+  };
+  clearTempFolders: string;
+  clearTempFoldersDescription: string;
+  "pipeline-cache-folder": string;
+  "enter-or-browse-for-a-folder": string;
+  browse: string;
+  "manage-where-the-app-stores-temporary-and-cache-files": string;
+  "clear-cache": string;
+  "reset-to-default": string;
+  "manage-subscription": string;
+  "renewal-date": string;
+  "start-date": string;
+  "cache-cleared-successfully": string;
+  "failed-to-clear-cache-error-message": string;
+  "failed-to-reset-cache-folder-error-message": string;
+  "select-cache-folder": string;
+};
+declare namespace headers$2 {
+  let dashboard: string;
+  let scenarios: string;
+  let editor: string;
+  let billing: string;
+  let team: string;
+}
+declare namespace base$2 {
+  export let close: string;
+  export let save: string;
+  export let run: string;
+  export let cancel: string;
+  export let end: string;
+  let _delete: string;
+  export { _delete as delete };
+  export let logs: string;
+  export let ok: string;
+  export let add: string;
+}
+declare let editor_1$2: {
+  "invalid-file-content": string;
+  "welcome-back": string;
+  "please-log-in-to-run-a-scenario": string;
+  "execution-done": string;
+  "your-project-has-been-executed-successfully": string;
+  "execution-failed": string;
+  "project-has-encountered-an-error": string;
+  "project-saved": string;
+  "your-project-has-be-saved-successfully": string;
+};
+declare let home$2: {
+  "invalid-preset": string;
+  "store-project-on-the-cloud": string;
+  cloud: string;
+  "store-project-locally": string;
+  local: string;
+  "invalid-number-of-paths-selected": string;
+  "pipelab-project": string;
+  "choose-a-new-path": string;
+  "invalid-file-type": string;
+  "create-project": string;
+  "duplicate-project": string;
+  "project-name": string;
+  "new-project": string;
+  open: string;
+  "your-projects": string;
+  "no-projects-yet": string;
+};
+declare namespace scenarios_1$2 {
+  let scenarios_2: string;
+  export { scenarios_2 as scenarios };
+}
+declare namespace __json_default_export$5 {
+  export { settings$2 as settings, headers$2 as headers, base$2 as base, home$2 as home, scenarios_1$2 as scenarios_1, editor_1$2 as editor, scenarios_1$2 as scenarios };
+}
+//#endregion
+//#region src/i18n/es_ES.json.d.ts
+declare let settings$1: {
+  darkTheme: string;
+  language: string;
+  languageOptions: {
+    "en-US": string;
+    "fr-FR": string;
+    "pt-BR": string;
+    "zh-CN": string;
+    "es-ES": string;
+    "de-DE": string;
+  };
+  tabs: {
+    general: string;
+    storage: string;
+    integrations: string;
+    advanced: string;
+    billing: string;
+  };
+  clearTempFolders: string;
+  clearTempFoldersDescription: string;
+  "pipeline-cache-folder": string;
+  "enter-or-browse-for-a-folder": string;
+  browse: string;
+  "manage-where-the-app-stores-temporary-and-cache-files": string;
+  "clear-cache": string;
+  "reset-to-default": string;
+  "manage-subscription": string;
+  "renewal-date": string;
+  "start-date": string;
+  "cache-cleared-successfully": string;
+  "failed-to-clear-cache-error-message": string;
+  "failed-to-reset-cache-folder-error-message": string;
+  "select-cache-folder": string;
+};
+declare namespace headers$1 {
+  let dashboard: string;
+  let scenarios: string;
+  let editor: string;
+  let billing: string;
+  let team: string;
+}
+declare namespace base$1 {
+  export let close: string;
+  export let save: string;
+  export let run: string;
+  export let cancel: string;
+  export let end: string;
+  let _delete: string;
+  export { _delete as delete };
+  export let logs: string;
+  export let ok: string;
+  export let add: string;
+}
+declare let editor_1$1: {
+  "invalid-file-content": string;
+  "welcome-back": string;
+  "please-log-in-to-run-a-scenario": string;
+  "execution-done": string;
+  "your-project-has-been-executed-successfully": string;
+  "execution-failed": string;
+  "project-has-encountered-an-error": string;
+  "project-saved": string;
+  "your-project-has-be-saved-successfully": string;
+};
+declare let home$1: {
+  "invalid-preset": string;
+  "store-project-on-the-cloud": string;
+  cloud: string;
+  "store-project-locally": string;
+  local: string;
+  "invalid-number-of-paths-selected": string;
+  "pipelab-project": string;
+  "choose-a-new-path": string;
+  "invalid-file-type": string;
+  "create-project": string;
+  "duplicate-project": string;
+  "project-name": string;
+  "new-project": string;
+  open: string;
+  "your-projects": string;
+  "no-projects-yet": string;
+};
+declare namespace scenarios_1$1 {
+  let scenarios_2: string;
+  export { scenarios_2 as scenarios };
+}
+declare namespace __json_default_export$2 {
+  export { settings$1 as settings, headers$1 as headers, base$1 as base, home$1 as home, scenarios_1$1 as scenarios_1, editor_1$1 as editor, scenarios_1$1 as scenarios };
+}
+//#endregion
+//#region src/i18n/de_DE.json.d.ts
+declare let settings: {
+  darkTheme: string;
+  language: string;
+  languageOptions: {
+    "en-US": string;
+    "fr-FR": string;
+    "pt-BR": string;
+    "zh-CN": string;
+    "es-ES": string;
+    "de-DE": string;
+  };
+  tabs: {
+    general: string;
+    storage: string;
+    integrations: string;
+    advanced: string;
+    billing: string;
+  };
+  clearTempFolders: string;
+  clearTempFoldersDescription: string;
+  "pipeline-cache-folder": string;
+  "enter-or-browse-for-a-folder": string;
+  browse: string;
+  "manage-where-the-app-stores-temporary-and-cache-files": string;
+  "clear-cache": string;
+  "reset-to-default": string;
+  "manage-subscription": string;
+  "renewal-date": string;
+  "start-date": string;
+  "cache-cleared-successfully": string;
+  "failed-to-clear-cache-error-message": string;
+  "failed-to-reset-cache-folder-error-message": string;
+  "select-cache-folder": string;
+};
+declare namespace headers {
+  let dashboard: string;
+  let scenarios: string;
+  let editor: string;
+  let billing: string;
+  let team: string;
+}
+declare namespace base {
+  export let close: string;
+  export let save: string;
+  export let run: string;
+  export let cancel: string;
+  export let end: string;
+  let _delete: string;
+  export { _delete as delete };
+  export let logs: string;
+  export let ok: string;
+  export let add: string;
+}
+declare let editor_1: {
+  "invalid-file-content": string;
+  "welcome-back": string;
+  "please-log-in-to-run-a-scenario": string;
+  "execution-done": string;
+  "your-project-has-been-executed-successfully": string;
+  "execution-failed": string;
+  "project-has-encountered-an-error": string;
+  "project-saved": string;
+  "your-project-has-be-saved-successfully": string;
+};
+declare let home: {
+  "invalid-preset": string;
+  "store-project-on-the-cloud": string;
+  cloud: string;
+  "store-project-locally": string;
+  local: string;
+  "invalid-number-of-paths-selected": string;
+  "pipelab-project": string;
+  "choose-a-new-path": string;
+  "invalid-file-type": string;
+  "create-project": string;
+  "duplicate-project": string;
+  "project-name": string;
+  "new-project": string;
+  open: string;
+  "your-projects": string;
+  "no-projects-yet": string;
+};
+declare namespace scenarios_1 {
+  let scenarios_2: string;
+  export { scenarios_2 as scenarios };
+}
+declare namespace __json_default_export {
+  export { settings, headers, base, home, scenarios_1, editor_1 as editor, scenarios_1 as scenarios };
+}
+//#endregion
+//#region src/i18n-utils.d.ts
+type MessageSchema = typeof __json_default_export$1;
+type Locales = "en-US" | "fr-FR" | "pt-BR" | "zh-CN" | "es-ES" | "de-DE";
+//#endregion
+//#region src/ipc.types.d.ts
+type UpdateStatus = "update-available" | "update-downloaded" | "checking-for-update" | "update-not-available" | "error";
+type IpcEvent<TYPE extends string, DATA> = {
+  type: TYPE;
+  data: DATA;
+};
+type EndEvent<DATA> = {
+  type: "end";
+  data: {
+    type: "success";
+    result: DATA;
+  } | {
+    type: "error";
+    ipcError: string;
+  };
+};
+type IpcDefinition = {
+  "dialog:alert": [{
+    message: string;
+    buttons?: {
+      title: string;
+      value: string;
+    }[];
+  }, EndEvent<{
+    answer: string;
+  }>];
+  "dialog:prompt": [{
+    message: string;
+    buttons?: {
+      title: string;
+      value: string;
+    }[];
+  }, EndEvent<{
+    answer: string;
+  }>];
+  "log:message": [ILogObjMeta, EndEvent<void>];
+  "update:set-status": [{
+    status: UpdateStatus;
+  }, EndEvent<void>];
+};
+type RendererChannels = keyof IpcDefinition;
+type RendererData<KEY extends RendererChannels> = IpcDefinition[KEY][0];
+type RendererEvents<KEY extends RendererChannels> = IpcDefinition[KEY][1];
+type RendererEnd<KEY extends RendererChannels> = Extract<IpcDefinition[KEY][1], {
+  type: "end";
+}>["data"];
+type RendererMessage = {
+  requestId: RequestId;
+  data: any;
+};
+type RequestId = Tagged<string, "request-id">;
+type HandleListenerRendererSendFn<KEY extends RendererChannels> = (events: RendererEvents<KEY>) => void;
+type HandleListenerRenderer<KEY extends RendererChannels> = (event: any, data: {
+  value: RendererData<KEY>;
+  send: HandleListenerRendererSendFn<KEY>;
+}) => Promise<void>;
+//#endregion
+//#region src/logger.d.ts
+declare const useLogger: () => {
+  logger: () => Logger<unknown>;
+  attachTransport: (transport: (logObj: unknown) => void) => void;
+};
+//#endregion
+//#region ../../node_modules/vue/node_modules/@vue/shared/dist/shared.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+//#endregion
+//#region ../../node_modules/vue/node_modules/@vue/reactivity/dist/reactivity.d.ts
+declare enum TrackOpTypes {
+  GET = "get",
+  HAS = "has",
+  ITERATE = "iterate"
+}
+declare enum TriggerOpTypes {
+  SET = "set",
+  ADD = "add",
+  DELETE = "delete",
+  CLEAR = "clear"
+}
+type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
+declare const ShallowReactiveMarker: unique symbol;
+type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+type Builtin = Primitive | Function | Date | Error | RegExp;
+type EffectScheduler = (...args: any[]) => any;
+type DebuggerEvent = {
+  effect: Subscriber;
+} & DebuggerEventExtraInfo;
+type DebuggerEventExtraInfo = {
+  target: object;
+  type: TrackOpTypes | TriggerOpTypes;
+  key: any;
+  newValue?: any;
+  oldValue?: any;
+  oldTarget?: Map<any, any> | Set<any>;
+};
+interface DebuggerOptions {
+  onTrack?: (event: DebuggerEvent) => void;
+  onTrigger?: (event: DebuggerEvent) => void;
+}
+interface ReactiveEffectOptions extends DebuggerOptions {
+  scheduler?: EffectScheduler;
+  allowRecurse?: boolean;
+  onStop?: () => void;
+}
+/**
+ * Subscriber is a type that tracks (or subscribes to) a list of deps.
+ */
+interface Subscriber extends DebuggerOptions {}
+declare class ReactiveEffect<T = any> implements Subscriber, ReactiveEffectOptions {
+  fn: () => T;
+  scheduler?: EffectScheduler;
+  onStop?: () => void;
+  onTrack?: (event: DebuggerEvent) => void;
+  onTrigger?: (event: DebuggerEvent) => void;
+  constructor(fn: () => T);
+  pause(): void;
+  resume(): void;
+  run(): T;
+  stop(): void;
+  trigger(): void;
+  get dirty(): boolean;
+}
+type ComputedGetter<T> = (oldValue?: T) => T;
+type ComputedSetter<T> = (newValue: T) => void;
+interface WritableComputedOptions<T, S = T> {
+  get: ComputedGetter<T>;
+  set: ComputedSetter<S>;
+}
+declare const RefSymbol: unique symbol;
+declare const RawSymbol: unique symbol;
+interface Ref<T = any, S = T> {
+  get value(): T;
+  set value(_: S);
+  /**
+   * Type differentiator only.
+   * We need this to be in public d.ts but don't want it to show up in IDE
+   * autocomplete, so we use a private Symbol instead.
+   */
+  [RefSymbol]: true;
+}
+declare const ShallowRefMarker: unique symbol;
+type ShallowRef<T = any, S = T> = Ref<T, S> & {
+  [ShallowRefMarker]?: true;
+};
+/**
+ * This is a special exported interface for other packages to declare
+ * additional types that should bail out for ref unwrapping. For example
+ * \@vue/runtime-dom can declare it like so in its d.ts:
+ *
+ * ``` ts
+ * declare module '@vue/reactivity' {
+ *   export interface RefUnwrapBailTypes {
+ *     runtimeDOMBailTypes: Node | Window
+ *   }
+ * }
+ * ```
+ */
+interface RefUnwrapBailTypes {}
+type ShallowUnwrapRef<T> = { [K in keyof T]: DistributeRef<T[K]> };
+type DistributeRef<T> = T extends Ref<infer V, unknown> ? V : T;
+type UnwrapRef<T> = T extends ShallowRef<infer V, unknown> ? V : T extends Ref<infer V, unknown> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
+type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
+  [RawSymbol]?: true;
+} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? { [K in keyof T]: UnwrapRefSimple<T[K]> } : T extends object & {
+  [ShallowReactiveMarker]?: never;
+} ? { [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]> } : T;
+type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
+type OnCleanup = (cleanupFn: () => void) => void;
+type WatchStopHandle = () => void;
+//#endregion
+//#region ../../node_modules/vue/node_modules/@vue/runtime-core/dist/runtime-core.d.ts
+type Slot<T extends any = any> = (...args: IfAny<T, any[], [T] | (T extends undefined ? [] : never)>) => VNode[];
+type InternalSlots = {
+  [name: string]: Slot | undefined;
+};
+type Slots = Readonly<InternalSlots>;
+declare const SlotSymbol: unique symbol;
+type SlotsType<T extends Record<string, any> = Record<string, any>> = {
+  [SlotSymbol]?: T;
+};
+type StrictUnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<T> & T;
+type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{ [K in keyof T]: NonNullable<T[K]> extends ((...args: any[]) => any) ? T[K] : Slot<T[K]> }>>;
+type RawSlots = {
+  [name: string]: unknown;
+  $stable?: boolean;
+};
+declare enum SchedulerJobFlags {
+  QUEUED = 1,
+  PRE = 2,
+  /**
+   * Indicates whether the effect is allowed to recursively trigger itself
+   * when managed by the scheduler.
+   *
+   * By default, a job cannot trigger itself because some built-in method calls,
+   * e.g. Array.prototype.push actually performs reads as well (#1740) which
+   * can lead to confusing infinite loops.
+   * The allowed cases are component update functions and watch callbacks.
+   * Component update functions may update child component props, which in turn
+   * trigger flush: "pre" watch callbacks that mutates state that the parent
+   * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
+   * triggers itself again, it's likely intentional and it is the user's
+   * responsibility to perform recursive state mutation that eventually
+   * stabilizes (#1727).
+   */
+  ALLOW_RECURSE = 4,
+  DISPOSED = 8
+}
+interface SchedulerJob extends Function {
+  id?: number;
+  /**
+   * flags can technically be undefined, but it can still be used in bitwise
+   * operations just like 0.
+   */
+  flags?: SchedulerJobFlags;
+  /**
+   * Attached by renderer.ts when setting up a component's render effect
+   * Used to obtain component information when reporting max recursive updates.
+   */
+  i?: ComponentInternalInstance;
+}
+declare function nextTick<T = void, R = void>(this: T, fn?: (this: T) => R): Promise<Awaited<R>>;
+type ComponentPropsOptions<P = Data$2> = ComponentObjectPropsOptions<P> | string[];
+type ComponentObjectPropsOptions<P = Data$2> = { [K in keyof P]: Prop<P[K]> | null };
+type Prop<T, D = T> = PropOptions<T, D> | PropType$1<T>;
+type DefaultFactory<T> = (props: Data$2) => T | null | undefined;
+interface PropOptions<T = any, D = T> {
+  type?: PropType$1<T> | true | null;
+  required?: boolean;
+  default?: D | DefaultFactory<D> | null | undefined | object;
+  validator?(value: unknown, props: Data$2): boolean;
+}
+type PropType$1<T> = PropConstructor<T> | (PropConstructor<T> | null)[];
+type PropConstructor<T = any> = {
+  new (...args: any[]): T & {};
+} | {
+  (): T;
+} | PropMethod<T>;
+type PropMethod<T, TConstructor = any> = [T] extends [((...args: any) => any) | undefined] ? {
+  new (): TConstructor;
+  (): T;
+  readonly prototype: TConstructor;
+} : never;
+type RequiredKeys<T> = { [K in keyof T]: T[K] extends {
+  required: true;
+} | {
+  default: any;
+} | BooleanConstructor | {
+  type: BooleanConstructor;
+} ? T[K] extends {
+  default: undefined | (() => undefined);
+} ? never : K : never }[keyof T];
+type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+type DefaultKeys<T> = { [K in keyof T]: T[K] extends {
+  default: any;
+} | BooleanConstructor | {
+  type: BooleanConstructor;
+} ? T[K] extends {
+  type: BooleanConstructor;
+  required: true;
+} ? never : K : never }[keyof T];
+type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends true ? any : null : [T] extends [{
+  type: null | true;
+}] ? any : [T] extends [ObjectConstructor | {
+  type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [BooleanConstructor | {
+  type: BooleanConstructor;
+}] ? boolean : [T] extends [DateConstructor | {
+  type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+  type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U, false> : InferPropType<U, false> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? IfAny<V, V, D> : V : V : T;
+/**
+ * Extract prop types from a runtime props options object.
+ * The extracted types are **internal** - i.e. the resolved props received by
+ * the component.
+ * - Boolean props are always present
+ * - Props with default values are always present
+ *
+ * To extract accepted props from the parent, use {@link ExtractPublicPropTypes}.
+ */
+type ExtractPropTypes<O> = { [K in keyof Pick<O, RequiredKeys<O>>]: InferPropType<O[K]> } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]> };
+type ExtractDefaultPropTypes<O> = O extends object ? { [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]> } : {};
+/**
+ * Vue `<script setup>` compiler macro for declaring component props. The
+ * expected argument is the same as the component `props` option.
+ *
+ * Example runtime declaration:
+ * ```js
+ * // using Array syntax
+ * const props = defineProps(['foo', 'bar'])
+ * // using Object syntax
+ * const props = defineProps({
+ *   foo: String,
+ *   bar: {
+ *     type: Number,
+ *     required: true
+ *   }
+ * })
+ * ```
+ *
+ * Equivalent type-based declaration:
+ * ```ts
+ * // will be compiled into equivalent runtime declarations
+ * const props = defineProps<{
+ *   foo?: string
+ *   bar: number
+ * }>()
+ * ```
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ */
+declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{ [key in PropNames]?: any }>>;
+declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>;
+declare function defineProps<TypeProps>(): DefineProps<LooseRequired<TypeProps>, BooleanKey<TypeProps>>;
+type DefineProps<T, BKeys extends keyof T> = Readonly<T> & { readonly [K in BKeys]-?: boolean };
+type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never;
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's emitted
+ * events. The expected argument is the same as the component `emits` option.
+ *
+ * Example runtime declaration:
+ * ```js
+ * const emit = defineEmits(['change', 'update'])
+ * ```
+ *
+ * Example type-based declaration:
+ * ```ts
+ * const emit = defineEmits<{
+ *   // <eventName>: <expected arguments>
+ *   change: []
+ *   update: [value: number] // named tuple syntax
+ * }>()
+ *
+ * emit('change')
+ * emit('update', 1)
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
+ */
+declare function defineEmits<EE extends string = string>(emitOptions: EE[]): EmitFn<EE[]>;
+declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions: E): EmitFn<E>;
+declare function defineEmits<T extends ComponentTypeEmits>(): T extends ((...args: any[]) => any) ? T : ShortEmits<T>;
+type ComponentTypeEmits = ((...args: any[]) => any) | Record<string, any>;
+type RecordToUnion<T extends Record<string, any>> = T[keyof T];
+type ShortEmits<T extends Record<string, any>> = UnionToIntersection<RecordToUnion<{ [K in keyof T]: (evt: K, ...args: T[K]) => void }>>;
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's exposed
+ * instance properties when it is accessed by a parent component via template
+ * refs.
+ *
+ * `<script setup>` components are closed by default - i.e. variables inside
+ * the `<script setup>` scope is not exposed to parent unless explicitly exposed
+ * via `defineExpose`.
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineexpose}
+ */
+declare function defineExpose<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): void;
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's additional
+ * options. This should be used only for options that cannot be expressed via
+ * Composition API - e.g. `inheritAttrs`.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineoptions}
+ */
+declare function defineOptions<RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin>(options?: ComponentOptionsBase<{}, RawBindings, D, C, M, Mixin, Extends, {}> & {
+  /**
+   * props should be defined via defineProps().
+   */
+  props?: never;
+  /**
+   * emits should be defined via defineEmits().
+   */
+  emits?: never;
+  /**
+   * expose should be defined via defineExpose().
+   */
+  expose?: never;
+  /**
+   * slots should be defined via defineSlots().
+   */
+  slots?: never;
+}): void;
+declare function defineSlots<S extends Record<string, any> = Record<string, any>>(): StrictUnwrapSlotsType<SlotsType<S>>;
+type ModelRef<T, M extends PropertyKey = string, G = T, S = T> = Ref<G, S> & [ModelRef<T, M, G, S>, Record<M, true | undefined>];
+type DefineModelOptions<T = any, G = T, S = T> = {
+  get?: (v: T) => G;
+  set?: (v: S) => any;
+};
+/**
+ * Vue `<script setup>` compiler macro for declaring a
+ * two-way binding prop that can be consumed via `v-model` from the parent
+ * component. This will declare a prop with the same name and a corresponding
+ * `update:propName` event.
+ *
+ * If the first argument is a string, it will be used as the prop name;
+ * Otherwise the prop name will default to "modelValue". In both cases, you
+ * can also pass an additional object which will be used as the prop's options.
+ *
+ * The returned ref behaves differently depending on whether the parent
+ * provided the corresponding v-model props or not:
+ * - If yes, the returned ref's value will always be in sync with the parent
+ *   prop.
+ * - If not, the returned ref will behave like a normal local ref.
+ *
+ * @example
+ * ```ts
+ * // default model (consumed via `v-model`)
+ * const modelValue = defineModel<string>()
+ * modelValue.value = "hello"
+ *
+ * // default model with options
+ * const modelValue = defineModel<string>({ required: true })
+ *
+ * // with specified name (consumed via `v-model:count`)
+ * const count = defineModel<number>('count')
+ * count.value++
+ *
+ * // with specified name and default value
+ * const count = defineModel<number>('count', { default: 0 })
+ * ```
+ */
+declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options: ({
+  default: any;
+} | {
+  required: true;
+}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
+declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
+declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options: ({
+  default: any;
+} | {
+  required: true;
+}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
+declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
+type NotUndefined<T> = T extends undefined ? never : T;
+type MappedOmit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P] };
+type InferDefaults<T> = { [K in keyof T]?: InferDefault<T, T[K]> };
+type NativeType = null | number | string | boolean | symbol | Function;
+type InferDefault<P, T> = ((props: P) => T & {}) | (T extends NativeType ? T : never);
+type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = T extends unknown ? Readonly<MappedOmit<T, keyof Defaults>> & { readonly [K in keyof Defaults as K extends keyof T ? K : never]-?: K extends keyof T ? Defaults[K] extends undefined ? IfAny<Defaults[K], NotUndefined<T[K]>, T[K]> : NotUndefined<T[K]> : never } & { readonly [K in BKeys]-?: K extends keyof Defaults ? Defaults[K] extends undefined ? boolean | undefined : boolean : boolean } : never;
+/**
+ * Vue `<script setup>` compiler macro for providing props default values when
+ * using type-based `defineProps` declaration.
+ *
+ * Example usage:
+ * ```ts
+ * withDefaults(defineProps<{
+ *   size?: number
+ *   labels?: string[]
+ * }>(), {
+ *   size: 3,
+ *   labels: () => ['default label']
+ * })
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the output
+ * and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/guide/typescript/composition-api.html#typing-component-props}
+ */
+declare function withDefaults<T, BKeys extends keyof T, Defaults extends InferDefaults<T>>(props: DefineProps<T, BKeys>, defaults: Defaults): PropsWithDefaults<T, Defaults, BKeys>;
+type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
+type EmitsOptions = ObjectEmitsOptions | string[];
+type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? { [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any } : T extends ObjectEmitsOptions ? { [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends ((...args: infer P) => any) ? P : T[K] extends null ? any[] : never) => any } : {};
+type ShortEmitsToObject<E> = E extends Record<string, any[]> ? { [K in keyof E]: (...args: E[K]) => any } : E;
+type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{ [key in Event]: Options[key] extends ((...args: infer Args) => any) ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void }[Event]>;
+/**
+Runtime helper for applying directives to a vnode. Example usage:
+
+const comp = resolveComponent('comp')
+const foo = resolveDirective('foo')
+const bar = resolveDirective('bar')
+
+return withDirectives(h(comp), [
+  [foo, this.x],
+  [bar, this.y]
+])
+*/
+interface DirectiveBinding<Value = any, Modifiers extends string = string, Arg extends string = string> {
+  instance: ComponentPublicInstance | Record<string, any> | null;
+  value: Value;
+  oldValue: Value | null;
+  arg?: Arg;
+  modifiers: DirectiveModifiers<Modifiers>;
+  dir: ObjectDirective<any, Value>;
+}
+type DirectiveHook<HostElement = any, Prev = VNode<any, HostElement> | null, Value = any, Modifiers extends string = string, Arg extends string = string> = (el: HostElement, binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode<any, HostElement>, prevVNode: Prev) => void;
+type SSRDirectiveHook<Value = any, Modifiers extends string = string, Arg extends string = string> = (binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode) => Data$2 | undefined;
+interface ObjectDirective<HostElement = any, Value = any, Modifiers extends string = string, Arg extends string = string> {
+  created?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  beforeMount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  mounted?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  beforeUpdate?: DirectiveHook<HostElement, VNode<any, HostElement>, Value, Modifiers, Arg>;
+  updated?: DirectiveHook<HostElement, VNode<any, HostElement>, Value, Modifiers, Arg>;
+  beforeUnmount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  unmounted?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  getSSRProps?: SSRDirectiveHook<Value, Modifiers, Arg>;
+  deep?: boolean;
+}
+type FunctionDirective<HostElement = any, V = any, Modifiers extends string = string, Arg extends string = string> = DirectiveHook<HostElement, any, V, Modifiers, Arg>;
+type Directive<HostElement = any, Value = any, Modifiers extends string = string, Arg extends string = string> = ObjectDirective<HostElement, Value, Modifiers, Arg> | FunctionDirective<HostElement, Value, Modifiers, Arg>;
+type DirectiveModifiers<K extends string = string> = Record<K, boolean>;
+/**
+ * Custom properties added to component instances in any way and can be accessed through `this`
+ *
+ * @example
+ * Here is an example of adding a property `$router` to every component instance:
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { Router, createRouter } from 'vue-router'
+ *
+ * declare module 'vue' {
+ *   interface ComponentCustomProperties {
+ *     $router: Router
+ *   }
+ * }
+ *
+ * // effectively adding the router to every component instance
+ * const app = createApp({})
+ * const router = createRouter()
+ * app.config.globalProperties.$router = router
+ *
+ * const vm = app.mount('#app')
+ * // we can access the router from the instance
+ * vm.$router.push('/')
+ * ```
+ */
+interface ComponentCustomProperties {}
+type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
+type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, infer Defaults, any, any, any, any, any, any, any> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
+type ExtractMixin<T> = {
+  Mixin: MixinToOptionTypes<T>;
+}[T extends ComponentOptionsMixin ? 'Mixin' : never];
+type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType : UnionToIntersection<ExtractMixin<T>>;
+type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
+type EnsureNonVoid<T> = T extends void ? {} : T;
+type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props, RawBindings, D, C, M> = ComponentPublicInstance<any>, Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = {
+  __isFragment?: never;
+  __isTeleport?: never;
+  __isSuspense?: never;
+  new (...args: any[]): T;
+};
+/**
+ * @deprecated This is no longer used internally, but exported and relied on by
+ * existing library types generated by vue-tsc.
+ */
+/**
+ * This is the same as `CreateComponentPublicInstance` but adds local components,
+ * global directives, exposed, and provide inference.
+ * It changes the arguments order so that we don't need to repeat mixin
+ * inference everywhere internally, but it has to be a new type to avoid
+ * breaking types that relies on previous arguments order (#10842)
+ */
+type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, TypeRefs extends Data$2 = {}, TypeEl extends Element = any, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs, TypeEl>;
+type ExposedKeys<T, Exposed extends string & keyof T> = '' extends Exposed ? T : Pick<T, Exposed>;
+type ComponentPublicInstance<P = {}, // props type extracted from props option
+B = {}, // raw bindings returned from setup()
+D = {}, // return from data()
+C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = '', TypeRefs extends Data$2 = {}, TypeEl extends Element = any> = {
+  $: ComponentInternalInstance;
+  $data: D;
+  $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
+  $attrs: Data$2;
+  $refs: Data$2 & TypeRefs;
+  $slots: UnwrapSlotsType<S>;
+  $root: ComponentPublicInstance | null;
+  $parent: ComponentPublicInstance | null;
+  $host: Element | null;
+  $emit: EmitFn<E>;
+  $el: TypeEl;
+  $options: Options & MergedComponentOptionsOverride;
+  $forceUpdate: () => void;
+  $nextTick: typeof nextTick;
+  $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends ((...args: any) => infer R) ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & ExposedKeys<IfAny<P, P, Readonly<Defaults> & Omit<P, keyof ShallowUnwrapRef<B> | keyof Defaults>> & ShallowUnwrapRef<B> & UnwrapNestedRefs<D> & ExtractComputedReturns<C> & M & ComponentCustomProperties & InjectToObject<I>, Exposed>;
+interface SuspenseProps {
+  onResolve?: () => void;
+  onPending?: () => void;
+  onFallback?: () => void;
+  timeout?: string | number;
+  /**
+   * Allow suspense to be captured by parent suspense
+   *
+   * @default false
+   */
+  suspensible?: boolean;
+}
+declare const SuspenseImpl: {
+  name: string;
+  __isSuspense: boolean;
+  process(n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals): void;
+  hydrate: typeof hydrateSuspense;
+  normalize: typeof normalizeSuspenseChildren;
+};
+declare const Suspense: {
+  __isSuspense: true;
+  new (): {
+    $props: VNodeProps & SuspenseProps;
+    $slots: {
+      default(): VNode[];
+      fallback(): VNode[];
+    };
+  };
+};
+interface SuspenseBoundary {
+  vnode: VNode<RendererNode, RendererElement, SuspenseProps>;
+  parent: SuspenseBoundary | null;
+  parentComponent: ComponentInternalInstance | null;
+  namespace: ElementNamespace;
+  container: RendererElement;
+  hiddenContainer: RendererElement;
+  activeBranch: VNode | null;
+  pendingBranch: VNode | null;
+  deps: number;
+  pendingId: number;
+  timeout: number;
+  isInFallback: boolean;
+  isHydrating: boolean;
+  isUnmounted: boolean;
+  effects: Function[];
+  resolve(force?: boolean, sync?: boolean): void;
+  fallback(fallbackVNode: VNode): void;
+  move(container: RendererElement, anchor: RendererNode | null, type: MoveType): void;
+  next(): RendererNode | null;
+  registerDep(instance: ComponentInternalInstance, setupRenderEffect: SetupRenderEffectFn, optimized: boolean): void;
+  unmount(parentSuspense: SuspenseBoundary | null, doRemove?: boolean): void;
+}
+declare function hydrateSuspense(node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, hydrateNode: (node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare function normalizeSuspenseChildren(vnode: VNode): void;
+type Hook<T = () => void> = T | T[];
+interface BaseTransitionProps<HostElement = RendererElement> {
+  mode?: 'in-out' | 'out-in' | 'default';
+  appear?: boolean;
+  persisted?: boolean;
+  onBeforeEnter?: Hook<(el: HostElement) => void>;
+  onEnter?: Hook<(el: HostElement, done: () => void) => void>;
+  onAfterEnter?: Hook<(el: HostElement) => void>;
+  onEnterCancelled?: Hook<(el: HostElement) => void>;
+  onBeforeLeave?: Hook<(el: HostElement) => void>;
+  onLeave?: Hook<(el: HostElement, done: () => void) => void>;
+  onAfterLeave?: Hook<(el: HostElement) => void>;
+  onLeaveCancelled?: Hook<(el: HostElement) => void>;
+  onBeforeAppear?: Hook<(el: HostElement) => void>;
+  onAppear?: Hook<(el: HostElement, done: () => void) => void>;
+  onAfterAppear?: Hook<(el: HostElement) => void>;
+  onAppearCancelled?: Hook<(el: HostElement) => void>;
+}
+interface TransitionHooks<HostElement = RendererElement> {
+  mode: BaseTransitionProps['mode'];
+  persisted: boolean;
+  beforeEnter(el: HostElement): void;
+  enter(el: HostElement): void;
+  leave(el: HostElement, remove: () => void): void;
+  clone(vnode: VNode): TransitionHooks<HostElement>;
+  afterLeave?(): void;
+  delayLeave?(el: HostElement, earlyRemove: () => void, delayedLeave: () => void): void;
+  delayedLeave?(): void;
+}
+type ElementNamespace = 'svg' | 'mathml' | undefined;
+interface RendererOptions<HostNode = RendererNode, HostElement = RendererElement> {
+  patchProp(el: HostElement, key: string, prevValue: any, nextValue: any, namespace?: ElementNamespace, parentComponent?: ComponentInternalInstance | null): void;
+  insert(el: HostNode, parent: HostElement, anchor?: HostNode | null): void;
+  remove(el: HostNode): void;
+  createElement(type: string, namespace?: ElementNamespace, isCustomizedBuiltIn?: string, vnodeProps?: (VNodeProps & {
+    [key: string]: any;
+  }) | null): HostElement;
+  createText(text: string): HostNode;
+  createComment(text: string): HostNode;
+  setText(node: HostNode, text: string): void;
+  setElementText(node: HostElement, text: string): void;
+  parentNode(node: HostNode): HostElement | null;
+  nextSibling(node: HostNode): HostNode | null;
+  querySelector?(selector: string): HostElement | null;
+  setScopeId?(el: HostElement, id: string): void;
+  cloneNode?(node: HostNode): HostNode;
+  insertStaticContent?(content: string, parent: HostElement, anchor: HostNode | null, namespace: ElementNamespace, start?: HostNode | null, end?: HostNode | null): [HostNode, HostNode];
+}
+interface RendererNode {
+  [key: string | symbol]: any;
+}
+interface RendererElement extends RendererNode {}
+interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> {
+  p: PatchFn;
+  um: UnmountFn;
+  r: RemoveFn;
+  m: MoveFn;
+  mt: MountComponentFn;
+  mc: MountChildrenFn;
+  pc: PatchChildrenFn;
+  pbc: PatchBlockChildrenFn;
+  n: NextFn;
+  o: RendererOptions<HostNode, HostElement>;
+}
+type PatchFn = (n1: VNode | null, // null means this is a mount
+n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, namespace?: ElementNamespace, slotScopeIds?: string[] | null, optimized?: boolean) => void;
+type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void;
+type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean) => void;
+type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null) => void;
+type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentSuspense?: SuspenseBoundary | null) => void;
+type NextFn = (vnode: VNode) => RendererNode | null;
+type UnmountFn = (vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean) => void;
+type RemoveFn = (vnode: VNode) => void;
+type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
+type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
+declare enum MoveType {
+  ENTER = 0,
+  LEAVE = 1,
+  REORDER = 2
+}
+/**
+ * The createRenderer function accepts two generic arguments:
+ * HostNode and HostElement, corresponding to Node and Element types in the
+ * host environment. For example, for runtime-dom, HostNode would be the DOM
+ * `Node` interface and HostElement would be the DOM `Element` interface.
+ *
+ * Custom renderers can pass in the platform specific types like this:
+ *
+ * ``` js
+ * const { render, createApp } = createRenderer<Node, Element>({
+ *   patchProp,
+ *   ...nodeOps
+ * })
+ * ```
+ */
+type MatchPattern = string | RegExp | (string | RegExp)[];
+interface KeepAliveProps {
+  include?: MatchPattern;
+  exclude?: MatchPattern;
+  max?: number | string;
+}
+type DebuggerHook = (e: DebuggerEvent) => void;
+type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
+declare enum DeprecationTypes$1 {
+  GLOBAL_MOUNT = "GLOBAL_MOUNT",
+  GLOBAL_MOUNT_CONTAINER = "GLOBAL_MOUNT_CONTAINER",
+  GLOBAL_EXTEND = "GLOBAL_EXTEND",
+  GLOBAL_PROTOTYPE = "GLOBAL_PROTOTYPE",
+  GLOBAL_SET = "GLOBAL_SET",
+  GLOBAL_DELETE = "GLOBAL_DELETE",
+  GLOBAL_OBSERVABLE = "GLOBAL_OBSERVABLE",
+  GLOBAL_PRIVATE_UTIL = "GLOBAL_PRIVATE_UTIL",
+  CONFIG_SILENT = "CONFIG_SILENT",
+  CONFIG_DEVTOOLS = "CONFIG_DEVTOOLS",
+  CONFIG_KEY_CODES = "CONFIG_KEY_CODES",
+  CONFIG_PRODUCTION_TIP = "CONFIG_PRODUCTION_TIP",
+  CONFIG_IGNORED_ELEMENTS = "CONFIG_IGNORED_ELEMENTS",
+  CONFIG_WHITESPACE = "CONFIG_WHITESPACE",
+  CONFIG_OPTION_MERGE_STRATS = "CONFIG_OPTION_MERGE_STRATS",
+  INSTANCE_SET = "INSTANCE_SET",
+  INSTANCE_DELETE = "INSTANCE_DELETE",
+  INSTANCE_DESTROY = "INSTANCE_DESTROY",
+  INSTANCE_EVENT_EMITTER = "INSTANCE_EVENT_EMITTER",
+  INSTANCE_EVENT_HOOKS = "INSTANCE_EVENT_HOOKS",
+  INSTANCE_CHILDREN = "INSTANCE_CHILDREN",
+  INSTANCE_LISTENERS = "INSTANCE_LISTENERS",
+  INSTANCE_SCOPED_SLOTS = "INSTANCE_SCOPED_SLOTS",
+  INSTANCE_ATTRS_CLASS_STYLE = "INSTANCE_ATTRS_CLASS_STYLE",
+  OPTIONS_DATA_FN = "OPTIONS_DATA_FN",
+  OPTIONS_DATA_MERGE = "OPTIONS_DATA_MERGE",
+  OPTIONS_BEFORE_DESTROY = "OPTIONS_BEFORE_DESTROY",
+  OPTIONS_DESTROYED = "OPTIONS_DESTROYED",
+  WATCH_ARRAY = "WATCH_ARRAY",
+  PROPS_DEFAULT_THIS = "PROPS_DEFAULT_THIS",
+  V_ON_KEYCODE_MODIFIER = "V_ON_KEYCODE_MODIFIER",
+  CUSTOM_DIR = "CUSTOM_DIR",
+  ATTR_FALSE_VALUE = "ATTR_FALSE_VALUE",
+  ATTR_ENUMERATED_COERCION = "ATTR_ENUMERATED_COERCION",
+  TRANSITION_CLASSES = "TRANSITION_CLASSES",
+  TRANSITION_GROUP_ROOT = "TRANSITION_GROUP_ROOT",
+  COMPONENT_ASYNC = "COMPONENT_ASYNC",
+  COMPONENT_FUNCTIONAL = "COMPONENT_FUNCTIONAL",
+  COMPONENT_V_MODEL = "COMPONENT_V_MODEL",
+  RENDER_FUNCTION = "RENDER_FUNCTION",
+  FILTERS = "FILTERS",
+  PRIVATE_APIS = "PRIVATE_APIS"
+}
+type CompatConfig = Partial<Record<DeprecationTypes$1, boolean | 'suppress-warning'>> & {
+  MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
+};
+/**
+ * Interface for declaring custom options.
+ *
+ * @example
+ * ```ts
+ * declare module 'vue' {
+ *   interface ComponentCustomOptions {
+ *     beforeRouteUpdate?(
+ *       to: Route,
+ *       from: Route,
+ *       next: () => void
+ *     ): void
+ *   }
+ * }
+ * ```
+ */
+interface ComponentCustomOptions {}
+type RenderFunction = () => VNodeChild;
+interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> extends LegacyOptions<Props, D, C, M, Mixin, Extends, I, II, Provide>, ComponentInternalOptions, ComponentCustomOptions {
+  setup?: (this: void, props: LooseRequired<Props & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, 'P'>>>, ctx: SetupContext<E, S>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
+  name?: string;
+  template?: string | object;
+  render?: Function;
+  components?: LC & Record<string, Component>;
+  directives?: Directives & Record<string, Directive>;
+  inheritAttrs?: boolean;
+  emits?: (E | EE[]) & ThisType<void>;
+  slots?: S;
+  expose?: Exposed[];
+  serverPrefetch?(): void | Promise<any>;
+  compilerOptions?: RuntimeCompilerOptions;
+  call?: (this: unknown, ...args: unknown[]) => never;
+  __isFragment?: never;
+  __isTeleport?: never;
+  __isSuspense?: never;
+  __defaults?: Defaults;
+}
+/**
+ * Subset of compiler options that makes sense for the runtime.
+ */
+interface RuntimeCompilerOptions {
+  isCustomElement?: (tag: string) => boolean;
+  whitespace?: 'preserve' | 'condense';
+  comments?: boolean;
+  delimiters?: [string, string];
+}
+type ComponentOptions<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = any, M extends MethodOptions = any, Mixin extends ComponentOptionsMixin = any, Extends extends ComponentOptionsMixin = any, E extends EmitsOptions = any, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II, S, LC, Directives, Exposed, Provide> & ThisType<CreateComponentPublicInstanceWithMixins<{}, RawBindings, D, C, M, Mixin, Extends, E, Readonly<Props>, Defaults, false, I, S, LC, Directives>>;
+type ComponentOptionsMixin = ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
+type ComputedOptions = Record<string, ComputedGetter<any> | WritableComputedOptions<any>>;
+interface MethodOptions {
+  [key: string]: Function;
+}
+type ExtractComputedReturns<T extends any> = { [key in keyof T]: T[key] extends {
+  get: (...args: any[]) => infer TReturn;
+} ? TReturn : T[key] extends ((...args: any[]) => infer TReturn) ? TReturn : never };
+type ObjectWatchOptionItem = {
+  handler: WatchCallback | string;
+} & WatchOptions;
+type WatchOptionItem = string | WatchCallback | ObjectWatchOptionItem;
+type ComponentWatchOptionItem = WatchOptionItem | WatchOptionItem[];
+type ComponentWatchOptions = Record<string, ComponentWatchOptionItem>;
+type ComponentProvideOptions = ObjectProvideOptions | Function;
+type ObjectProvideOptions = Record<string | symbol, unknown>;
+type ComponentInjectOptions = string[] | ObjectInjectOptions;
+type ObjectInjectOptions = Record<string | symbol, string | symbol | {
+  from?: string | symbol;
+  default?: unknown;
+}>;
+type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? { [K in T[number]]?: unknown } : T extends ObjectInjectOptions ? { [K in keyof T]?: unknown } : never;
+interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string, Provide extends ComponentProvideOptions = ComponentProvideOptions> {
+  compatConfig?: CompatConfig;
+  [key: string]: any;
+  data?: (this: CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, MethodOptions, Mixin, Extends>, vm: CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, MethodOptions, Mixin, Extends>) => D;
+  computed?: C;
+  methods?: M;
+  watch?: ComponentWatchOptions;
+  provide?: Provide;
+  inject?: I | II[];
+  filters?: Record<string, Function>;
+  mixins?: Mixin[];
+  extends?: Extends;
+  beforeCreate?(): void;
+  created?(): void;
+  beforeMount?(): void;
+  mounted?(): void;
+  beforeUpdate?(): void;
+  updated?(): void;
+  activated?(): void;
+  deactivated?(): void;
+  /** @deprecated use `beforeUnmount` instead */
+  beforeDestroy?(): void;
+  beforeUnmount?(): void;
+  /** @deprecated use `unmounted` instead */
+  destroyed?(): void;
+  unmounted?(): void;
+  renderTracked?: DebuggerHook;
+  renderTriggered?: DebuggerHook;
+  errorCaptured?: ErrorCapturedHook;
+  /**
+   * runtime compile only
+   * @deprecated use `compilerOptions.delimiters` instead.
+   */
+  delimiters?: [string, string];
+  /**
+   * #3468
+   *
+   * type-only, used to assist Mixin's type inference,
+   * typescript will try to simplify the inferred `Mixin` type,
+   * with the `__differentiator`, typescript won't be able to combine different mixins,
+   * because the `__differentiator` will be different
+   */
+  __differentiator?: keyof D | keyof C | keyof M;
+}
+type MergedHook<T = () => void> = T | T[];
+type MergedComponentOptionsOverride = {
+  beforeCreate?: MergedHook;
+  created?: MergedHook;
+  beforeMount?: MergedHook;
+  mounted?: MergedHook;
+  beforeUpdate?: MergedHook;
+  updated?: MergedHook;
+  activated?: MergedHook;
+  deactivated?: MergedHook; /** @deprecated use `beforeUnmount` instead */
+  beforeDestroy?: MergedHook;
+  beforeUnmount?: MergedHook; /** @deprecated use `unmounted` instead */
+  destroyed?: MergedHook;
+  unmounted?: MergedHook;
+  renderTracked?: MergedHook<DebuggerHook>;
+  renderTriggered?: MergedHook<DebuggerHook>;
+  errorCaptured?: MergedHook<ErrorCapturedHook>;
+};
+type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults';
+type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Defaults = {}> = {
+  P: P;
+  B: B;
+  D: D;
+  C: C;
+  M: M;
+  Defaults: Defaults;
+};
+/**
+ * @deprecated
+ */
+interface InjectionConstraint<T> {}
+type InjectionKey<T> = symbol & InjectionConstraint<T>;
+type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
+type ResolveProps<PropsOrPropOptions, E extends EmitsOptions> = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>);
+type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}, TypeEl extends Element = any> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs, TypeEl>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
+interface App$1<HostElement = any> {
+  version: string;
+  config: AppConfig$1;
+  use<Options extends unknown[]>(plugin: Plugin$1<Options>, ...options: Options): this;
+  use<Options>(plugin: Plugin$1<Options>, options: Options): this;
+  mixin(mixin: ComponentOptions): this;
+  component(name: string): Component | undefined;
+  component<T extends Component | DefineComponent>(name: string, component: T): this;
+  directive<HostElement = any, Value = any, Modifiers extends string = string, Arg extends string = string>(name: string): Directive<HostElement, Value, Modifiers, Arg> | undefined;
+  directive<HostElement = any, Value = any, Modifiers extends string = string, Arg extends string = string>(name: string, directive: Directive<HostElement, Value, Modifiers, Arg>): this;
+  mount(rootContainer: HostElement | string,
+  /**
+   * @internal
+   */
+
+  isHydrate?: boolean,
+  /**
+   * @internal
+   */
+
+  namespace?: boolean | ElementNamespace,
+  /**
+   * @internal
+   */
+
+  vnode?: VNode): ComponentPublicInstance;
+  unmount(): void;
+  onUnmount(cb: () => void): void;
+  provide<T, K = InjectionKey<T> | string | number>(key: K, value: K extends InjectionKey<infer V> ? V : T): this;
+  /**
+   * Runs a function with the app as active instance. This allows using of `inject()` within the function to get access
+   * to variables provided via `app.provide()`.
+   *
+   * @param fn - function to run with the app as active instance
+   */
+  runWithContext<T>(fn: () => T): T;
+  _uid: number;
+  _component: ConcreteComponent;
+  _props: Data$2 | null;
+  _container: HostElement | null;
+  _context: AppContext;
+  _instance: ComponentInternalInstance | null;
+  /**
+   * v2 compat only
+   */
+  filter?(name: string): Function | undefined;
+  filter?(name: string, filter: Function): this;
+}
+type OptionMergeFunction = (to: unknown, from: unknown) => any;
+interface AppConfig$1 {
+  readonly isNativeTag: (tag: string) => boolean;
+  performance: boolean;
+  optionMergeStrategies: Record<string, OptionMergeFunction>;
+  globalProperties: ComponentCustomProperties & Record<string, any>;
+  errorHandler?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => void;
+  warnHandler?: (msg: string, instance: ComponentPublicInstance | null, trace: string) => void;
+  /**
+   * Options to pass to `@vue/compiler-dom`.
+   * Only supported in runtime compiler build.
+   */
+  compilerOptions: RuntimeCompilerOptions;
+  /**
+   * @deprecated use config.compilerOptions.isCustomElement
+   */
+  isCustomElement?: (tag: string) => boolean;
+  /**
+   * TODO document for 3.5
+   * Enable warnings for computed getters that recursively trigger itself.
+   */
+  warnRecursiveComputed?: boolean;
+  /**
+   * Whether to throw unhandled errors in production.
+   * Default is `false` to avoid crashing on any error (and only logs it)
+   * But in some cases, e.g. SSR, throwing might be more desirable.
+   */
+  throwUnhandledErrorInProduction?: boolean;
+  /**
+   * Prefix for all useId() calls within this app
+   */
+  idPrefix?: string;
+}
+interface AppContext {
+  app: App$1;
+  config: AppConfig$1;
+  mixins: ComponentOptions[];
+  components: Record<string, Component>;
+  directives: Record<string, Directive>;
+  provides: Record<string | symbol, any>;
+}
+type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App$1, ...options: Options) => any : (app: App$1, options: Options) => any;
+type ObjectPlugin<Options = any[]> = {
+  install: PluginInstallFunction<Options>;
+};
+type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>;
+type Plugin$1<Options = any[]> = FunctionPlugin<Options> | ObjectPlugin<Options>;
+type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
+interface TeleportProps {
+  to: string | RendererElement | null | undefined;
+  disabled?: boolean;
+  defer?: boolean;
+}
+declare const TeleportImpl: {
+  name: string;
+  __isTeleport: boolean;
+  process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void;
+  remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, {
+    um: unmount,
+    o: {
+      remove: hostRemove
+    }
+  }: RendererInternals, doRemove: boolean): void;
+  move: typeof moveTeleport;
+  hydrate: typeof hydrateTeleport;
+};
+declare enum TeleportMoveTypes {
+  TARGET_CHANGE = 0,
+  TOGGLE = 1,
+  // enable / disable
+  REORDER = 2
+}
+declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, {
+  o: {
+    insert
+  },
+  m: move
+}: RendererInternals, moveType?: TeleportMoveTypes): void;
+declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, {
+  o: {
+    nextSibling,
+    parentNode,
+    querySelector,
+    insert,
+    createText
+  }
+}: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare const Teleport: {
+  __isTeleport: true;
+  new (): {
+    $props: VNodeProps & TeleportProps;
+    $slots: {
+      default(): VNode[];
+    };
+  };
+};
+declare const Fragment: {
+  __isFragment: true;
+  new (): {
+    $props: VNodeProps;
+  };
+};
+declare const Text: unique symbol;
+declare const Comment: unique symbol;
+declare const Static: unique symbol;
+type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl;
+type VNodeRef = string | Ref | ((ref: Element | ComponentPublicInstance | null, refs: Record<string, any>) => void);
+type VNodeNormalizedRefAtom = {
+  /**
+   * component instance
+   */
+  i: ComponentInternalInstance;
+  /**
+   * Actual ref
+   */
+  r: VNodeRef;
+  /**
+   * setup ref key
+   */
+  k?: string;
+  /**
+   * refInFor marker
+   */
+  f?: boolean;
+};
+type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
+type VNodeMountHook = (vnode: VNode) => void;
+type VNodeUpdateHook = (vnode: VNode, oldVNode: VNode) => void;
+type VNodeProps = {
+  key?: PropertyKey;
+  ref?: VNodeRef;
+  ref_for?: boolean;
+  ref_key?: string;
+  onVnodeBeforeMount?: VNodeMountHook | VNodeMountHook[];
+  onVnodeMounted?: VNodeMountHook | VNodeMountHook[];
+  onVnodeBeforeUpdate?: VNodeUpdateHook | VNodeUpdateHook[];
+  onVnodeUpdated?: VNodeUpdateHook | VNodeUpdateHook[];
+  onVnodeBeforeUnmount?: VNodeMountHook | VNodeMountHook[];
+  onVnodeUnmounted?: VNodeMountHook | VNodeMountHook[];
+};
+type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
+type VNodeArrayChildren = Array<VNodeArrayChildren | VNodeChildAtom>;
+type VNodeChild = VNodeChildAtom | VNodeArrayChildren;
+type VNodeNormalizedChildren = string | VNodeArrayChildren | RawSlots | null;
+interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraProps = {
+  [key: string]: any;
+}> {
+  type: VNodeTypes;
+  props: (VNodeProps & ExtraProps) | null;
+  key: PropertyKey | null;
+  ref: VNodeNormalizedRef | null;
+  /**
+   * SFC only. This is assigned on vnode creation using currentScopeId
+   * which is set alongside currentRenderingInstance.
+   */
+  scopeId: string | null;
+  children: VNodeNormalizedChildren;
+  component: ComponentInternalInstance | null;
+  dirs: DirectiveBinding[] | null;
+  transition: TransitionHooks<HostElement> | null;
+  el: HostNode | null;
+  anchor: HostNode | null;
+  target: HostElement | null;
+  targetStart: HostNode | null;
+  targetAnchor: HostNode | null;
+  suspense: SuspenseBoundary | null;
+  shapeFlag: number;
+  patchFlag: number;
+  appContext: AppContext | null;
+}
+type Data$2 = Record<string, unknown>;
+/**
+ * Public utility type for extracting the instance type of a component.
+ * Works with all valid component definition types. This is intended to replace
+ * the usage of `InstanceType<typeof Comp>` which only works for
+ * constructor-based component definition types.
+ *
+ * @example
+ * ```ts
+ * const MyComp = { ... }
+ * declare const instance: ComponentInstance<typeof MyComp>
+ * ```
+ */
+/**
+ * For extending allowed non-declared props on components in TSX
+ */
+interface ComponentCustomProps {}
+/**
+ * For globally defined Directives
+ * Here is an example of adding a directive `VTooltip` as global directive:
+ *
+ * @example
+ * ```ts
+ * import VTooltip from 'v-tooltip'
+ *
+ * declare module '@vue/runtime-core' {
+ *   interface GlobalDirectives {
+ *     VTooltip
+ *   }
+ * }
+ * ```
+ */
+interface GlobalDirectives {}
+/**
+ * For globally defined Components
+ * Here is an example of adding a component `RouterView` as global component:
+ *
+ * @example
+ * ```ts
+ * import { RouterView } from 'vue-router'
+ *
+ * declare module '@vue/runtime-core' {
+ *   interface GlobalComponents {
+ *     RouterView
+ *   }
+ * }
+ * ```
+ */
+interface GlobalComponents {
+  Teleport: DefineComponent<TeleportProps>;
+  Suspense: DefineComponent<SuspenseProps>;
+  KeepAlive: DefineComponent<KeepAliveProps>;
+  BaseTransition: DefineComponent<BaseTransitionProps>;
+}
+/**
+ * Default allowed non-declared props on component in TSX
+ */
+interface AllowedComponentProps {
+  class?: unknown;
+  style?: unknown;
+}
+interface ComponentInternalOptions {
+  /**
+   * Compat build only, for bailing out of certain compatibility behavior
+   */
+  __isBuiltIn?: boolean;
+  /**
+   * This one should be exposed so that devtools can make use of it
+   */
+  __file?: string;
+  /**
+   * name inferred from filename
+   */
+  __name?: string;
+}
+interface FunctionalComponent<P = {}, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any, EE extends EmitsOptions = ShortEmitsToObject<E>> extends ComponentInternalOptions {
+  (props: P & EmitsToProps<EE>, ctx: Omit<SetupContext<EE, IfAny<S, {}, SlotsType<S>>>, 'expose'>): any;
+  props?: ComponentPropsOptions<P>;
+  emits?: EE | (keyof EE)[];
+  slots?: IfAny<S, Slots, SlotsType<S>>;
+  inheritAttrs?: boolean;
+  displayName?: string;
+  compatConfig?: CompatConfig;
+}
+/**
+ * Concrete component type matches its actual value: it's either an options
+ * object, or a function. Use this where the code expects to work with actual
+ * values, e.g. checking if its a function or not. This is mostly for internal
+ * implementation code.
+ */
+type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ComponentOptions<Props, RawBindings, D, C, M> | FunctionalComponent<Props, E, S>;
+/**
+ * A type used in public APIs where a component type is expected.
+ * The constructor type is an artificial type returned by defineComponent().
+ */
+type Component<Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ConcreteComponent<Props, RawBindings, D, C, M, E, S> | ComponentPublicInstanceConstructor<Props>;
+type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
+  attrs: Data$2;
+  slots: UnwrapSlotsType<S>;
+  emit: EmitFn<E>;
+  expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
+} : never;
+/**
+ * We expose a subset of properties on the internal instance as they are
+ * useful for advanced external libraries and tools.
+ */
+interface ComponentInternalInstance {
+  uid: number;
+  type: ConcreteComponent;
+  parent: ComponentInternalInstance | null;
+  root: ComponentInternalInstance;
+  appContext: AppContext;
+  /**
+   * Vnode representing this component in its parent's vdom tree
+   */
+  vnode: VNode;
+  /**
+   * Root vnode of this component's own vdom tree
+   */
+  subTree: VNode;
+  /**
+   * Render effect instance
+   */
+  effect: ReactiveEffect;
+  /**
+   * Force update render effect
+   */
+  update: () => void;
+  /**
+   * Render effect job to be passed to scheduler (checks if dirty)
+   */
+  job: SchedulerJob;
+  proxy: ComponentPublicInstance | null;
+  exposed: Record<string, any> | null;
+  exposeProxy: Record<string, any> | null;
+  data: Data$2;
+  props: Data$2;
+  attrs: Data$2;
+  slots: InternalSlots;
+  refs: Data$2;
+  emit: EmitFn;
+  isMounted: boolean;
+  isUnmounted: boolean;
+  isDeactivated: boolean;
+}
+interface WatchEffectOptions extends DebuggerOptions {
+  flush?: 'pre' | 'post' | 'sync';
+}
+interface WatchOptions<Immediate = boolean> extends WatchEffectOptions {
+  immediate?: Immediate;
+  deep?: boolean | number;
+  once?: boolean;
+}
+declare module '@vue/reactivity' {
+  interface RefUnwrapBailTypes {
+    runtimeCoreBailTypes: VNode | {
+      $: ComponentInternalInstance;
+    };
+  }
+}
+// Note: this file is auto concatenated to the end of the bundled d.ts during
+// build.
+declare module '@vue/runtime-core' {
+  export interface GlobalComponents {
+    Teleport: DefineComponent<TeleportProps>;
+    Suspense: DefineComponent<SuspenseProps>;
+    KeepAlive: DefineComponent<KeepAliveProps>;
+    BaseTransition: DefineComponent<BaseTransitionProps>;
+  }
+} // Note: this file is auto concatenated to the end of the bundled d.ts during
+// build.
+type _defineProps = typeof defineProps;
+type _defineEmits = typeof defineEmits;
+type _defineExpose = typeof defineExpose;
+type _defineOptions = typeof defineOptions;
+type _defineSlots = typeof defineSlots;
+type _defineModel = typeof defineModel;
+type _withDefaults = typeof withDefaults;
+declare global {
+  const defineProps: _defineProps;
+  const defineEmits: _defineEmits;
+  const defineExpose: _defineExpose;
+  const defineOptions: _defineOptions;
+  const defineSlots: _defineSlots;
+  const defineModel: _defineModel;
+  const withDefaults: _withDefaults;
+}
+//#endregion
+//#region ../../node_modules/vue/node_modules/@vue/runtime-dom/dist/runtime-dom.d.ts
+declare const TRANSITION = "transition";
+declare const ANIMATION = "animation";
+type AnimationTypes = typeof TRANSITION | typeof ANIMATION;
+interface TransitionProps extends BaseTransitionProps<Element> {
+  name?: string;
+  type?: AnimationTypes;
+  css?: boolean;
+  duration?: number | {
+    enter: number;
+    leave: number;
+  };
+  enterFromClass?: string;
+  enterActiveClass?: string;
+  enterToClass?: string;
+  appearFromClass?: string;
+  appearActiveClass?: string;
+  appearToClass?: string;
+  leaveFromClass?: string;
+  leaveActiveClass?: string;
+  leaveToClass?: string;
+}
+type TransitionGroupProps = Omit<TransitionProps, 'mode'> & {
+  tag?: string;
+  moveClass?: string;
+};
+declare const vShowOriginalDisplay: unique symbol;
+declare const vShowHidden: unique symbol;
+interface VShowElement extends HTMLElement {
+  [vShowOriginalDisplay]: string;
+  [vShowHidden]: boolean;
+}
+declare const vShow: ObjectDirective<VShowElement> & {
+  name?: 'show';
+};
+declare const systemModifiers: readonly ["ctrl", "shift", "alt", "meta"];
+type SystemModifiers = (typeof systemModifiers)[number];
+type CompatModifiers = keyof typeof keyNames;
+type VOnModifiers = SystemModifiers | ModifierGuards | CompatModifiers;
+type ModifierGuards = 'shift' | 'ctrl' | 'alt' | 'meta' | 'left' | 'right' | 'stop' | 'prevent' | 'self' | 'middle' | 'exact';
+/**
+ * @private
+ */
+declare const keyNames: Record<'esc' | 'space' | 'up' | 'left' | 'right' | 'down' | 'delete', string>;
+/**
+ * @private
+ */
+type VOnDirective = Directive<any, any, VOnModifiers>;
+type AssignerFn = (value: any) => void;
+declare const assignKey: unique symbol;
+type ModelDirective<T, Modifiers extends string = string> = ObjectDirective<T & {
+  [assignKey]: AssignerFn;
+  _assigning?: boolean;
+}, any, Modifiers>;
+declare const vModelText: ModelDirective<HTMLInputElement | HTMLTextAreaElement, 'trim' | 'number' | 'lazy'>;
+declare const vModelCheckbox: ModelDirective<HTMLInputElement>;
+declare const vModelRadio: ModelDirective<HTMLInputElement>;
+declare const vModelSelect: ModelDirective<HTMLSelectElement, 'number'>;
+declare const vModelDynamic: ObjectDirective<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+type VModelDirective = typeof vModelText | typeof vModelCheckbox | typeof vModelSelect | typeof vModelRadio | typeof vModelDynamic;
+/**
+ * This is a stub implementation to prevent the need to use dom types.
+ *
+ * To enable proper types, add `"dom"` to `"lib"` in your `tsconfig.json`.
+ */
+type DomStub = {};
+type DomType<T> = typeof globalThis extends {
+  window: unknown;
+} ? T : DomStub;
+declare module '@vue/reactivity' {
+  interface RefUnwrapBailTypes {
+    runtimeDOMBailTypes: DomType<Node | Window>;
+  }
+}
+declare module '@vue/runtime-core' {
+  interface GlobalComponents {
+    Transition: DefineComponent<TransitionProps>;
+    TransitionGroup: DefineComponent<TransitionGroupProps>;
+  }
+  interface GlobalDirectives {
+    vShow: typeof vShow;
+    vOn: VOnDirective;
+    vBind: VModelDirective;
+    vIf: Directive<any, boolean>;
+    VOnce: Directive;
+    VSlot: Directive;
+  }
+}
+//#endregion
+//#region src/plugins.d.ts
+type Plugin = RendererPluginDefinition;
+declare const usePlugins: () => {
+  load: () => void;
+  registerPlugins: (newPlugins: Plugin[]) => void;
+  plugins: ShallowRef<RendererPluginDefinition[], RendererPluginDefinition[]>;
+};
+//#endregion
+//#region src/subscription-errors.d.ts
+declare class SubscriptionRequiredError extends Error implements SubscriptionError {
+  readonly code: "SUBSCRIPTION_REQUIRED";
+  benefit: string;
+  userMessage: string;
+  constructor(benefit?: string);
+}
+declare class SubscriptionExpiredError extends Error implements SubscriptionError {
+  readonly code: "SUBSCRIPTION_EXPIRED";
+  benefit: string;
+  userMessage: string;
+  constructor(benefit?: string);
+}
+declare class BenefitNotFoundError extends Error implements SubscriptionError {
+  readonly code: "BENEFIT_NOT_FOUND";
+  benefit: string;
+  userMessage: string;
+  constructor(benefit: string);
+}
+declare class UnauthorizedError extends Error implements SubscriptionError {
+  readonly code: "UNAUTHORIZED";
+  benefit?: string;
+  userMessage: string;
+  constructor(message?: string, benefit?: string);
+}
+declare function createSubscriptionError(code: SubscriptionError["code"], benefit?: string, customMessage?: string): SubscriptionError;
+declare function isSubscriptionError(error: unknown): error is SubscriptionError;
+declare function getSubscriptionErrorMessage(error: unknown): string;
+//#endregion
+//#region src/supabase.d.ts
+declare const isSupabaseAvailable: () => boolean;
+declare const supabase: (options?: any) => _supabase_supabase_js0.SupabaseClient<Database, "public", "public", {
+  Tables: { [_ in never]: never };
+  Views: { [_ in never]: never };
+  Functions: { [_ in never]: never };
+  Enums: { [_ in never]: never };
+  CompositeTypes: { [_ in never]: never };
+}, {
+  PostgrestVersion: "12";
+}>;
+//#endregion
+//#region src/validation.d.ts
+declare const isRequired: (param: InputDefinition) => boolean;
+declare const isRenderer: () => boolean;
+//#endregion
+//#region src/index.d.ts
+declare const appSettingsMigrator: any;
+declare const defaultAppSettings: any;
+declare const fileRepoMigrations: any;
+declare const defaultFileRepo: any;
+declare const savedFileMigrator: any;
+declare const configRegistry: Record<string, Migrator<any>>;
+//#endregion
+export { Action, Agent, type AppConfig, type AppConfigV1, type AppConfigV2, type AppConfigV3, type AppConfigV4, type AppConfigV5, type AppConfigV6, type AppConfigV7, AppSettingsValidator, AppSettingsValidatorV1, AppSettingsValidatorV2, AppSettingsValidatorV3, AppSettingsValidatorV4, AppSettingsValidatorV5, AppSettingsValidatorV6, AppSettingsValidatorV7, AuthorizationCheck, AuthorizationContext, BaseNode, BenefitNotFoundError, Block, BlockAction, BlockComment, BlockCondition, BlockEvent, BlockLoop, BuildHistoryConfig, BuildHistoryEntry, BuildHistoryQuery, BuildHistoryResponse, Channels, Condition, Context, ControlType, ControlTypeArray, ControlTypeBase, ControlTypeBoolean, ControlTypeCheckbox, ControlTypeColor, ControlTypeElectronConfigureV2, ControlTypeExpression, ControlTypeInput, ControlTypeJSON, ControlTypeMultiSelect, ControlTypeNetlifySite, ControlTypePath, ControlTypeSelect, CreateQuickJSFn, Data$1 as Data, DataResult, Database, EditorParam, EditorParamValidatorV3, End, EndEvent, EnhancedFile, Enums, Event$1 as Event, Events, ExecutionError, ExecutionStep, Expression, ExtractInputsFromAction, ExtractInputsFromCondition, ExtractInputsFromEvent, ExtractInputsFromExpression, ExtractInputsFromLoop, GetDataEntries, GetDataKeys, GetFlowEntries, GetFlowKeys, HandleListenerRenderer, HandleListenerRendererSendFn, IBuildHistoryStorage, IconType, InputDefinition, InputOutputDefinition, InputsDefinition, InputsOutputsDefinition, IpcEvent, IpcMessage, Json, Locales, LogEntry, Loop, MainPluginDefinition, MessageSchema, Meta, type Migrator, Origin, OriginValidator, OutputDefinition, OutputsDefinition, ParamsToInput, PathOptions, PipelabNode, PipelabSelectOption, PluginDefinition, Position, Preset, PresetFn, PresetResult, Presets, PropType, RELEASE_SYNC, RendererChannels, RendererData, RendererEnd, RendererEvents, RendererMessage, RendererNodeDefinition, RendererPluginDefinition, RetentionPolicy, SaveLocation, SaveLocationExternal, SaveLocationExternalValidator, SaveLocationInternal, SaveLocationInternalValidator, SaveLocationPipelabCloud, SaveLocationPipelabCloudValidator, SaveLocationValidator, SavedFile, SavedFileDefault, SavedFileDefaultValidator, SavedFileSimple, SavedFileSimpleValidator, SavedFileV1, SavedFileV2, SavedFileV3, SavedFileV4, SavedFileValidator, SavedFileValidatorV1, SavedFileValidatorV2, SavedFileValidatorV3, SavedFileValidatorV4, SetOutputActionFn, SetOutputExpressionFn, SetOutputLoopFn, ShellChannels, Steps, SubscriptionBenefit, SubscriptionError, SubscriptionExpiredError, SubscriptionRequiredError, Tables, TablesInsert, TablesUpdate, UnauthorizedError, UpdateStatus, Variable, VariableBase, VariableValidatorV1, WebSocketAPI, WebSocketClientConfig, WebSocketClientEvents, WebSocketConnectionError, WebSocketConnectionInfo, WebSocketConnectionState, WebSocketError, WebSocketErrorMessage, WebSocketEvent, WebSocketHandler, WebSocketListener, WebSocketManager, WebSocketMessage, WebSocketMessageType, WebSocketRequestMessage, WebSocketResponseMessage, WebSocketResponseType, WebSocketSendFunction, WebSocketServerConfig, WebSocketServerEvents, WebSocketTimeoutError, WithId, appSettingsMigrator, configRegistry, createAction, createArray, createBooleanParam, createColorPicker, createCondition, createDefinition, createEvent, createExpression, createLoop, createNetlifySiteParam, createNodeDefinition, createNumberParam, createPasswordParam, createPathParam, createQuickJs, createQuickJsFromVariant, createRawParam, createStringParam, createSubscriptionError, createVersionSchema, __json_default_export as de_DE, defaultAppSettings, defaultFileRepo, __json_default_export$1 as en_US, __json_default_export$2 as es_ES, fileRepoMigrations, fmt, foo, __json_default_export$3 as fr_FR, getSubscriptionErrorMessage, isRenderer, isRequired, isSubscriptionError, isSupabaseAvailable, isWebSocketErrorMessage, isWebSocketRequestMessage, isWebSocketResponseMessage, makeResolvedParams, newVariant, processGraph, __json_default_export$4 as pt_BR, savedFileMigrator, supabase, useLogger, usePlugins, variableToFormattedVariable, __json_default_export$5 as zh_CN };
+//# sourceMappingURL=index.d.mts.map