import { QHeader, Header } from './Header-60ec61cf.js';
import { QSeparator } from './QSeparator-f2beec84.js';
import { QPageContainer, QLayout } from './Logo_D2-67d1a1d2.js';
import { _export_sfc } from './_plugin-vue_export-helper-e9a2c33e.js';
import { openBlock, createBlock, withCtx, createVNode, renderSlot, createBaseVNode, createComponent, onBeforeUnmount, h, Transition, shallowReactive, useRouterLinkProps, ref, computed, watch, withDirectives, vShow, hSlot, getCurrentInstance, QIcon, stopAndPrevent, createElementBlock, resolveComponent, createTextVNode, Ripple, pushScopeId, popScopeId } from './__federation_expose_Modules-a9c6a6fc.js';
import { QItem, QItemSection } from './QItem-1f9e6dcc.js';
import { QList } from './QList-5be5d7fb.js';
import { QItemLabel } from './QItemLabel-41c0a679.js';
import { useDarkProps, useDark } from './use-dark-b88930fe.js';
import { useModelToggleProps, useModelToggleEmits, useModelToggle } from './QMenu-97111d1f.js';
import { uid } from './uid-8cc7ec44.js';
import { QInput } from './QInput-a81d9a9f.js';

const UserGuideLayout_vue_vue_type_style_index_0_scoped_8010068e_lang = '';

const _sfc_main$4 = {
  name: 'Layout',
  data() {
    return {};
  },
  methods: {}
};
const _hoisted_1$3 = {
  class: "flex"
};
const _hoisted_2$2 = {
  class: "align-center-middle-wrap"
};
const _hoisted_3$2 = {
  class: "row"
};
const _hoisted_4$1 = {
  class: "col"
};
const _hoisted_5$1 = {
  class: "flex title-user-guide"
};
const _hoisted_6 = {
  class: "align-center-middle-wrap"
};
const _hoisted_7 = {
  class: "row"
};
const _hoisted_8 = {
  class: "col"
};
const _hoisted_9 = {
  class: "flex"
};
const _hoisted_10 = {
  class: "align-center-middle-wrap"
};
const _hoisted_11 = {
  class: "row",
  style: {
    "column-gap": "37px"
  }
};
const _hoisted_12 = {
  class: "col"
};
const _hoisted_13 = {
  class: "col-9"
};
function _sfc_render$4(_ctx, _cache, $props, $setup, $data, $options) {
  return openBlock(), createBlock(QLayout, null, {
    default: withCtx(() => [createVNode(QHeader, {
      style: {
        "height": "50px",
        "background-color": "white"
      },
      bordered: ""
    }, {
      default: withCtx(() => [renderSlot(_ctx.$slots, "header", {}, undefined, true)]),
      _: 3
    }), createVNode(QPageContainer, null, {
      default: withCtx(() => [createBaseVNode("div", _hoisted_1$3, [createBaseVNode("div", _hoisted_2$2, [createBaseVNode("div", _hoisted_3$2, [createBaseVNode("div", _hoisted_4$1, [renderSlot(_ctx.$slots, "navbar", {}, undefined, true)])])])]), createVNode(QSeparator), createBaseVNode("div", _hoisted_5$1, [createBaseVNode("div", _hoisted_6, [createBaseVNode("div", _hoisted_7, [createBaseVNode("div", _hoisted_8, [renderSlot(_ctx.$slots, "title", {}, undefined, true)])])])]), createBaseVNode("div", _hoisted_9, [createBaseVNode("div", _hoisted_10, [createBaseVNode("div", _hoisted_11, [createBaseVNode("div", _hoisted_12, [renderSlot(_ctx.$slots, "sidebar", {}, undefined, true)]), createBaseVNode("div", _hoisted_13, [renderSlot(_ctx.$slots, "content", {}, undefined, true)])])])])]),
      _: 3
    })]),
    _: 3
  });
}
const UserGuideLayout = /*#__PURE__*/_export_sfc(_sfc_main$4, [['render', _sfc_render$4], ['__scopeId', "data-v-8010068e"]]);

const QSlideTransition = createComponent({
  name: 'QSlideTransition',

  props: {
    appear: Boolean,
    duration: {
      type: Number,
      default: 300
    }
  },

  emits: [ 'show', 'hide' ],

  setup (props, { slots, emit }) {
    let animating = false, doneFn, element;
    let timer = null, timerFallback = null, animListener, lastEvent;

    function cleanup () {
      doneFn && doneFn();
      doneFn = null;
      animating = false;

      if (timer !== null) {
        clearTimeout(timer);
        timer = null;
      }

      if (timerFallback !== null) {
        clearTimeout(timerFallback);
        timerFallback = null;
      }

      element !== void 0 && element.removeEventListener('transitionend', animListener);
      animListener = null;
    }

    function begin (el, height, done) {
      // here overflowY is 'hidden'
      if (height !== void 0) {
        el.style.height = `${ height }px`;
      }
      el.style.transition = `height ${ props.duration }ms cubic-bezier(.25, .8, .50, 1)`;

      animating = true;
      doneFn = done;
    }

    function end (el, event) {
      el.style.overflowY = null;
      el.style.height = null;
      el.style.transition = null;
      cleanup();
      event !== lastEvent && emit(event);
    }

    function onEnter (el, done) {
      let pos = 0;
      element = el;

      // if animationg overflowY is already 'hidden'
      if (animating === true) {
        cleanup();
        pos = el.offsetHeight === el.scrollHeight ? 0 : void 0;
      }
      else {
        lastEvent = 'hide';
        el.style.overflowY = 'hidden';
      }

      begin(el, pos, done);

      timer = setTimeout(() => {
        timer = null;
        el.style.height = `${ el.scrollHeight }px`;
        animListener = evt => {
          timerFallback = null;

          if (Object(evt) !== evt || evt.target === el) {
            end(el, 'show');
          }
        };
        el.addEventListener('transitionend', animListener);
        timerFallback = setTimeout(animListener, props.duration * 1.1);
      }, 100);
    }

    function onLeave (el, done) {
      let pos;
      element = el;

      if (animating === true) {
        cleanup();
      }
      else {
        lastEvent = 'show';
        // we need to set overflowY 'hidden' before calculating the height
        // or else we get small differences
        el.style.overflowY = 'hidden';
        pos = el.scrollHeight;
      }

      begin(el, pos, done);

      timer = setTimeout(() => {
        timer = null;
        el.style.height = 0;
        animListener = evt => {
          timerFallback = null;

          if (Object(evt) !== evt || evt.target === el) {
            end(el, 'hide');
          }
        };
        el.addEventListener('transitionend', animListener);
        timerFallback = setTimeout(animListener, props.duration * 1.1);
      }, 100);
    }

    onBeforeUnmount(() => {
      animating === true && cleanup();
    });

    return () => h(Transition, {
      css: false,
      appear: props.appear,
      onEnter,
      onLeave
    }, slots.default)
  }
});

const itemGroups = shallowReactive({});
const LINK_PROPS = Object.keys(useRouterLinkProps);

const QExpansionItem = createComponent({
  name: 'QExpansionItem',

  props: {
    ...useRouterLinkProps,
    ...useModelToggleProps,
    ...useDarkProps,

    icon: String,

    label: String,
    labelLines: [ Number, String ],

    caption: String,
    captionLines: [ Number, String ],

    dense: Boolean,

    toggleAriaLabel: String,
    expandIcon: String,
    expandedIcon: String,
    expandIconClass: [ Array, String, Object ],
    duration: Number,

    headerInsetLevel: Number,
    contentInsetLevel: Number,

    expandSeparator: Boolean,
    defaultOpened: Boolean,
    hideExpandIcon: Boolean,
    expandIconToggle: Boolean,
    switchToggleSide: Boolean,
    denseToggle: Boolean,
    group: String,
    popup: Boolean,

    headerStyle: [ Array, String, Object ],
    headerClass: [ Array, String, Object ]
  },

  emits: [
    ...useModelToggleEmits,
    'click', 'afterShow', 'afterHide'
  ],

  setup (props, { slots, emit }) {
    const { proxy: { $q } } = getCurrentInstance();
    const isDark = useDark(props, $q);

    const showing = ref(
      props.modelValue !== null
        ? props.modelValue
        : props.defaultOpened
    );

    const blurTargetRef = ref(null);
    const targetUid = uid();

    const { show, hide, toggle } = useModelToggle({ showing });

    let uniqueId, exitGroup;

    const classes = computed(() =>
      'q-expansion-item q-item-type'
      + ` q-expansion-item--${ showing.value === true ? 'expanded' : 'collapsed' }`
      + ` q-expansion-item--${ props.popup === true ? 'popup' : 'standard' }`
    );

    const contentStyle = computed(() => {
      if (props.contentInsetLevel === void 0) {
        return null
      }

      const dir = $q.lang.rtl === true ? 'Right' : 'Left';
      return {
        [ 'padding' + dir ]: (props.contentInsetLevel * 56) + 'px'
      }
    });

    const hasLink = computed(() =>
      props.disable !== true && (
        props.href !== void 0
        || (props.to !== void 0 && props.to !== null && props.to !== '')
      )
    );

    const linkProps = computed(() => {
      const acc = {};
      LINK_PROPS.forEach(key => {
        acc[ key ] = props[ key ];
      });
      return acc
    });

    const isClickable = computed(() =>
      hasLink.value === true || props.expandIconToggle !== true
    );

    const expansionIcon = computed(() => (
      props.expandedIcon !== void 0 && showing.value === true
        ? props.expandedIcon
        : props.expandIcon || $q.iconSet.expansionItem[ props.denseToggle === true ? 'denseIcon' : 'icon' ]
    ));

    const activeToggleIcon = computed(() =>
      props.disable !== true && (hasLink.value === true || props.expandIconToggle === true)
    );

    const headerSlotScope = computed(() => ({
      expanded: showing.value === true,
      detailsId: props.targetUid,
      toggle,
      show,
      hide
    }));

    const toggleAriaAttrs = computed(() => {
      const toggleAriaLabel = props.toggleAriaLabel !== void 0
        ? props.toggleAriaLabel
        : $q.lang.label[ showing.value === true ? 'collapse' : 'expand' ](props.label);

      return {
        role: 'button',
        'aria-expanded': showing.value === true ? 'true' : 'false',
        'aria-controls': targetUid,
        'aria-label': toggleAriaLabel
      }
    });

    watch(() => props.group, name => {
      exitGroup !== void 0 && exitGroup();
      name !== void 0 && enterGroup();
    });

    function onHeaderClick (e) {
      hasLink.value !== true && toggle(e);
      emit('click', e);
    }

    function toggleIconKeyboard (e) {
      e.keyCode === 13 && toggleIcon(e, true);
    }

    function toggleIcon (e, keyboard) {
      keyboard !== true && blurTargetRef.value !== null && blurTargetRef.value.focus();
      toggle(e);
      stopAndPrevent(e);
    }

    function onShow () {
      emit('afterShow');
    }

    function onHide () {
      emit('afterHide');
    }

    function enterGroup () {
      if (uniqueId === void 0) {
        uniqueId = uid();
      }

      if (showing.value === true) {
        itemGroups[ props.group ] = uniqueId;
      }

      const show = watch(showing, val => {
        if (val === true) {
          itemGroups[ props.group ] = uniqueId;
        }
        else if (itemGroups[ props.group ] === uniqueId) {
          delete itemGroups[ props.group ];
        }
      });

      const group = watch(
        () => itemGroups[ props.group ],
        (val, oldVal) => {
          if (oldVal === uniqueId && val !== void 0 && val !== uniqueId) {
            hide();
          }
        }
      );

      exitGroup = () => {
        show();
        group();

        if (itemGroups[ props.group ] === uniqueId) {
          delete itemGroups[ props.group ];
        }

        exitGroup = void 0;
      };
    }

    function getToggleIcon () {
      const data = {
        class: [
          'q-focusable relative-position cursor-pointer'
            + `${ props.denseToggle === true && props.switchToggleSide === true ? ' items-end' : '' }`,
          props.expandIconClass
        ],
        side: props.switchToggleSide !== true,
        avatar: props.switchToggleSide
      };

      const child = [
        h(QIcon, {
          class: 'q-expansion-item__toggle-icon'
            + (props.expandedIcon === void 0 && showing.value === true
              ? ' q-expansion-item__toggle-icon--rotated'
              : ''),
          name: expansionIcon.value
        })
      ];

      if (activeToggleIcon.value === true) {
        Object.assign(data, {
          tabindex: 0,
          ...toggleAriaAttrs.value,
          onClick: toggleIcon,
          onKeyup: toggleIconKeyboard
        });

        child.unshift(
          h('div', {
            ref: blurTargetRef,
            class: 'q-expansion-item__toggle-focus q-icon q-focus-helper q-focus-helper--rounded',
            tabindex: -1
          })
        );
      }

      return h(QItemSection, data, () => child)
    }

    function getHeaderChild () {
      let child;

      if (slots.header !== void 0) {
        child = [].concat(slots.header(headerSlotScope.value));
      }
      else {
        child = [
          h(QItemSection, () => [
            h(QItemLabel, { lines: props.labelLines }, () => props.label || ''),

            props.caption
              ? h(QItemLabel, { lines: props.captionLines, caption: true }, () => props.caption)
              : null
          ])
        ];

        props.icon && child[ props.switchToggleSide === true ? 'push' : 'unshift' ](
          h(QItemSection, {
            side: props.switchToggleSide === true,
            avatar: props.switchToggleSide !== true
          }, () => h(QIcon, { name: props.icon }))
        );
      }

      if (props.disable !== true && props.hideExpandIcon !== true) {
        child[ props.switchToggleSide === true ? 'unshift' : 'push' ](
          getToggleIcon()
        );
      }

      return child
    }

    function getHeader () {
      const data = {
        ref: 'item',
        style: props.headerStyle,
        class: props.headerClass,
        dark: isDark.value,
        disable: props.disable,
        dense: props.dense,
        insetLevel: props.headerInsetLevel
      };

      if (isClickable.value === true) {
        data.clickable = true;
        data.onClick = onHeaderClick;

        Object.assign(
          data,
          hasLink.value === true ? linkProps.value : toggleAriaAttrs.value
        );
      }

      return h(QItem, data, getHeaderChild)
    }

    function getTransitionChild () {
      return withDirectives(
        h('div', {
          key: 'e-content',
          class: 'q-expansion-item__content relative-position',
          style: contentStyle.value,
          id: targetUid
        }, hSlot(slots.default)),
        [ [
          vShow,
          showing.value
        ] ]
      )
    }

    function getContent () {
      const node = [
        getHeader(),

        h(QSlideTransition, {
          duration: props.duration,
          onShow,
          onHide
        }, getTransitionChild)
      ];

      if (props.expandSeparator === true) {
        node.push(
          h(QSeparator, {
            class: 'q-expansion-item__border q-expansion-item__border--top absolute-top',
            dark: isDark.value
          }),
          h(QSeparator, {
            class: 'q-expansion-item__border q-expansion-item__border--bottom absolute-bottom',
            dark: isDark.value
          })
        );
      }

      return node
    }

    props.group !== void 0 && enterGroup();

    onBeforeUnmount(() => {
      exitGroup !== void 0 && exitGroup();
    });

    return () => h('div', { class: classes.value }, [
      h('div', { class: 'q-expansion-item__container relative-position' }, getContent())
    ])
  }
});

const _sfc_main$3 = {
  data() {
    return {
      filter: ''
    };
  }
};
function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
  return openBlock(), createElementBlock("div", null, [createVNode(QInput, {
    placeholder: "Search",
    outlined: "",
    dense: "",
    modelValue: $data.filter,
    "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => $data.filter = $event)
  }, null, 8, ["modelValue"])]);
}
const SearchInput = /*#__PURE__*/_export_sfc(_sfc_main$3, [['render', _sfc_render$3]]);

const UserGuideSidebar_vue_vue_type_style_index_0_scoped_3c78598b_lang = '';

const _sfc_main$2 = {
  components: {
    SearchInput
  },
  data() {
    return {
      introduction: false,
      components: false,
      howtouse: false,
      apis: false,
      troubleshooting: false,
      mlpipeline: false,
      hpo: false
    };
  },
  methods: {
    onClicked(itemFirstLevel, itemSecondLevel) {
      this.introduction = false;
      this.components = false;
      this.hpo = false;
      this.howtouse = false;
      this.apis = false;
      this.troubleshooting = false;
      this.mlpipeline = false;
      if (itemFirstLevel == 'introduction') {
        if (itemSecondLevel == 'docs') {
          this.introduction = true;
        } else if (itemSecondLevel == 'mlpipeline') {
          this.components = true;
          this.mlpipeline = true;
        } else if (itemSecondLevel == 'hpo') {
          this.components = true;
          this.hpo = true;
        }
      } else if (itemFirstLevel == 'components') {
        this.components = true;
      } else if (itemFirstLevel == 'mlpipeline' || itemFirstLevel == 'mlpipelinecomponents' || itemFirstLevel == 'samplecodes') {
        this.components = true;
        this.mlpipeline = true;
      } else if (itemFirstLevel == 'hpo' || itemFirstLevel == 'algorithms') {
        this.components = true;
        this.hpo = true;
      } else if (itemFirstLevel == 'howtouse' || itemFirstLevel == 'userinterface' || itemFirstLevel == 'startingtrainingprocedure' || itemFirstLevel == 'testingservingendpointapis') {
        this.howtouse = true;
      } else if (itemFirstLevel == 'apis') {
        this.apis = true;
      } else if (itemFirstLevel == 'troubleshooting') {
        this.troubleshooting = true;
      }
    },
    openInit() {
      var itemFirstLevel = this.$route.path.split('/').reverse()[0];
      var itemSecondLevel = this.$route.path.split('/').reverse()[1];
      if (itemFirstLevel == 'how-to-use') {
        itemFirstLevel = 'howtouse';
      } else if (itemFirstLevel == 'mlpipeline-components') {
        itemFirstLevel = 'mlpipelinecomponents';
      } else if (itemFirstLevel == 'sample-codes') {
        itemFirstLevel = 'samplecodes';
      } else if (itemFirstLevel == 'user-interface') {
        itemFirstLevel = 'userinterface';
      } else if (itemFirstLevel == 'starting-training-procedure') {
        itemFirstLevel = 'startingtrainingprocedure';
      } else if (itemFirstLevel == 'testing-serving-endpoint-apis') {
        itemFirstLevel = 'testingservingendpointapis';
      }
      this.onClicked(itemFirstLevel, itemSecondLevel);
    }
  },
  mounted() {
    this.openInit();
  }
};
const _hoisted_1$2 = {
  style: {
    "position": "sticky",
    "top": "20px"
  }
};
const _hoisted_2$1 = {
  class: "row",
  style: {
    "margin-bottom": "14px"
  }
};
const _hoisted_3$1 = {
  class: "col"
};
const _hoisted_4 = {
  class: "row"
};
const _hoisted_5 = {
  class: "col"
};
function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
  const _component_search_input = resolveComponent("search-input");
  return openBlock(), createElementBlock("div", _hoisted_1$2, [createBaseVNode("div", _hoisted_2$1, [createBaseVNode("div", _hoisted_3$1, [createVNode(_component_search_input)])]), createBaseVNode("div", _hoisted_4, [createBaseVNode("div", _hoisted_5, [createVNode(QList, {
    style: {
      "margin-left": "-35px"
    }
  }, {
    default: withCtx(() => [createVNode(QExpansionItem, {
      "content-header-level": 0,
      "content-inset-level": 1.5,
      modelValue: $data.introduction,
      "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => $data.introduction = $event),
      "switch-toggle-side": "",
      dense: "",
      "dense-toggle": "",
      label: "Introduction",
      to: {
        path: '/docs/introduction'
      },
      onClick: _cache[1] || (_cache[1] = $event => $options.onClicked('introduction', 'docs'))
    }, {
      default: withCtx(() => [createVNode(QList, null, {
        default: withCtx(() => [withDirectives((openBlock(), createBlock(QItem, {
          dense: "",
          clickable: "",
          exact: "",
          to: {
            path: '/docs/introduction',
            hash: '#what-is-d2-%3F'
          }
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("What is D2 ?")]),
            _: 1
          })]),
          _: 1
        })), [[Ripple]]), withDirectives((openBlock(), createBlock(QItem, {
          dense: "",
          clickable: "",
          exact: "",
          to: {
            path: '/docs/introduction',
            hash: '#why-d2-%3F'
          }
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("Why D2 ?")]),
            _: 1
          })]),
          _: 1
        })), [[Ripple]]), withDirectives((openBlock(), createBlock(QItem, {
          dense: "",
          clickable: "",
          exact: "",
          to: {
            path: '/docs/introduction',
            hash: '#architecture'
          }
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("Architecture")]),
            _: 1
          })]),
          _: 1
        })), [[Ripple]])]),
        _: 1
      })]),
      _: 1
    }, 8, ["content-inset-level", "modelValue"]), createVNode(QExpansionItem, {
      "header-inset-level": 0,
      "content-inset-level": 1.5,
      modelValue: $data.components,
      "onUpdate:modelValue": _cache[6] || (_cache[6] = $event => $data.components = $event),
      "switch-toggle-side": "",
      dense: "",
      "dense-toggle": "",
      label: "Components",
      to: "/docs/components",
      onClick: _cache[7] || (_cache[7] = $event => $options.onClicked('components'))
    }, {
      default: withCtx(() => [createVNode(QList, null, {
        default: withCtx(() => [createVNode(QExpansionItem, {
          style: {
            "margin-left": "-20px"
          },
          "content-inset-level": 1.5,
          modelValue: $data.mlpipeline,
          "onUpdate:modelValue": _cache[2] || (_cache[2] = $event => $data.mlpipeline = $event),
          "switch-toggle-side": "",
          dense: "",
          "dense-toggle": "",
          label: "Machine Learning Pipeline",
          to: "/docs/components/mlpipeline",
          onClick: _cache[3] || (_cache[3] = $event => $options.onClicked('mlpipeline', 'components'))
        }, {
          default: withCtx(() => [createVNode(QList, null, {
            default: withCtx(() => [withDirectives((openBlock(), createBlock(QItem, {
              dense: "",
              clickable: "",
              to: "/docs/components/mlpipeline/introduction"
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("Introduction")]),
                _: 1
              })]),
              _: 1
            })), [[Ripple]]), withDirectives((openBlock(), createBlock(QItem, {
              dense: "",
              clickable: "",
              to: "/docs/components/mlpipeline/mlpipeline-components"
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("Pipeline components")]),
                _: 1
              })]),
              _: 1
            })), [[Ripple]])]),
            _: 1
          })]),
          _: 1
        }, 8, ["content-inset-level", "modelValue"]), createVNode(QExpansionItem, {
          style: {
            "margin-left": "-20px"
          },
          "content-inset-level": 1.5,
          modelValue: $data.hpo,
          "onUpdate:modelValue": _cache[4] || (_cache[4] = $event => $data.hpo = $event),
          "switch-toggle-side": "",
          dense: "",
          "dense-toggle": "",
          label: "Hyperparameters Optimizer",
          to: "/docs/components/hpo",
          onClick: _cache[5] || (_cache[5] = $event => $options.onClicked('hpo', 'components'))
        }, {
          default: withCtx(() => [createVNode(QList, null, {
            default: withCtx(() => [withDirectives((openBlock(), createBlock(QItem, {
              dense: "",
              clickable: "",
              to: "/docs/components/hpo/introduction"
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("Introduction")]),
                _: 1
              })]),
              _: 1
            })), [[Ripple]]), withDirectives((openBlock(), createBlock(QItem, {
              dense: "",
              clickable: "",
              to: "/docs/components/hpo/algorithms"
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("Optimizer Algorithms")]),
                _: 1
              })]),
              _: 1
            })), [[Ripple]])]),
            _: 1
          })]),
          _: 1
        }, 8, ["content-inset-level", "modelValue"])]),
        _: 1
      })]),
      _: 1
    }, 8, ["content-inset-level", "modelValue"]), createVNode(QExpansionItem, {
      "content-header-level": 0,
      "content-inset-level": 1.5,
      modelValue: $data.howtouse,
      "onUpdate:modelValue": _cache[8] || (_cache[8] = $event => $data.howtouse = $event),
      "switch-toggle-side": "",
      dense: "",
      "dense-toggle": "",
      label: "How to use",
      to: "/docs/how-to-use",
      onClick: _cache[9] || (_cache[9] = $event => $options.onClicked('howtouse', ''))
    }, {
      default: withCtx(() => [createVNode(QList, null, {
        default: withCtx(() => [withDirectives((openBlock(), createBlock(QItem, {
          dense: "",
          clickable: "",
          to: "/docs/how-to-use/user-interface"
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("User Interface (UI)")]),
            _: 1
          })]),
          _: 1
        })), [[Ripple]]), withDirectives((openBlock(), createBlock(QItem, {
          dense: "",
          clickable: "",
          to: "/docs/how-to-use/starting-training-procedure"
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("Starting Training Procedure")]),
            _: 1
          })]),
          _: 1
        })), [[Ripple]]), withDirectives((openBlock(), createBlock(QItem, {
          dense: "",
          clickable: "",
          to: "/docs/how-to-use/testing-serving-endpoint-apis"
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("Testing Serving Endpoint APIs")]),
            _: 1
          })]),
          _: 1
        })), [[Ripple]])]),
        _: 1
      })]),
      _: 1
    }, 8, ["content-inset-level", "modelValue"]), createVNode(QExpansionItem, {
      "content-header-level": 0,
      "content-inset-level": 1.5,
      modelValue: $data.apis,
      "onUpdate:modelValue": _cache[10] || (_cache[10] = $event => $data.apis = $event),
      "switch-toggle-side": "",
      dense: "",
      "dense-toggle": "",
      label: "APIs",
      to: "/docs/apis",
      onClick: _cache[11] || (_cache[11] = $event => $options.onClicked('apis'))
    }, {
      default: withCtx(() => [createVNode(QList, null, {
        default: withCtx(() => [withDirectives((openBlock(), createBlock(QItem, {
          dense: "",
          clickable: "",
          to: "/docs/apis/model-training"
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("Model Tranining")]),
            _: 1
          })]),
          _: 1
        })), [[Ripple]]), withDirectives((openBlock(), createBlock(QItem, {
          dense: "",
          clickable: "",
          to: "/docs/apis/model-serving"
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("Model Serving")]),
            _: 1
          })]),
          _: 1
        })), [[Ripple]])]),
        _: 1
      })]),
      _: 1
    }, 8, ["content-inset-level", "modelValue"]), createVNode(QExpansionItem, {
      "content-header-level": 0,
      "content-inset-level": 1.5,
      modelValue: $data.troubleshooting,
      "onUpdate:modelValue": _cache[12] || (_cache[12] = $event => $data.troubleshooting = $event),
      "switch-toggle-side": "",
      dense: "",
      "dense-toggle": "",
      label: "Troubleshooting",
      to: "/docs/troubleshooting",
      onClick: _cache[13] || (_cache[13] = $event => $options.onClicked('troubleshooting', ''))
    }, {
      default: withCtx(() => [createVNode(QList, null, {
        default: withCtx(() => [withDirectives((openBlock(), createBlock(QItem, {
          dense: "",
          clickable: "",
          to: "/docs/troubleshooting/tbd"
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("T.B.D")]),
            _: 1
          })]),
          _: 1
        })), [[Ripple]])]),
        _: 1
      })]),
      _: 1
    }, 8, ["content-inset-level", "modelValue"])]),
    _: 1
  })])])]);
}
const UserGuideSidebar = /*#__PURE__*/_export_sfc(_sfc_main$2, [['render', _sfc_render$2], ['__scopeId', "data-v-3c78598b"]]);

const UserGuideNavbar_vue_vue_type_style_index_0_scoped_5f6d2024_lang = '';

const _sfc_main$1 = {};
const _withScopeId$1 = n => (pushScopeId("data-v-5f6d2024"), n = n(), popScopeId(), n);
const _hoisted_1$1 = {
  class: "navbar"
};
const _hoisted_2 = /*#__PURE__*/_withScopeId$1(() => /*#__PURE__*/createBaseVNode("span", null, "New training / User guide", -1));
const _hoisted_3 = [_hoisted_2];
function _sfc_render$1(_ctx, _cache) {
  return openBlock(), createElementBlock("div", _hoisted_1$1, _hoisted_3);
}
const UserGuideNavbar = /*#__PURE__*/_export_sfc(_sfc_main$1, [['render', _sfc_render$1], ['__scopeId', "data-v-5f6d2024"]]);

const index_vue_vue_type_style_index_0_scoped_ccc2e667_lang = '';

const _sfc_main = {
  components: {
    UserGuideLayout,
    UserGuideSidebar,
    UserGuideNavbar,
    Header
  },
  data() {
    return {};
  }
};
const _withScopeId = n => (pushScopeId("data-v-ccc2e667"), n = n(), popScopeId(), n);
const _hoisted_1 = /*#__PURE__*/_withScopeId(() => /*#__PURE__*/createBaseVNode("div", {
  class: "title"
}, "User Guide", -1));
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
  const _component_Header = resolveComponent("Header");
  const _component_user_guide_navbar = resolveComponent("user-guide-navbar");
  const _component_user_guide_sidebar = resolveComponent("user-guide-sidebar");
  const _component_router_view = resolveComponent("router-view");
  const _component_user_guide_layout = resolveComponent("user-guide-layout");
  return openBlock(), createElementBlock("div", null, [createVNode(_component_user_guide_layout, {
    showSideBar: false
  }, {
    header: withCtx(() => [createVNode(_component_Header)]),
    navbar: withCtx(() => [createVNode(_component_user_guide_navbar)]),
    title: withCtx(() => [_hoisted_1]),
    sidebar: withCtx(() => [createVNode(_component_user_guide_sidebar)]),
    content: withCtx(() => [createVNode(_component_router_view)]),
    _: 1
  })]);
}
const index = /*#__PURE__*/_export_sfc(_sfc_main, [['render', _sfc_render], ['__scopeId', "data-v-ccc2e667"]]);

export { index as default };
