appmax-client-vue3 5.0.8 → 5.1.0

package/dist/UserIndicationsPage-CD94gXNQ.js

@@ -0,0 +1,723 @@
+import { aO as AxiosError, E as ApiService, as as toRefs, x as reactive, L as nextTick, ab as userService, d4 as USER_INDICATIONS_PERMISIONS, ad as defineComponent, g as createElementBlock, h as openBlock, l as unref, H as withModifiers, i as createVNode, j as createBaseVNode, b_ as B, at as isRef, I as script, $, e as computed, ag as toaster, q as createBlock, K as script$1, w as withCtx, P, F as Fragment, k as createCommentVNode, G as f, y, m as createTextVNode, t as toDisplayString, A as w, o as onMounted } from "./main-BmrFFhAz.js";
+import { u as useQueryFilter } from "./useQueryFilter-CUjzwNVC.js";
+import { _ as _sfc_main$d, a as _sfc_main$e } from "./AmEmptyState.vue_vue_type_script_setup_true_lang-CwhBcd2N.js";
+import { a as script$2, s as script$3 } from "./index-Bgqt2gY9.js";
+import { A as AmCardV3 } from "./AmCardV3-DchSFKey.js";
+var UserIndicationStatus = /* @__PURE__ */ ((UserIndicationStatus2) => {
+  UserIndicationStatus2[UserIndicationStatus2["ALL"] = 0] = "ALL";
+  UserIndicationStatus2[UserIndicationStatus2["ACTIVE"] = 1] = "ACTIVE";
+  UserIndicationStatus2[UserIndicationStatus2["INACTIVE"] = 2] = "INACTIVE";
+  return UserIndicationStatus2;
+})(UserIndicationStatus || {});
+const parseUserIndicationsFilter = (userIndicationFilter) => {
+  const params = {
+    page: userIndicationFilter.page || 1,
+    sort: userIndicationFilter.sort || "desc",
+    indicator_id: userIndicationFilter.indicatorId,
+    indicated_id: userIndicationFilter.indicatedId,
+    status: userIndicationFilter.status || UserIndicationStatus.ALL
+  };
+  return params;
+};
+const parseUserIndicationsResponse = ({
+  result
+}) => {
+  const data = result.data.map((item) => ({
+    id: item.id,
+    indicatorId: item.indicator_id,
+    indicatedId: item.indicated_id,
+    indicatorName: item.indicator_name,
+    indicatedName: item.indicated_name,
+    createdAt: item.created_at
+  }));
+  const pagination = {
+    page: result.current_page,
+    lastPage: result.last_page,
+    total: result.total
+  };
+  return { data, pagination };
+};
+class UserIndicationsService {
+  constructor(apiService) {
+    this.apiService = apiService;
+  }
+  async getAll(userIndicationFilter) {
+    const route = "/api/user-indications";
+    const params = parseUserIndicationsFilter(userIndicationFilter);
+    const response = await this.apiService.get(route, { params });
+    return parseUserIndicationsResponse(response.data);
+  }
+  async create(userIndicationPayload) {
+    var _a, _b;
+    try {
+      const route = "/api/user-indications";
+      const payload = {
+        indicator_id: userIndicationPayload.indicatorId,
+        indicated_id: userIndicationPayload.indicatedId
+      };
+      await this.apiService.post(route, payload);
+    } catch (error) {
+      let message = "Erro no servidor";
+      if (error instanceof AxiosError) {
+        message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.error) || message;
+      }
+      throw new Error(message);
+    }
+  }
+  async remove(userIndicationId) {
+    const route = `/api/user-indications/${userIndicationId}`;
+    await this.apiService.delete(route);
+  }
+}
+const userIndicationsService = new UserIndicationsService(ApiService);
+const getInitialState = () => ({
+  isLoading: false,
+  error: false,
+  lastPage: 1,
+  data: [],
+  canCreate: false,
+  canRemove: false
+});
+const getInitialFilter = () => ({
+  indicatedId: "",
+  indicatorId: "",
+  page: 1,
+  status: 0
+});
+const state$2 = reactive(getInitialState());
+const filter = reactive(getInitialFilter());
+const setFilter = (newFilter) => {
+  const mergedFilter = { ...getInitialFilter(), ...newFilter };
+  Object.assign(filter, mergedFilter);
+};
+const queryFilter = useQueryFilter({
+  fields: [
+    { name: "indicatorId", valueType: "string" },
+    { name: "indicatedId", valueType: "string" },
+    { name: "page", valueType: "number" },
+    { name: "status", valueType: "number" }
+  ],
+  onChange: async (newFilter) => {
+    setFilter(newFilter);
+    await nextTick();
+    await getUserIndications();
+  }
+});
+const resetState = () => {
+  Object.assign(state$2, getInitialState());
+};
+const getUserIndications = async () => {
+  try {
+    state$2.isLoading = true;
+    state$2.error = false;
+    const { data, pagination } = await userIndicationsService.getAll({
+      indicatedId: Number(filter.indicatedId) || void 0,
+      indicatorId: Number(filter.indicatorId) || void 0,
+      status: filter.status,
+      page: filter.page
+    });
+    state$2.data = data;
+    state$2.lastPage = pagination.lastPage;
+  } catch (error) {
+    state$2.error = true;
+    state$2.data = [];
+    console.error("Error fetching user indications", error);
+  } finally {
+    state$2.isLoading = false;
+  }
+};
+const onPageChange = async (page) => {
+  queryFilter.set({ ...filter, page: page > 1 ? page : "" });
+};
+const onFilter = () => {
+  queryFilter.set({ ...filter, page: "" });
+};
+const onReset = async () => {
+  queryFilter.set({});
+};
+const onRefresh = async () => {
+  await getUserIndications();
+};
+const populatePermissions = async () => {
+  const { permissions } = await userService.getData();
+  state$2.canCreate = permissions.includes(USER_INDICATIONS_PERMISIONS.CREATE);
+  state$2.canRemove = permissions.includes(USER_INDICATIONS_PERMISIONS.REMOVE);
+};
+const initialize = async () => {
+  resetState();
+  populatePermissions();
+  queryFilter.syncFilter();
+};
+const useUserIndications = () => {
+  return {
+    ...toRefs(state$2),
+    ...toRefs(filter),
+    initialize,
+    onPageChange,
+    onFilter,
+    onRefresh,
+    onReset
+  };
+};
+const _hoisted_1$6 = { class: "flex gap-2" };
+const _sfc_main$c = /* @__PURE__ */ defineComponent({
+  __name: "UserIndicationsFilter",
+  setup(__props) {
+    const { onFilter: onFilter2, onReset: onReset2, isLoading, indicatorId, indicatedId, status } = useUserIndications();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("form", {
+        class: "grid sm:flex gap-2 items-end",
+        onSubmit: _cache[3] || (_cache[3] = withModifiers(
+          //@ts-ignore
+          (...args) => unref(onFilter2) && unref(onFilter2)(...args),
+          ["prevent"]
+        )),
+        onReset: _cache[4] || (_cache[4] = //@ts-ignore
+        (...args) => unref(onReset2) && unref(onReset2)(...args)),
+        autocomplete: "off"
+      }, [
+        createVNode(unref(B), {
+          "data-test-prefix": "indicator",
+          name: "indicatorId",
+          label: "Id do Indicador",
+          class: "sm:max-w-[115px]",
+          mask: "#########",
+          size: "small",
+          disabled: unref(isLoading),
+          modelValue: unref(indicatorId),
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(indicatorId) ? indicatorId.value = $event : null)
+        }, null, 8, ["disabled", "modelValue"]),
+        createVNode(unref(B), {
+          "data-test-prefix": "indicated",
+          name: "indicatedId",
+          label: "Id do Indicado",
+          class: "sm:max-w-[115px]",
+          mask: "#########",
+          size: "small",
+          disabled: unref(isLoading),
+          modelValue: unref(indicatedId),
+          "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(indicatedId) ? indicatedId.value = $event : null)
+        }, null, 8, ["disabled", "modelValue"]),
+        createVNode(unref(B), {
+          as: unref(script),
+          disabled: unref(isLoading),
+          options: [
+            { label: "Todos", value: 0 },
+            { label: "Ativos", value: 1 },
+            { label: "Inativos", value: 2 }
+          ],
+          modelValue: unref(status),
+          "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => isRef(status) ? status.value = $event : null),
+          optionLabel: "label",
+          optionValue: "value",
+          "data-test-prefix": "status",
+          name: "status",
+          label: "Status",
+          class: "sm:max-w-[115px] min-w-[115px]",
+          size: "small"
+        }, null, 8, ["as", "disabled", "modelValue"]),
+        createBaseVNode("div", _hoisted_1$6, [
+          createVNode(unref($), {
+            icon: "search",
+            label: "Filtrar",
+            type: "submit",
+            size: "small",
+            disabled: unref(isLoading)
+          }, null, 8, ["disabled"]),
+          createVNode(unref($), {
+            icon: "close",
+            label: "Limpar",
+            type: "reset",
+            size: "small",
+            disabled: unref(isLoading),
+            outlined: ""
+          }, null, 8, ["disabled"])
+        ])
+      ], 32);
+    };
+  }
+});
+const state$1 = reactive({
+  isSubmitting: false,
+  isModalOpen: false
+});
+const values = reactive({
+  indicatedId: "",
+  indicatorId: ""
+});
+const resetValues = () => {
+  values.indicatedId = "";
+  values.indicatorId = "";
+};
+const closeModal = () => {
+  state$1.isModalOpen = false;
+  resetValues();
+};
+const openModal = () => {
+  state$1.isModalOpen = true;
+  resetValues();
+};
+const onSubmit = async () => {
+  try {
+    state$1.isSubmitting = true;
+    await userIndicationsService.create({
+      indicatedId: Number(values.indicatedId),
+      indicatorId: Number(values.indicatorId)
+    });
+    toaster.success("Deu tudo certo!", "Nova indicação adicionada com sucesso");
+    closeModal();
+    useUserIndications().onRefresh();
+  } catch (error) {
+    toaster.error("Algo deu errado :(", error.message);
+    console.error("Error creating user indication", error);
+  } finally {
+    state$1.isSubmitting = false;
+  }
+};
+const isDisabled = computed(() => !values.indicatedId || !values.indicatorId);
+const useUserIndicationsCreate = () => {
+  return { ...toRefs(state$1), openModal, closeModal, onSubmit, isDisabled, values };
+};
+const _hoisted_1$5 = { class: "grid grid-cols-[1fr_48px_1fr]" };
+const _hoisted_2$2 = { class: "flex items-center justify-center pt-5" };
+const __default__$a = { name: "UserIndicationsCreateModal" };
+const _sfc_main$b = /* @__PURE__ */ defineComponent({
+  ...__default__$a,
+  setup(__props) {
+    const { isModalOpen, isSubmitting, isDisabled: isDisabled2, onSubmit: onSubmit2, values: values2 } = useUserIndicationsCreate();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(script$1), {
+        visible: unref(isModalOpen),
+        "onUpdate:visible": _cache[3] || (_cache[3] = ($event) => isRef(isModalOpen) ? isModalOpen.value = $event : null),
+        modal: true,
+        closable: true,
+        class: "max-w-md w-[90%]",
+        header: "Nova indicação",
+        pt: { header: { class: "pb-3" } }
+      }, {
+        default: withCtx(() => [
+          createBaseVNode("form", {
+            class: "grid gap-6",
+            autocomplete: "off",
+            onSubmit: _cache[2] || (_cache[2] = withModifiers(
+              //@ts-ignore
+              (...args) => unref(onSubmit2) && unref(onSubmit2)(...args),
+              ["prevent"]
+            ))
+          }, [
+            createBaseVNode("div", _hoisted_1$5, [
+              createVNode(unref(B), {
+                "data-test-prefix": "indicator",
+                label: "Id do indicador",
+                name: "indicatorId",
+                class: "w-full",
+                mask: "#########",
+                modelValue: unref(values2).indicatorId,
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(values2).indicatorId = $event)
+              }, null, 8, ["modelValue"]),
+              createBaseVNode("div", _hoisted_2$2, [
+                createVNode(unref(P), { icon: "arrow_right_alt" })
+              ]),
+              createVNode(unref(B), {
+                "data-test-prefix": "indicated",
+                label: "Id do indicado",
+                name: "indicatedId",
+                class: "w-full",
+                mask: "#########",
+                modelValue: unref(values2).indicatedId,
+                "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => unref(values2).indicatedId = $event)
+              }, null, 8, ["modelValue"])
+            ]),
+            createVNode(unref($), {
+              label: "Adicionar",
+              type: "submit",
+              disabled: unref(isDisabled2),
+              loading: unref(isSubmitting)
+            }, null, 8, ["disabled", "loading"])
+          ], 32)
+        ]),
+        _: 1
+      }, 8, ["visible"]);
+    };
+  }
+});
+const __default__$9 = { name: "UserIndicationsCreate" };
+const _sfc_main$a = /* @__PURE__ */ defineComponent({
+  ...__default__$9,
+  setup(__props) {
+    const { openModal: openModal2 } = useUserIndicationsCreate();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        createVNode(unref($), {
+          label: "Nova Indicação",
+          icon: "add",
+          size: "small",
+          class: "text-nowrap",
+          onClick: unref(openModal2)
+        }, null, 8, ["onClick"]),
+        createVNode(_sfc_main$b)
+      ], 64);
+    };
+  }
+});
+const _hoisted_1$4 = { class: "flex flex-col-reverse md:flex-row gap-4 md:justify-between md:items-end" };
+const __default__$8 = { name: "UserIndicationsHeader" };
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  ...__default__$8,
+  setup(__props) {
+    const { canCreate } = useUserIndications();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$4, [
+        createVNode(unref(_sfc_main$c)),
+        unref(canCreate) ? (openBlock(), createBlock(unref(_sfc_main$a), { key: 0 })) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const state = reactive({
+  isSubmitting: false,
+  userIndication: null,
+  isOpened: false
+});
+const onCancel = () => {
+  state.userIndication = null;
+  state.isSubmitting = false;
+  state.isOpened = false;
+};
+const onConfirm = async () => {
+  if (!state.userIndication) return onCancel();
+  try {
+    state.isSubmitting = true;
+    await userIndicationsService.remove(state.userIndication.id);
+    toaster.success("Indicação removida com sucesso");
+    useUserIndications().onRefresh();
+  } catch (error) {
+    toaster.error("Não foi possível remover a indicação");
+    console.error("Error removing user indication", error);
+  } finally {
+    state.isSubmitting = false;
+    onCancel();
+  }
+};
+const onDestroy = async (data) => {
+  state.userIndication = data;
+  state.isOpened = true;
+};
+const useUserIndicationsDestroy = () => {
+  return {
+    ...toRefs(state),
+    onDestroy,
+    onCancel,
+    onConfirm
+  };
+};
+const __default__$7 = { name: "UserIndicationsRemove" };
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  ...__default__$7,
+  props: {
+    data: {}
+  },
+  setup(__props) {
+    const { onDestroy: onDestroy2 } = useUserIndicationsDestroy();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(f), {
+        icon: "delete",
+        onClick: _cache[0] || (_cache[0] = ($event) => unref(onDestroy2)(_ctx.data))
+      });
+    };
+  }
+});
+const __default__$6 = { name: "UserIndicationsItem" };
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  ...__default__$6,
+  props: {
+    id: {},
+    name: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        createVNode(unref(y), { variant: "caption" }, {
+          default: withCtx(() => [
+            createTextVNode("ID: " + toDisplayString(_ctx.id), 1)
+          ]),
+          _: 1
+        }),
+        createVNode(unref(y), null, {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(_ctx.name), 1)
+          ]),
+          _: 1
+        })
+      ]);
+    };
+  }
+});
+const _hoisted_1$3 = { class: "flex items-center gap-2" };
+const __default__$5 = { name: "UserIndicationsTitle" };
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  ...__default__$5,
+  props: {
+    isIndicator: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const USER = {
+      indicator: {
+        icon: "north_east",
+        text: "Indicador"
+      },
+      indicated: {
+        icon: "call_received",
+        text: "Indicado"
+      }
+    };
+    const user = computed(() => props.isIndicator ? USER.indicator : USER.indicated);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$3, [
+        createVNode(unref(P), {
+          icon: user.value.icon
+        }, null, 8, ["icon"]),
+        createVNode(unref(y), {
+          variant: "subtitle",
+          isStrong: ""
+        }, {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(user.value.text), 1)
+          ]),
+          _: 1
+        })
+      ]);
+    };
+  }
+});
+const __default__$4 = { name: "UserIndicationsTable" };
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  ...__default__$4,
+  setup(__props) {
+    const { data, canRemove } = useUserIndications();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(script$2), {
+        class: "min-w-full",
+        value: unref(data)
+      }, {
+        default: withCtx(() => [
+          createVNode(unref(script$3), null, {
+            header: withCtx(() => [
+              createVNode(_sfc_main$6, { isIndicator: true })
+            ]),
+            body: withCtx(({ data: data2 }) => [
+              createVNode(_sfc_main$7, {
+                id: data2.indicatorId,
+                name: data2.indicatorName
+              }, null, 8, ["id", "name"])
+            ]),
+            _: 1
+          }),
+          createVNode(unref(script$3), null, {
+            header: withCtx(() => [
+              createVNode(_sfc_main$6, { isIndicator: false })
+            ]),
+            body: withCtx(({ data: data2 }) => [
+              createVNode(_sfc_main$7, {
+                id: data2.indicatedId,
+                name: data2.indicatedName
+              }, null, 8, ["id", "name"])
+            ]),
+            _: 1
+          }),
+          unref(canRemove) ? (openBlock(), createBlock(unref(script$3), {
+            key: 0,
+            pt: { bodyCell: { class: "!p-0 w-10" } }
+          }, {
+            body: withCtx(({ data: data2 }) => [
+              createVNode(_sfc_main$8, { data: data2 }, null, 8, ["data"])
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        _: 1
+      }, 8, ["value"]);
+    };
+  }
+});
+const _hoisted_1$2 = { class: "flex justify-between items-center gap-2" };
+const _hoisted_2$1 = {
+  key: 2,
+  class: "flex gap-2"
+};
+const __default__$3 = { name: "AmPagination" };
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  ...__default__$3,
+  props: {
+    page: {},
+    pages: {}
+  },
+  emits: ["next", "previous"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const hasNextPage = computed(() => __props.page < __props.pages);
+    const hasPreviousPage = computed(() => __props.page > 1);
+    const onNextPage = () => {
+      if (!hasNextPage.value) return;
+      const nextPage = __props.page + 1;
+      emit("next", nextPage);
+    };
+    const onPreviousPage = () => {
+      if (!hasPreviousPage.value) return;
+      const previousPage = __props.page - 1;
+      emit("previous", previousPage);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$2, [
+        _ctx.pages ? (openBlock(), createBlock(unref(y), { key: 0 }, {
+          default: withCtx(() => [
+            createTextVNode("Página " + toDisplayString(_ctx.page) + " de " + toDisplayString(_ctx.pages), 1)
+          ]),
+          _: 1
+        })) : (openBlock(), createBlock(unref(y), { key: 1 }, {
+          default: withCtx(() => [
+            createTextVNode("Página " + toDisplayString(_ctx.page), 1)
+          ]),
+          _: 1
+        })),
+        _ctx.pages > 1 ? (openBlock(), createElementBlock("div", _hoisted_2$1, [
+          createVNode(unref(f), {
+            icon: "chevron_left",
+            disabled: !hasPreviousPage.value,
+            onClick: onPreviousPage
+          }, null, 8, ["disabled"]),
+          createVNode(unref(f), {
+            icon: "chevron_right",
+            disabled: !hasNextPage.value,
+            onClick: onNextPage
+          }, null, 8, ["disabled"])
+        ])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const __default__$2 = { name: "UserIndicationsPagination" };
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  ...__default__$2,
+  setup(__props) {
+    const {
+      page,
+      lastPage,
+      onPageChange: onPageChange2
+    } = useUserIndications();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$4), {
+        page: unref(page),
+        pages: unref(lastPage),
+        onNext: unref(onPageChange2),
+        onPrevious: unref(onPageChange2)
+      }, null, 8, ["page", "pages", "onNext", "onPrevious"]);
+    };
+  }
+});
+const _hoisted_1$1 = { class: "grid grid-cols-2 my-5" };
+const _hoisted_2 = { class: "pr-4" };
+const _hoisted_3 = { class: "border-l border-gray-200 pl-4" };
+const _hoisted_4 = { class: "flex justify-end gap-2 mt-8" };
+const __default__$1 = { name: "UserIndicationsRemoveModal" };
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  ...__default__$1,
+  setup(__props) {
+    const { isOpened, isSubmitting, onCancel: onCancel2, onConfirm: onConfirm2, userIndication } = useUserIndicationsDestroy();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(script$1), {
+        visible: unref(isOpened),
+        "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => isRef(isOpened) ? isOpened.value = $event : null),
+        modal: true,
+        class: "max-w-md w-[90%]",
+        header: "Confirmação"
+      }, {
+        default: withCtx(() => [
+          createVNode(unref(y), null, {
+            default: withCtx(() => _cache[1] || (_cache[1] = [
+              createTextVNode("Você tem certeza que deseja desvincular essa indicação?")
+            ])),
+            _: 1
+          }),
+          createBaseVNode("div", _hoisted_1$1, [
+            createBaseVNode("div", _hoisted_2, [
+              createVNode(_sfc_main$6, { isIndicator: "" }),
+              createVNode(_sfc_main$7, {
+                class: "pl-7",
+                id: unref(userIndication).indicatorId,
+                name: unref(userIndication).indicatorName
+              }, null, 8, ["id", "name"])
+            ]),
+            createBaseVNode("div", _hoisted_3, [
+              createVNode(_sfc_main$6),
+              createVNode(_sfc_main$7, {
+                class: "pl-7",
+                id: unref(userIndication).indicatedId,
+                name: unref(userIndication).indicatedName
+              }, null, 8, ["id", "name"])
+            ])
+          ]),
+          createBaseVNode("div", _hoisted_4, [
+            createVNode(unref($), {
+              label: "Cancelar",
+              severity: "secondary",
+              disabled: unref(isSubmitting),
+              onClick: unref(onCancel2)
+            }, null, 8, ["disabled", "onClick"]),
+            createVNode(unref($), {
+              label: "Confirmar",
+              severity: "danger",
+              loading: unref(isSubmitting),
+              onClick: unref(onConfirm2)
+            }, null, 8, ["loading", "onClick"])
+          ])
+        ]),
+        _: 1
+      }, 8, ["visible"]);
+    };
+  }
+});
+const _hoisted_1 = {
+  key: 3,
+  class: "grid gap-4"
+};
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "UserIndicationsList",
+  setup(__props) {
+    const { isLoading, error, data } = useUserIndications();
+    return (_ctx, _cache) => {
+      return unref(error) ? (openBlock(), createBlock(_sfc_main$d, {
+        key: 0,
+        noretry: ""
+      })) : unref(isLoading) ? (openBlock(), createBlock(unref(w), {
+        key: 1,
+        class: "min-h-96"
+      })) : !unref(data).length ? (openBlock(), createBlock(_sfc_main$e, { key: 2 })) : (openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(_sfc_main$5),
+        createVNode(_sfc_main$3),
+        createVNode(unref(_sfc_main$2))
+      ]));
+    };
+  }
+});
+const __default__ = { name: "UserIndicationsPage" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  setup(__props) {
+    const { initialize: initialize2 } = useUserIndications();
+    onMounted(initialize2);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(AmCardV3, { class: "grid gap-4" }, {
+        default: withCtx(() => [
+          createVNode(unref(_sfc_main$9)),
+          createVNode(unref(_sfc_main$1))
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+export {
+  _sfc_main as default
+};