jk-vue-comps 0.1.5 → 0.1.6

package/dist/chunks/vuePropTypes-BV0onEYv.js

@@ -0,0 +1,34 @@
+var r = Object.defineProperty;
+var l = (c, a, o) => a in c ? r(c, a, { enumerable: !0, configurable: !0, writable: !0, value: o }) : c[a] = o;
+var s = (c, a, o) => (l(c, typeof a != "symbol" ? a + "" : a, o), o);
+import * as n from "vue-types";
+const { createTypes: u, toValidableType: i } = n, t = void 0;
+class e extends u({
+  func: t,
+  bool: t,
+  string: t,
+  number: t,
+  object: t,
+  integer: t
+}) {
+  static get style() {
+    return i("style", {
+      type: [String, Object],
+      default: t
+    });
+  }
+  static get vueNode() {
+    return i("vueNode", { default: t });
+  }
+}
+s(e, "vueTypes", n), s(e, "anyType", n.any), s(e, "stringType", n.string), s(e, "boolType", n.bool), s(e, "numberType", n.number), s(e, "funcType", n.func);
+const y = e, d = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: e,
+  propTypes: y
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  e as V,
+  d as a,
+  y as p
+};

package/dist/chunks/withInstall-b5j1glXj.js

@@ -0,0 +1,14 @@
+function r(t, l) {
+  const e = t;
+  return e.install = (o) => {
+    o.component(e.name || e.displayName, t), l && (o.config.globalProperties[l] = t);
+  }, t;
+}
+const a = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  withInstall: r
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  a,
+  r as w
+};

package/dist/components/GoogleAuth.d.ts

@@ -0,0 +1,95 @@
+import { type SlotsType } from 'vue';
+/** 跳转谷歌身份检查 */
+export declare function toGoogleAuth(clientId: string, redirectUri: string): void;
+/** 谷歌身份检查 */
+export declare const GoogleAuth: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+        clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+        redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+    }>> & {
+        onCallback?: ((_data: {
+            code: string;
+        }) => any) | undefined;
+        onRejectCallback?: ((_data: any) => any) | undefined;
+    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        callback: (_data: {
+            code: string;
+        }) => true;
+        rejectCallback: (_data: any) => true;
+    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+        clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+        redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+    }>> & {
+        onCallback?: ((_data: {
+            code: string;
+        }) => any) | undefined;
+        onRejectCallback?: ((_data: any) => any) | undefined;
+    }, {
+        clientId: string;
+        redirectUri: string;
+    }, true, {}, SlotsType<{
+        default: {
+            startCheck: () => void;
+        };
+    }>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+        redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+    }>> & {
+        onCallback?: ((_data: {
+            code: string;
+        }) => any) | undefined;
+        onRejectCallback?: ((_data: any) => any) | undefined;
+    }, () => JSX.Element, {}, {}, {}, {
+        clientId: string;
+        redirectUri: string;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+}>> & {
+    onCallback?: ((_data: {
+        code: string;
+    }) => any) | undefined;
+    onRejectCallback?: ((_data: any) => any) | undefined;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    callback: (_data: {
+        code: string;
+    }) => true;
+    rejectCallback: (_data: any) => true;
+}, string, {
+    clientId: string;
+    redirectUri: string;
+}, {}, string, SlotsType<{
+    default: {
+        startCheck: () => void;
+    };
+}>> & (import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & ({
+    readonly toGoogleAuth: typeof toGoogleAuth;
+} & import("vue").Plugin)));
+export default GoogleAuth;

package/dist/components/GoogleAuth.js

@@ -0,0 +1,70 @@
+import { defineComponent as g, ref as p, onMounted as h, createVNode as C } from "vue";
+import { p as f } from "../chunks/vuePropTypes-BV0onEYv.js";
+import { C as w, A as _ } from "../chunks/is-bvgc5qxU.js";
+import { w as b } from "../chunks/withInstall-b5j1glXj.js";
+function v(o, r) {
+  if (!o || !r)
+    return;
+  const c = encodeURIComponent(r), a = encodeURIComponent("email profile"), i = encodeURIComponent(o), n = `https://accounts.google.com/o/oauth2/v2/auth?response_type=code&redirect_uri=${c}&scope=${a}&client_id=${i}`;
+  w() ? window.open(n, "_self") : window.location.href = n;
+}
+const I = /* @__PURE__ */ g({
+  name: "GoogleAuth",
+  toGoogleAuth: v,
+  props: {
+    clientId: f.string,
+    redirectUri: f.string
+  },
+  emits: {
+    callback: (o) => !0,
+    rejectCallback: (o) => !0
+  },
+  slots: Object,
+  setup(o, {
+    emit: r,
+    slots: c,
+    expose: a
+  }) {
+    const i = p(null), n = p(!0), s = () => {
+      var e, t, l;
+      return (l = (t = (e = window == null ? void 0 : window.google) == null ? void 0 : e.accounts) == null ? void 0 : t.oauth2) == null ? void 0 : l.initCodeClient;
+    };
+    function d() {
+      var e, t, l;
+      (l = (t = (e = s()) == null ? void 0 : e({
+        client_id: o.clientId,
+        scope: "email profile",
+        redirect_uri: o.redirectUri,
+        ux_mode: _() ? "redirect" : "popup",
+        callback(u) {
+          u.error ? r("rejectCallback", u) : r("callback", u);
+        }
+      })) == null ? void 0 : t.requestCode) == null || l.call(t);
+    }
+    function m() {
+      if (!(window != null && window.document) || s() || !i.value) {
+        s() && (n.value = !1);
+        return;
+      }
+      const e = document.createElement("script");
+      e.async = !0, e.defer = !0, e.src = "https://accounts.google.com/gsi/client", i.value.appendChild(e), e.onload = () => {
+        s() && (n.value = !1);
+      };
+    }
+    return h(m), a({
+      startCheck: d
+    }), () => {
+      var e;
+      return C("div", {
+        ref: i
+      }, [!n.value && ((e = c.default) == null ? void 0 : e.call(c, {
+        startCheck: d
+      }))]);
+    };
+  }
+}), R = b(I);
+export {
+  R as GoogleAuth,
+  R as default,
+  v as toGoogleAuth
+};

package/dist/components/TelegramAuth.d.ts

@@ -0,0 +1,96 @@
+import { type SlotsType } from 'vue';
+/** tg用户信息 */
+export type TgUserData = {
+    auth_date: number;
+    first_name: string;
+    hash: string;
+    id: number;
+    last_name: string;
+    photo_url: string;
+    username: string;
+};
+/** 跳转Telegram身份检查 */
+export declare function toTelegramAuth(botId: number, toPath: string): void;
+/** 获取路由中的Telegram身份检查回调参数 */
+export declare function getTelegramAuthUrlParams(): TgUserData | null;
+/** Telegram身份检查 */
+export declare const TelegramAuth: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+        botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+            default: number;
+        };
+        toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+    }>> & {
+        onCallback?: ((_user: TgUserData) => any) | undefined;
+        onRejectCallback?: (() => any) | undefined;
+    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        callback: (_user: TgUserData) => true;
+        rejectCallback: () => true;
+    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+        botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+            default: number;
+        };
+        toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+    }>> & {
+        onCallback?: ((_user: TgUserData) => any) | undefined;
+        onRejectCallback?: (() => any) | undefined;
+    }, {
+        botId: number;
+        toPath: string;
+    }, true, {}, SlotsType<{
+        default: {
+            startCheck: () => void;
+        };
+    }>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+            default: number;
+        };
+        toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+    }>> & {
+        onCallback?: ((_user: TgUserData) => any) | undefined;
+        onRejectCallback?: (() => any) | undefined;
+    }, () => JSX.Element, {}, {}, {}, {
+        botId: number;
+        toPath: string;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+}>> & {
+    onCallback?: ((_user: TgUserData) => any) | undefined;
+    onRejectCallback?: (() => any) | undefined;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    callback: (_user: TgUserData) => true;
+    rejectCallback: () => true;
+}, string, {
+    botId: number;
+    toPath: string;
+}, {}, string, SlotsType<{
+    default: {
+        startCheck: () => void;
+    };
+}>> & (import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & ({
+    readonly toTelegramAuth: typeof toTelegramAuth;
+    readonly getTelegramAuthUrlParams: typeof getTelegramAuthUrlParams;
+} & import("vue").Plugin)));
+export default TelegramAuth;

package/dist/components/TelegramAuth.js

@@ -0,0 +1,91 @@
+import { defineComponent as h, ref as g, onMounted as w, createVNode as b } from "vue";
+import { p as m } from "../chunks/vuePropTypes-BV0onEYv.js";
+import { a as A } from "../chunks/index-2VK0fFTB.js";
+import { w as C } from "../chunks/withInstall-b5j1glXj.js";
+import { C as _, A as p } from "../chunks/is-bvgc5qxU.js";
+function d(r, o) {
+  if (!r || !o)
+    return;
+  const t = encodeURIComponent(A()), n = encodeURIComponent(o), a = `https://oauth.telegram.org/auth?bot_id=${r}&origin=${t}&embed=1&request_access=write&return_to=${t}${n}`;
+  _() ? window.open(a, "_self") : window.location.href = a;
+}
+function T() {
+  const r = /[#\?\&]tgAuthResult=([A-Za-z0-9\-_=]*)$/;
+  try {
+    const o = window.location.hash.toString(), t = o.match(r);
+    if (!t)
+      return null;
+    window.location.hash = o.replace(r, "");
+    let n = t[1].replace(/-/g, "+").replace(/_/g, "/");
+    const a = n.length % 4;
+    return a > 1 && (n += new Array(5 - a).join("=")), n ? JSON.parse(window.atob(n)) : null;
+  } catch {
+    return null;
+  }
+}
+const j = /* @__PURE__ */ h({
+  name: "TelegramAuth",
+  toTelegramAuth: d,
+  getTelegramAuthUrlParams: T,
+  props: {
+    botId: m.number,
+    toPath: m.string
+  },
+  emits: {
+    callback: (r) => !0,
+    rejectCallback: () => !0
+  },
+  slots: Object,
+  setup(r, {
+    emit: o,
+    slots: t,
+    expose: n
+  }) {
+    const a = g(null), i = () => {
+      var e, c;
+      return (c = (e = window == null ? void 0 : window.Telegram) == null ? void 0 : e.Login) == null ? void 0 : c.auth;
+    };
+    function l() {
+      const {
+        botId: e,
+        toPath: c
+      } = r;
+      if (!e)
+        return;
+      const s = i();
+      if (p() || !s) {
+        d(e, c);
+        return;
+      }
+      s == null || s({
+        bot_id: e,
+        request_access: !0
+      }, (u) => {
+        u ? o("callback", u) : o("rejectCallback");
+      });
+    }
+    function f() {
+      var c;
+      if (!(window != null && window.document) || i() || p())
+        return;
+      const e = document.createElement("script");
+      e.async = !0, e.defer = !0, e.src = "https://telegram.org/js/telegram-widget.js", (c = a.value) == null || c.appendChild(e);
+    }
+    return w(f), n({
+      startCheck: l
+    }), () => {
+      var e;
+      return b("div", {
+        ref: a
+      }, [(e = t.default) == null ? void 0 : e.call(t, {
+        startCheck: l
+      })]);
+    };
+  }
+}), R = C(j);
+export {
+  R as TelegramAuth,
+  R as default,
+  T as getTelegramAuthUrlParams,
+  d as toTelegramAuth
+};

package/dist/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './GoogleAuth';
+export * from './TelegramAuth';

package/dist/components/index.js

@@ -0,0 +1,9 @@
+import { GoogleAuth as t, toGoogleAuth as r } from "./GoogleAuth.js";
+import { TelegramAuth as l, getTelegramAuthUrlParams as m, toTelegramAuth as a } from "./TelegramAuth.js";
+export {
+  t as GoogleAuth,
+  l as TelegramAuth,
+  m as getTelegramAuthUrlParams,
+  r as toGoogleAuth,
+  a as toTelegramAuth
+};

package/dist/index.d.ts

@@ -0,0 +1,227 @@
+import * as comps from './components';
+import * as utils from './utils';
+export * from './components';
+export * from './utils';
+declare const JKVUEComps: {
+    Utils: {
+        is: typeof import("./utils/is");
+        propTypes: typeof import("./utils/vuePropTypes");
+        timeZone: typeof import("./utils/timeZone");
+        withInstall: typeof import("./utils/withInstall");
+    };
+    Comps: typeof comps;
+    evalPro(str: string): any;
+    filterInputNum(e: string | number, type?: "int" | "float", maxDecimal?: number): string;
+    generateHandleInputFn<T extends object, K extends keyof T>(obj: T, key: K, fn?: (() => void) | undefined, type?: "int" | "float", maxDecimal?: number): (e: ChangeEvent) => void;
+    renderHtmlStr(html: string): string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    getWebsiteUrl(): string;
+    getRouterParams(): Recordable<any> | undefined;
+    is(val: unknown, type: string): boolean;
+    isDef<T_1 = unknown>(val?: T_1 | undefined): val is T_1;
+    isUnDef<T_2 = unknown>(val?: T_2 | undefined): val is T_2;
+    isObject(val: any): val is Record<any, any>;
+    isDate(val: unknown): val is Date;
+    isNull(val: unknown): val is null;
+    isNullAndUnDef(val: unknown): val is null | undefined;
+    isNullOrUnDef(val: unknown): val is null | undefined;
+    isNumber(val: unknown): val is number;
+    isString(val: unknown): val is string;
+    isFunction(val: unknown): val is Function;
+    isBoolean(val: unknown): val is boolean;
+    isRegExp(val: unknown): val is RegExp;
+    isArray(val: any): val is any[];
+    isEmpty<T_3 = unknown>(val: T_3): val is T_3;
+    isPromise<T_4 = any>(val: unknown): val is Promise<T_4>;
+    isPromiseLink<T_5>(it: T_5 | PromiseLike<T_5>): it is PromiseLike<T_5>;
+    isWindow(val: any): val is Window;
+    isElement(val: unknown): val is Element;
+    isMap(val: unknown): val is Map<any, any>;
+    isUrl(path: string): boolean;
+    isValidPhoneNumber(phoneNumber: string): boolean;
+    isInMobileBrowser(): false | RegExpMatchArray | null;
+    isZhLang(lang: string): boolean;
+    isEdgeBrowser(): boolean;
+    isServer: boolean;
+    isClient: boolean;
+    isIp: (ip: string) => boolean;
+    isEmail: (email: string) => boolean;
+    isHtmlStr: (str: string) => boolean;
+    propTypes: typeof import("./utils/vuePropTypes").default;
+    timeZoneOptions: utils.TimeZoneItem[];
+    withInstall<T_6>(component: T_6, alias?: string | undefined): T_6 & import("vue").Plugin;
+    toGoogleAuth(clientId: string, redirectUri: string): void;
+    GoogleAuth: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+            clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+            redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_data: {
+                code: string;
+            }) => any) | undefined;
+            onRejectCallback?: ((_data: any) => any) | undefined;
+        }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            callback: (_data: {
+                code: string;
+            }) => true;
+            rejectCallback: (_data: any) => true;
+        }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+            redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_data: {
+                code: string;
+            }) => any) | undefined;
+            onRejectCallback?: ((_data: any) => any) | undefined;
+        }, {
+            clientId: string;
+            redirectUri: string;
+        }, true, {}, import("vue").SlotsType<{
+            default: {
+                startCheck: () => void;
+            };
+        }>, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+            redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_data: {
+                code: string;
+            }) => any) | undefined;
+            onRejectCallback?: ((_data: any) => any) | undefined;
+        }, () => JSX.Element, {}, {}, {}, {
+            clientId: string;
+            redirectUri: string;
+        }>;
+        __isFragment?: undefined;
+        __isTeleport?: undefined;
+        __isSuspense?: undefined;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+        redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+    }>> & {
+        onCallback?: ((_data: {
+            code: string;
+        }) => any) | undefined;
+        onRejectCallback?: ((_data: any) => any) | undefined;
+    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        callback: (_data: {
+            code: string;
+        }) => true;
+        rejectCallback: (_data: any) => true;
+    }, string, {
+        clientId: string;
+        redirectUri: string;
+    }, {}, string, import("vue").SlotsType<{
+        default: {
+            startCheck: () => void;
+        };
+    }>> & (import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & ({
+        readonly toGoogleAuth: typeof comps.toGoogleAuth;
+    } & import("vue").Plugin)));
+    toTelegramAuth(botId: number, toPath: string): void;
+    getTelegramAuthUrlParams(): comps.TgUserData | null;
+    TelegramAuth: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+            botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+                default: number;
+            };
+            toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_user: comps.TgUserData) => any) | undefined;
+            onRejectCallback?: (() => any) | undefined;
+        }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            callback: (_user: comps.TgUserData) => true;
+            rejectCallback: () => true;
+        }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+                default: number;
+            };
+            toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_user: comps.TgUserData) => any) | undefined;
+            onRejectCallback?: (() => any) | undefined;
+        }, {
+            botId: number;
+            toPath: string;
+        }, true, {}, import("vue").SlotsType<{
+            default: {
+                startCheck: () => void;
+            };
+        }>, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+                default: number;
+            };
+            toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_user: comps.TgUserData) => any) | undefined;
+            onRejectCallback?: (() => any) | undefined;
+        }, () => JSX.Element, {}, {}, {}, {
+            botId: number;
+            toPath: string;
+        }>;
+        __isFragment?: undefined;
+        __isTeleport?: undefined;
+        __isSuspense?: undefined;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+            default: number;
+        };
+        toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+    }>> & {
+        onCallback?: ((_user: comps.TgUserData) => any) | undefined;
+        onRejectCallback?: (() => any) | undefined;
+    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        callback: (_user: comps.TgUserData) => true;
+        rejectCallback: () => true;
+    }, string, {
+        botId: number;
+        toPath: string;
+    }, {}, string, import("vue").SlotsType<{
+        default: {
+            startCheck: () => void;
+        };
+    }>> & (import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & ({
+        readonly toTelegramAuth: typeof comps.toTelegramAuth;
+        readonly getTelegramAuthUrlParams: typeof comps.getTelegramAuthUrlParams;
+    } & import("vue").Plugin)));
+};
+export default JKVUEComps;