import { resolveComponent, mergeProps, withCtx, createTextVNode, withDirectives, createVNode, vShow, toRefs, computed, createElementVNode, Fragment, normalizeClass, inject, useSSRContext } from 'vue';
import { ssrRenderComponent } from 'vue/server-renderer';
import { _ as _export_sfc, r as VContainer, g as genericComponent, h as useGroup, i as useDisplay, j as getPropertyFromItem, k as provideDefaults, a as useRender, R as Ripple, c as useGroupItem, d as genOverlays, e as VIcon, f as useProxiedModel, u as useLocale, V as VDefaultsProvider, b as VBtn, p as propsFactory, l as pick, n as makeGroupProps, m as makeGroupItemProps, o as omit, I as IconValue, q as makeDisplayProps } from './server.mjs';
import { V as VSelect, a as VSheet, m as makeVSheetProps } from './VSelect-BX3KCscZ.mjs';
import { c as createSimpleFunctional } from './createSimpleFunctional-eaVhl3I5.mjs';
import { V as VAvatar } from './VAvatar-oghuaLjs.mjs';
import { V as VWindow, a as VWindowItem, m as makeVWindowProps, b as makeVWindowItemProps } from './VWindowItem-C-U9LBHC.mjs';
import { V as VDivider } from './VDivider-D3it--C7.mjs';
import '../nitro/nitro.mjs';
import 'luxon';
import '@sequelize/core';
import 'html-to-text';
import 'zod';
import 'crypto';
import 'node:fs';
import 'sharp';
import 'path';
import 'node:stream';
import 'jsdom';
import 'dompurify';
import 'mime-types';
import 'fs';
import 'fs/promises';
import 'linkify-html';
import '@peertube/http-signature';
import 'jsonld';
import 'lodash.intersection';
import 'email-templates';
import 'node:http';
import 'node:https';
import 'node:crypto';
import 'node:events';
import 'node:buffer';
import 'node:path';
import 'vue-router';
import 'dotenv';
import 'url';
import 'bcryptjs';
import 'slugify';
import 'umzug';
import 'consola';
import '@sequelize/core/decorators-legacy';
import 'util';
import 'mitt';
import 'ical.js';
import 'node:url';
import 'fast-xml-parser';
import 'perfect-debounce';
import 'v-calendar';
import 'linkifyjs';
import '../routes/renderer.mjs';
import 'vue-bundle-renderer/runtime';
import 'unhead/server';
import 'devalue';
import 'unhead/utils';
import './autofocus-DtAziIxK.mjs';
import './index-1z1zC4K2.mjs';
import './form-B9qqVmvI.mjs';
import './animation-Ilk0LvxU.mjs';
import './VTextField-Cxy8Koxy.mjs';
import './forwardRefs-C3iWxc5z.mjs';
import './VOverlay-DatVsI3B.mjs';
import './VMenu-eOMhQZM2.mjs';
import './VSelectionControl-zP2tQQmL.mjs';
import './VChip-BM5W0ePt.mjs';

const VStepperSymbol = /* @__PURE__ */ Symbol.for("vuetify:v-stepper");
const makeVStepperActionsProps = propsFactory({
  color: String,
  disabled: {
    type: [Boolean, String],
    default: false
  },
  prevText: {
    type: String,
    default: "$vuetify.stepper.prev"
  },
  nextText: {
    type: String,
    default: "$vuetify.stepper.next"
  }
}, "VStepperActions");
const VStepperActions = genericComponent()({
  name: "VStepperActions",
  props: makeVStepperActionsProps(),
  emits: {
    "click:prev": () => true,
    "click:next": () => true
  },
  setup(props, _ref) {
    let {
      emit,
      slots
    } = _ref;
    const {
      t
    } = useLocale();
    function onClickPrev() {
      emit("click:prev");
    }
    function onClickNext() {
      emit("click:next");
    }
    useRender(() => {
      const prevSlotProps = {
        onClick: onClickPrev
      };
      const nextSlotProps = {
        onClick: onClickNext
      };
      return createElementVNode("div", {
        "class": "v-stepper-actions"
      }, [createVNode(VDefaultsProvider, {
        "defaults": {
          VBtn: {
            disabled: ["prev", true].includes(props.disabled),
            text: t(props.prevText),
            variant: "text"
          }
        }
      }, {
        default: () => [slots.prev?.({
          props: prevSlotProps
        }) ?? createVNode(VBtn, prevSlotProps, null)]
      }), createVNode(VDefaultsProvider, {
        "defaults": {
          VBtn: {
            color: props.color,
            disabled: ["next", true].includes(props.disabled),
            text: t(props.nextText),
            variant: "tonal"
          }
        }
      }, {
        default: () => [slots.next?.({
          props: nextSlotProps
        }) ?? createVNode(VBtn, nextSlotProps, null)]
      })]);
    });
    return {};
  }
});
const VStepperHeader = createSimpleFunctional("v-stepper-header");
const makeStepperItemProps = propsFactory({
  color: String,
  title: String,
  subtitle: String,
  complete: Boolean,
  completeIcon: {
    type: IconValue,
    default: "$complete"
  },
  editable: Boolean,
  editIcon: {
    type: IconValue,
    default: "$edit"
  },
  error: Boolean,
  errorIcon: {
    type: IconValue,
    default: "$error"
  },
  icon: IconValue,
  ripple: {
    type: [Boolean, Object],
    default: true
  },
  rules: {
    type: Array,
    default: () => []
  }
}, "StepperItem");
const makeVStepperItemProps = propsFactory({
  ...makeStepperItemProps(),
  ...makeGroupItemProps()
}, "VStepperItem");
const VStepperItem = genericComponent()({
  name: "VStepperItem",
  directives: {
    vRipple: Ripple
  },
  props: makeVStepperItemProps(),
  emits: {
    "group:selected": (val) => true
  },
  setup(props, _ref) {
    let {
      slots
    } = _ref;
    const group = useGroupItem(props, VStepperSymbol, true);
    const step = computed(() => group?.value.value ?? props.value);
    const isValid = computed(() => props.rules.every((handler) => handler() === true));
    const isClickable = computed(() => !props.disabled && props.editable);
    const canEdit = computed(() => !props.disabled && props.editable);
    const hasError = computed(() => props.error || !isValid.value);
    const hasCompleted = computed(() => props.complete || props.rules.length > 0 && isValid.value);
    const icon = computed(() => {
      if (hasError.value) return props.errorIcon;
      if (hasCompleted.value) return props.completeIcon;
      if (group.isSelected.value && props.editable) return props.editIcon;
      return props.icon;
    });
    const slotProps = computed(() => ({
      canEdit: canEdit.value,
      hasError: hasError.value,
      hasCompleted: hasCompleted.value,
      title: props.title,
      subtitle: props.subtitle,
      step: step.value,
      value: props.value
    }));
    useRender(() => {
      const hasColor = (!group || group.isSelected.value || hasCompleted.value || canEdit.value) && !hasError.value && !props.disabled;
      const hasTitle = !!(props.title != null || slots.title);
      const hasSubtitle = !!(props.subtitle != null || slots.subtitle);
      function onClick() {
        group?.toggle();
      }
      return withDirectives(createElementVNode("button", {
        "class": normalizeClass(["v-stepper-item", {
          "v-stepper-item--complete": hasCompleted.value,
          "v-stepper-item--disabled": props.disabled,
          "v-stepper-item--error": hasError.value
        }, group?.selectedClass.value]),
        "disabled": !props.editable,
        "type": "button",
        "onClick": onClick
      }, [isClickable.value && genOverlays(true, "v-stepper-item"), createVNode(VAvatar, {
        "key": "stepper-avatar",
        "class": "v-stepper-item__avatar",
        "color": hasColor ? props.color : void 0,
        "size": 24
      }, {
        default: () => [slots.icon?.(slotProps.value) ?? (icon.value ? createVNode(VIcon, {
          "icon": icon.value
        }, null) : step.value)]
      }), createElementVNode("div", {
        "class": "v-stepper-item__content"
      }, [hasTitle && createElementVNode("div", {
        "key": "title",
        "class": "v-stepper-item__title"
      }, [slots.title?.(slotProps.value) ?? props.title]), hasSubtitle && createElementVNode("div", {
        "key": "subtitle",
        "class": "v-stepper-item__subtitle"
      }, [slots.subtitle?.(slotProps.value) ?? props.subtitle]), slots.default?.(slotProps.value)])]), [[Ripple, props.editable && props.ripple, null]]);
    });
    return {};
  }
});
const makeVStepperWindowProps = propsFactory({
  ...omit(makeVWindowProps(), ["continuous", "nextIcon", "prevIcon", "showArrows", "touch", "mandatory"])
}, "VStepperWindow");
const VStepperWindow = genericComponent()({
  name: "VStepperWindow",
  props: makeVStepperWindowProps(),
  emits: {
    "update:modelValue": (v) => true
  },
  setup(props, _ref) {
    let {
      slots
    } = _ref;
    const group = inject(VStepperSymbol, null);
    const _model = useProxiedModel(props, "modelValue");
    const model = computed({
      get() {
        if (_model.value != null || !group) return _model.value;
        return group.items.value.find((item) => group.selected.value.includes(item.id))?.value;
      },
      set(val) {
        _model.value = val;
      }
    });
    useRender(() => {
      const windowProps = VWindow.filterProps(props);
      return createVNode(VWindow, mergeProps({
        "_as": "VStepperWindow"
      }, windowProps, {
        "modelValue": model.value,
        "onUpdate:modelValue": ($event) => model.value = $event,
        "class": ["v-stepper-window", props.class],
        "style": props.style,
        "mandatory": false,
        "touch": false
      }), slots);
    });
    return {};
  }
});
const makeVStepperWindowItemProps = propsFactory({
  ...makeVWindowItemProps()
}, "VStepperWindowItem");
const VStepperWindowItem = genericComponent()({
  name: "VStepperWindowItem",
  props: makeVStepperWindowItemProps(),
  setup(props, _ref) {
    let {
      slots
    } = _ref;
    useRender(() => {
      const windowItemProps = VWindowItem.filterProps(props);
      return createVNode(VWindowItem, mergeProps({
        "_as": "VStepperWindowItem"
      }, windowItemProps, {
        "class": ["v-stepper-window-item", props.class],
        "style": props.style
      }), slots);
    });
    return {};
  }
});
const makeStepperProps = propsFactory({
  altLabels: Boolean,
  bgColor: String,
  completeIcon: IconValue,
  editIcon: IconValue,
  editable: Boolean,
  errorIcon: IconValue,
  hideActions: Boolean,
  items: {
    type: Array,
    default: () => []
  },
  itemTitle: {
    type: [String, Array, Function],
    default: "title"
  },
  itemValue: {
    type: [String, Array, Function],
    default: "value"
  },
  itemProps: {
    type: [Boolean, String, Array, Function],
    default: "props"
  },
  nonLinear: Boolean,
  flat: Boolean,
  ...makeDisplayProps()
}, "Stepper");
const makeVStepperProps = propsFactory({
  ...makeStepperProps(),
  ...makeGroupProps({
    mandatory: "force",
    selectedClass: "v-stepper-item--selected"
  }),
  ...makeVSheetProps(),
  ...pick(makeVStepperActionsProps(), ["prevText", "nextText"])
}, "VStepper");
const VStepper = genericComponent()({
  name: "VStepper",
  props: makeVStepperProps(),
  emits: {
    "update:modelValue": (v) => true
  },
  setup(props, _ref) {
    let {
      slots
    } = _ref;
    const {
      items: _items,
      next,
      prev,
      selected
    } = useGroup(props, VStepperSymbol);
    const {
      displayClasses,
      mobile
    } = useDisplay(props);
    const {
      completeIcon,
      editIcon,
      errorIcon,
      color,
      editable,
      prevText,
      nextText
    } = toRefs(props);
    const items = computed(() => props.items.map((item, index) => {
      const title = getPropertyFromItem(item, props.itemTitle, item);
      const value = getPropertyFromItem(item, props.itemValue, index + 1);
      const itemProps = props.itemProps === true ? item : getPropertyFromItem(item, props.itemProps);
      const _props = {
        title,
        value,
        ...itemProps
      };
      return {
        title: _props.title,
        value: _props.value,
        props: _props,
        raw: item
      };
    }));
    const activeIndex = computed(() => {
      return _items.value.findIndex((item) => selected.value.includes(item.id));
    });
    const disabled = computed(() => {
      if (props.disabled) return props.disabled;
      if (activeIndex.value === 0) return "prev";
      if (activeIndex.value === _items.value.length - 1) return "next";
      return false;
    });
    provideDefaults({
      VStepperItem: {
        editable,
        errorIcon,
        completeIcon,
        editIcon,
        prevText,
        nextText
      },
      VStepperActions: {
        color,
        disabled,
        prevText,
        nextText
      }
    });
    useRender(() => {
      const sheetProps = VSheet.filterProps(props);
      const hasHeader = !!(slots.header || props.items.length);
      const hasWindow = props.items.length > 0;
      const hasActions = !props.hideActions && !!(hasWindow || slots.actions);
      return createVNode(VSheet, mergeProps(sheetProps, {
        "color": props.bgColor,
        "class": ["v-stepper", {
          "v-stepper--alt-labels": props.altLabels,
          "v-stepper--flat": props.flat,
          "v-stepper--non-linear": props.nonLinear,
          "v-stepper--mobile": mobile.value
        }, displayClasses.value, props.class],
        "style": props.style
      }), {
        default: () => [hasHeader && createVNode(VStepperHeader, {
          "key": "stepper-header"
        }, {
          default: () => [items.value.map((_ref2, index) => {
            let {
              raw,
              ...item
            } = _ref2;
            return createElementVNode(Fragment, null, [!!index && createVNode(VDivider, null, null), createVNode(VStepperItem, item.props, {
              default: slots[`header-item.${item.value}`] ?? slots.header,
              icon: slots.icon,
              title: slots.title,
              subtitle: slots.subtitle
            })]);
          })]
        }), hasWindow && createVNode(VStepperWindow, {
          "key": "stepper-window"
        }, {
          default: () => [items.value.map((item) => createVNode(VStepperWindowItem, {
            "value": item.value
          }, {
            default: () => slots[`item.${item.value}`]?.(item) ?? slots.item?.(item)
          }))]
        }), slots.default?.({
          prev,
          next
        }), hasActions && (slots.actions?.({
          next,
          prev
        }) ?? createVNode(VStepperActions, {
          "key": "stepper-actions",
          "onClick:prev": prev,
          "onClick:next": next
        }, slots))]
      });
    });
    return {
      prev,
      next
    };
  }
});
function ssrRender(_ctx, _push, _parent, _attrs) {
  const _component_v_stepper_step = resolveComponent("v-stepper-step");
  const _component_v_stepper_items = resolveComponent("v-stepper-items");
  const _component_v_stepper_content = resolveComponent("v-stepper-content");
  const _component_DbStep = resolveComponent("DbStep");
  const _component_Settings = resolveComponent("Settings");
  const _component_Completed = resolveComponent("Completed");
  _push(ssrRenderComponent(VContainer, mergeProps({ class: "pa-6" }, _attrs), {
    default: withCtx((_, _push2, _parent2, _scopeId) => {
      if (_push2) {
        _push2(`<h2 class="mb-2 text-center"${_scopeId}>Gancio Setup</h2>`);
        _push2(ssrRenderComponent(VSelect, {
          label: "Select your language",
          "single-line": "",
          items: _ctx.$i18n.locales,
          "item-text": "name",
          "item-value": "code",
          onChange: (e) => _ctx.$i18n.setLocale(e)
        }, null, _parent2, _scopeId));
        _push2(ssrRenderComponent(VStepper, {
          class: "grey lighten-5",
          modelValue: _ctx.step,
          "onUpdate:modelValue": ($event) => _ctx.step = $event
        }, {
          default: withCtx((_2, _push3, _parent3, _scopeId2) => {
            if (_push3) {
              _push3(ssrRenderComponent(VStepperHeader, null, {
                default: withCtx((_3, _push4, _parent4, _scopeId3) => {
                  if (_push4) {
                    _push4(ssrRenderComponent(_component_v_stepper_step, {
                      style: !_ctx.dbdone ? null : { display: "none" },
                      complete: _ctx.step > 1,
                      step: "1"
                    }, {
                      default: withCtx((_4, _push5, _parent5, _scopeId4) => {
                        if (_push5) {
                          _push5(`Database`);
                        } else {
                          return [
                            createTextVNode("Database")
                          ];
                        }
                      }),
                      _: 1
                    }, _parent4, _scopeId3));
                    _push4(ssrRenderComponent(VDivider, {
                      style: !_ctx.dbdone ? null : { display: "none" }
                    }, null, _parent4, _scopeId3));
                    _push4(ssrRenderComponent(_component_v_stepper_step, {
                      complete: _ctx.step > 2,
                      step: "2"
                    }, {
                      default: withCtx((_4, _push5, _parent5, _scopeId4) => {
                        if (_push5) {
                          _push5(`Configuration`);
                        } else {
                          return [
                            createTextVNode("Configuration")
                          ];
                        }
                      }),
                      _: 1
                    }, _parent4, _scopeId3));
                    _push4(ssrRenderComponent(VDivider, null, null, _parent4, _scopeId3));
                    _push4(ssrRenderComponent(_component_v_stepper_step, {
                      complete: _ctx.step > 3,
                      step: "3"
                    }, {
                      default: withCtx((_4, _push5, _parent5, _scopeId4) => {
                        if (_push5) {
                          _push5(`Finish`);
                        } else {
                          return [
                            createTextVNode("Finish")
                          ];
                        }
                      }),
                      _: 1
                    }, _parent4, _scopeId3));
                  } else {
                    return [
                      withDirectives(createVNode(_component_v_stepper_step, {
                        complete: _ctx.step > 1,
                        step: "1"
                      }, {
                        default: withCtx(() => [
                          createTextVNode("Database")
                        ]),
                        _: 1
                      }, 8, ["complete"]), [
                        [vShow, !_ctx.dbdone]
                      ]),
                      withDirectives(createVNode(VDivider, null, null, 512), [
                        [vShow, !_ctx.dbdone]
                      ]),
                      createVNode(_component_v_stepper_step, {
                        complete: _ctx.step > 2,
                        step: "2"
                      }, {
                        default: withCtx(() => [
                          createTextVNode("Configuration")
                        ]),
                        _: 1
                      }, 8, ["complete"]),
                      createVNode(VDivider),
                      createVNode(_component_v_stepper_step, {
                        complete: _ctx.step > 3,
                        step: "3"
                      }, {
                        default: withCtx(() => [
                          createTextVNode("Finish")
                        ]),
                        _: 1
                      }, 8, ["complete"])
                    ];
                  }
                }),
                _: 1
              }, _parent3, _scopeId2));
              _push3(ssrRenderComponent(_component_v_stepper_items, null, {
                default: withCtx((_3, _push4, _parent4, _scopeId3) => {
                  if (_push4) {
                    _push4(ssrRenderComponent(_component_v_stepper_content, {
                      style: !_ctx.dbdone ? null : { display: "none" },
                      step: "1"
                    }, {
                      default: withCtx((_4, _push5, _parent5, _scopeId4) => {
                        if (_push5) {
                          _push5(ssrRenderComponent(_component_DbStep, { onComplete: _ctx.dbCompleted }, null, _parent5, _scopeId4));
                        } else {
                          return [
                            createVNode(_component_DbStep, { onComplete: _ctx.dbCompleted }, null, 8, ["onComplete"])
                          ];
                        }
                      }),
                      _: 1
                    }, _parent4, _scopeId3));
                    _push4(ssrRenderComponent(_component_v_stepper_content, { step: "2" }, {
                      default: withCtx((_4, _push5, _parent5, _scopeId4) => {
                        if (_push5) {
                          _push5(ssrRenderComponent(_component_Settings, {
                            setup: "",
                            onComplete: _ctx.configCompleted
                          }, null, _parent5, _scopeId4));
                        } else {
                          return [
                            createVNode(_component_Settings, {
                              setup: "",
                              onComplete: _ctx.configCompleted
                            }, null, 8, ["onComplete"])
                          ];
                        }
                      }),
                      _: 1
                    }, _parent4, _scopeId3));
                    _push4(ssrRenderComponent(_component_v_stepper_content, { step: "3" }, {
                      default: withCtx((_4, _push5, _parent5, _scopeId4) => {
                        if (_push5) {
                          _push5(ssrRenderComponent(_component_Completed, {
                            ref: "completed",
                            isHttp: _ctx.isHttp
                          }, null, _parent5, _scopeId4));
                        } else {
                          return [
                            createVNode(_component_Completed, {
                              ref: "completed",
                              isHttp: _ctx.isHttp
                            }, null, 8, ["isHttp"])
                          ];
                        }
                      }),
                      _: 1
                    }, _parent4, _scopeId3));
                  } else {
                    return [
                      withDirectives(createVNode(_component_v_stepper_content, { step: "1" }, {
                        default: withCtx(() => [
                          createVNode(_component_DbStep, { onComplete: _ctx.dbCompleted }, null, 8, ["onComplete"])
                        ]),
                        _: 1
                      }, 512), [
                        [vShow, !_ctx.dbdone]
                      ]),
                      createVNode(_component_v_stepper_content, { step: "2" }, {
                        default: withCtx(() => [
                          createVNode(_component_Settings, {
                            setup: "",
                            onComplete: _ctx.configCompleted
                          }, null, 8, ["onComplete"])
                        ]),
                        _: 1
                      }),
                      createVNode(_component_v_stepper_content, { step: "3" }, {
                        default: withCtx(() => [
                          createVNode(_component_Completed, {
                            ref: "completed",
                            isHttp: _ctx.isHttp
                          }, null, 8, ["isHttp"])
                        ]),
                        _: 1
                      })
                    ];
                  }
                }),
                _: 1
              }, _parent3, _scopeId2));
            } else {
              return [
                createVNode(VStepperHeader, null, {
                  default: withCtx(() => [
                    withDirectives(createVNode(_component_v_stepper_step, {
                      complete: _ctx.step > 1,
                      step: "1"
                    }, {
                      default: withCtx(() => [
                        createTextVNode("Database")
                      ]),
                      _: 1
                    }, 8, ["complete"]), [
                      [vShow, !_ctx.dbdone]
                    ]),
                    withDirectives(createVNode(VDivider, null, null, 512), [
                      [vShow, !_ctx.dbdone]
                    ]),
                    createVNode(_component_v_stepper_step, {
                      complete: _ctx.step > 2,
                      step: "2"
                    }, {
                      default: withCtx(() => [
                        createTextVNode("Configuration")
                      ]),
                      _: 1
                    }, 8, ["complete"]),
                    createVNode(VDivider),
                    createVNode(_component_v_stepper_step, {
                      complete: _ctx.step > 3,
                      step: "3"
                    }, {
                      default: withCtx(() => [
                        createTextVNode("Finish")
                      ]),
                      _: 1
                    }, 8, ["complete"])
                  ]),
                  _: 1
                }),
                createVNode(_component_v_stepper_items, null, {
                  default: withCtx(() => [
                    withDirectives(createVNode(_component_v_stepper_content, { step: "1" }, {
                      default: withCtx(() => [
                        createVNode(_component_DbStep, { onComplete: _ctx.dbCompleted }, null, 8, ["onComplete"])
                      ]),
                      _: 1
                    }, 512), [
                      [vShow, !_ctx.dbdone]
                    ]),
                    createVNode(_component_v_stepper_content, { step: "2" }, {
                      default: withCtx(() => [
                        createVNode(_component_Settings, {
                          setup: "",
                          onComplete: _ctx.configCompleted
                        }, null, 8, ["onComplete"])
                      ]),
                      _: 1
                    }),
                    createVNode(_component_v_stepper_content, { step: "3" }, {
                      default: withCtx(() => [
                        createVNode(_component_Completed, {
                          ref: "completed",
                          isHttp: _ctx.isHttp
                        }, null, 8, ["isHttp"])
                      ]),
                      _: 1
                    })
                  ]),
                  _: 1
                })
              ];
            }
          }),
          _: 1
        }, _parent2, _scopeId));
      } else {
        return [
          createVNode("h2", { class: "mb-2 text-center" }, "Gancio Setup"),
          createVNode(VSelect, {
            label: "Select your language",
            "single-line": "",
            items: _ctx.$i18n.locales,
            "item-text": "name",
            "item-value": "code",
            onChange: (e) => _ctx.$i18n.setLocale(e)
          }, null, 8, ["items", "onChange"]),
          createVNode(VStepper, {
            class: "grey lighten-5",
            modelValue: _ctx.step,
            "onUpdate:modelValue": ($event) => _ctx.step = $event
          }, {
            default: withCtx(() => [
              createVNode(VStepperHeader, null, {
                default: withCtx(() => [
                  withDirectives(createVNode(_component_v_stepper_step, {
                    complete: _ctx.step > 1,
                    step: "1"
                  }, {
                    default: withCtx(() => [
                      createTextVNode("Database")
                    ]),
                    _: 1
                  }, 8, ["complete"]), [
                    [vShow, !_ctx.dbdone]
                  ]),
                  withDirectives(createVNode(VDivider, null, null, 512), [
                    [vShow, !_ctx.dbdone]
                  ]),
                  createVNode(_component_v_stepper_step, {
                    complete: _ctx.step > 2,
                    step: "2"
                  }, {
                    default: withCtx(() => [
                      createTextVNode("Configuration")
                    ]),
                    _: 1
                  }, 8, ["complete"]),
                  createVNode(VDivider),
                  createVNode(_component_v_stepper_step, {
                    complete: _ctx.step > 3,
                    step: "3"
                  }, {
                    default: withCtx(() => [
                      createTextVNode("Finish")
                    ]),
                    _: 1
                  }, 8, ["complete"])
                ]),
                _: 1
              }),
              createVNode(_component_v_stepper_items, null, {
                default: withCtx(() => [
                  withDirectives(createVNode(_component_v_stepper_content, { step: "1" }, {
                    default: withCtx(() => [
                      createVNode(_component_DbStep, { onComplete: _ctx.dbCompleted }, null, 8, ["onComplete"])
                    ]),
                    _: 1
                  }, 512), [
                    [vShow, !_ctx.dbdone]
                  ]),
                  createVNode(_component_v_stepper_content, { step: "2" }, {
                    default: withCtx(() => [
                      createVNode(_component_Settings, {
                        setup: "",
                        onComplete: _ctx.configCompleted
                      }, null, 8, ["onComplete"])
                    ]),
                    _: 1
                  }),
                  createVNode(_component_v_stepper_content, { step: "3" }, {
                    default: withCtx(() => [
                      createVNode(_component_Completed, {
                        ref: "completed",
                        isHttp: _ctx.isHttp
                      }, null, 8, ["isHttp"])
                    ]),
                    _: 1
                  })
                ]),
                _: 1
              })
            ]),
            _: 1
          }, 8, ["modelValue", "onUpdate:modelValue"])
        ];
      }
    }),
    _: 1
  }, _parent));
}
const _sfc_main = {};
const _sfc_setup = _sfc_main.setup;
_sfc_main.setup = (props, ctx) => {
  const ssrContext = useSSRContext();
  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("pages/setup/_db.vue");
  return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
};
const _db = /* @__PURE__ */ _export_sfc(_sfc_main, [["ssrRender", ssrRender]]);

export { _db as default };
