@blocklet/aigne-hub 0.2.7

package/lib/esm/components/subscribe/alert.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLocaleContext } from '@arcblock/ux/lib/Locale/context';
+import { Alert, CircularProgress, Stack } from '@mui/material';
+import { SubscriptionErrorType } from '../../api/error';
+import withLocaleProvider from '../../utils/withLocaleProvider';
+import SubscribeButton from './button';
+import { useAIKitServiceStatus } from './state';
+function SubscribeErrorAlert({ error, ...props }) {
+    const { t } = useLocaleContext();
+    const isUnsubscribeError = (error === null || error === void 0 ? void 0 : error.type) === SubscriptionErrorType.UNSUBSCRIBED;
+    const loading = useAIKitServiceStatus((i) => i.loading);
+    const subscription = useAIKitServiceStatus((i) => { var _a; return (_a = i.app) === null || _a === void 0 ? void 0 : _a.subscription; });
+    const useAIKitService = useAIKitServiceStatus((i) => { var _a, _b; return (_b = (_a = i.app) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.useAIKitService; });
+    const isPastDue = (subscription === null || subscription === void 0 ? void 0 : subscription.status) === 'past_due';
+    const message = !isUnsubscribeError
+        ? error.message
+        : !subscription
+            ? t('notSubscribeTip')
+            : isPastDue
+                ? t('pastDueTip')
+                : !useAIKitService
+                    ? t('notEnableAIServiceTip')
+                    : t('successTip');
+    return (_jsxs(Alert, { severity: isUnsubscribeError && subscription && useAIKitService ? 'info' : 'warning', ...props, sx: {
+            px: 1,
+            py: 0,
+            '& .MuiAlert-message': {
+                width: '100%',
+            },
+            ...props.sx,
+        }, children: [isUnsubscribeError && loading ? _jsx(CircularProgress, { size: 18 }) : message, isUnsubscribeError && (_jsx(Stack, { direction: "row", sx: { justifyContent: 'flex-end' }, children: _jsx(SubscribeButton, { shouldOpenInNewTab: true, showUseAIServiceButton: true }) }))] }));
+}
+export default withLocaleProvider(SubscribeErrorAlert, {
+    translations: {
+        en: {
+            notSubscribeTip: 'Hello, please subscribe to AI service first!',
+            pastDueTip: 'Your AI service has expired, please renew it first!',
+            notEnableAIServiceTip: 'You have not enabled AI service, please enable AI service first!',
+            successTip: 'Congratulations, your subscription is successful!',
+        },
+        zh: {
+            notSubscribeTip: '你好，请订阅 AI 服务后继续！',
+            pastDueTip: '您的 AI 服务已过期，请续订后继续！',
+            notEnableAIServiceTip: '您尚未启用AI服务，请启用 AI 服务后继续！',
+            successTip: '恭喜，您的订阅已生效！',
+        },
+    },
+});

package/lib/esm/components/subscribe/button.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLocaleContext } from '@arcblock/ux/lib/Locale/context';
+import Toast from '@arcblock/ux/lib/Toast';
+import { LoadingButton } from '@mui/lab';
+import { Typography } from '@mui/material';
+import { useCallback, useEffect, useState } from 'react';
+import { joinURL, withQuery } from 'ufo';
+import { appServiceRegister } from '../../api/app';
+import withLocaleProvider from '../../utils/withLocaleProvider';
+import { useAIKitServiceStatus } from './state';
+function SubscribeButton({ shouldOpenInNewTab = false, showUseAIServiceButton = false, }) {
+    const { t } = useLocaleContext();
+    const fetch = useAIKitServiceStatus((i) => i.fetch);
+    const isSubscriptionAvailable = useAIKitServiceStatus((i) => { var _a; return (_a = i.computed) === null || _a === void 0 ? void 0 : _a.isSubscriptionAvailable; });
+    const loading = useAIKitServiceStatus((i) => i.loading);
+    const setConfig = useAIKitServiceStatus((i) => i.setConfig);
+    const subscription = useAIKitServiceStatus((i) => { var _a; return (_a = i.app) === null || _a === void 0 ? void 0 : _a.subscription; });
+    const useAIKitService = useAIKitServiceStatus((i) => { var _a, _b; return (_b = (_a = i.app) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.useAIKitService; });
+    const subscriptionDetailUrl = useAIKitServiceStatus((i) => { var _a; return (_a = i.app) === null || _a === void 0 ? void 0 : _a.subscriptionDetailUrl; });
+    const isPastDue = (subscription === null || subscription === void 0 ? void 0 : subscription.status) === 'past_due';
+    const [submitting, setSubmitting] = useState(false);
+    const linkToAiKit = useCallback(async () => {
+        var _a, _b;
+        setSubmitting(true);
+        try {
+            const res = await appServiceRegister();
+            if (res.paymentLink) {
+                const { origin, href } = window.location;
+                const prefix = ((_b = (_a = window.blocklet) === null || _a === void 0 ? void 0 : _a.componentMountPoints.find((i) => i.name === 'ai-kit')) === null || _b === void 0 ? void 0 : _b.mountPoint) || '/';
+                const payLink = withQuery(res.paymentLink, {
+                    redirect: withQuery(joinURL(origin, prefix, '/api/app/client/subscription/success'), { redirect: href }),
+                });
+                if (shouldOpenInNewTab) {
+                    const win = window.open(payLink, '_blank');
+                    win === null || win === void 0 ? void 0 : win.focus();
+                }
+                else {
+                    window.location.href = payLink;
+                }
+            }
+        }
+        catch (error) {
+            Toast.error(error.message);
+            throw error;
+        }
+        finally {
+            setSubmitting(false);
+        }
+    }, [shouldOpenInNewTab]);
+    useEffect(() => {
+        fetch();
+    }, [fetch]);
+    if (!loading && !isSubscriptionAvailable) {
+        return (_jsx(LoadingButton, { onClick: isPastDue && subscriptionDetailUrl ? undefined : linkToAiKit, href: subscriptionDetailUrl, size: "small", variant: "outlined", color: isPastDue ? 'error' : 'primary', type: "button", sx: { mx: 0.5, minWidth: 0 }, loading: submitting, children: _jsx(Typography, { noWrap: true, children: t(isPastDue ? 'aiServicePastDue' : 'subscribeAIService') }) }, "button"));
+    }
+    if (showUseAIServiceButton && isSubscriptionAvailable && !useAIKitService) {
+        return (_jsx(LoadingButton, { loading: submitting, onClick: async () => {
+                setSubmitting(true);
+                try {
+                    await setConfig({ useAIKitService: true });
+                    Toast.success('Successfully changed to AI service!');
+                }
+                catch (error) {
+                    Toast.error(error.message);
+                    throw error;
+                }
+                finally {
+                    setSubmitting(false);
+                }
+            }, children: t('useAIService') }));
+    }
+    return null;
+}
+export default withLocaleProvider(SubscribeButton, {
+    translations: {
+        en: {
+            subscribeAIService: 'Subscribe AI Service',
+            aiServicePastDue: 'Pay for overdue AI service',
+            useAIService: 'Enable AI Service',
+        },
+        zh: {
+            subscribeAIService: '订阅 AI 服务',
+            aiServicePastDue: '支付 AI 服务欠费',
+            useAIService: '启用 AI 服务',
+        },
+    },
+});

package/lib/esm/components/subscribe/state.js

@@ -0,0 +1,39 @@
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+import { appStatus, setAppConfig } from '../../api/app';
+export const useAIKitServiceStatus = create()(immer((set, get) => ({
+    loading: true,
+    fetch: async () => {
+        set((state) => {
+            state.loading = true;
+        });
+        try {
+            const app = await appStatus();
+            set((state) => {
+                state.app = app;
+                state.error = undefined;
+                state.loading = false;
+            });
+        }
+        catch (error) {
+            set((state) => {
+                state.error = error;
+                state.loading = false;
+            });
+        }
+    },
+    setConfig: async (config) => {
+        const result = await setAppConfig(config);
+        set((state) => {
+            if (state.app)
+                state.app.config = result;
+        });
+    },
+    computed: {
+        get isSubscriptionAvailable() {
+            var _a;
+            const subscription = (_a = get().app) === null || _a === void 0 ? void 0 : _a.subscription;
+            return subscription && ['active', 'trialing'].includes(subscription.status);
+        },
+    },
+})));

package/lib/esm/components/switch-button.js

@@ -0,0 +1,46 @@
+import { Switch } from '@mui/material';
+import { styled } from '@mui/system';
+const SwitchButton = styled(Switch)(({ variant = 'success', theme }) => {
+    var _a, _b;
+    return ({
+        width: 28,
+        height: 16,
+        padding: 0,
+        display: 'inline-flex',
+        '&:active': {
+            '& .MuiSwitch-thumb': {
+                width: 15,
+            },
+            '& .MuiSwitch-switchBase.Mui-checked': {
+                transform: 'translateX(9px)',
+            },
+        },
+        '& .MuiSwitch-switchBase': {
+            padding: 2,
+            '&.Mui-checked': {
+                transform: 'translateX(12px)',
+                color: '#fff',
+                '& + .MuiSwitch-track': {
+                    opacity: 1,
+                    backgroundColor: (_a = theme.palette[variant]) === null || _a === void 0 ? void 0 : _a.light,
+                },
+            },
+        },
+        '& .MuiSwitch-thumb': {
+            boxShadow: '0 2px 4px 0 rgb(0 35 11 / 20%)',
+            width: 12,
+            height: 12,
+            borderRadius: 6,
+            transition: (_b = theme.transitions) === null || _b === void 0 ? void 0 : _b.create(['width'], {
+                duration: 200,
+            }),
+        },
+        '& .MuiSwitch-track': {
+            borderRadius: 16 / 2,
+            opacity: 1,
+            backgroundColor: theme.palette.mode === 'dark' ? 'rgba(255,255,255,.35)' : 'rgba(0,0,0,.25)',
+            boxSizing: 'border-box',
+        },
+    });
+});
+export default SwitchButton;

package/lib/esm/components/table.js

@@ -0,0 +1,198 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import Datatable from '@arcblock/ux/lib/Datatable';
+import Empty from '@arcblock/ux/lib/Empty';
+import { useLocaleContext } from '@arcblock/ux/lib/Locale/context';
+import { useMediaQuery, useTheme } from '@mui/material';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { styled } from '@mui/system';
+/* eslint-disable @typescript-eslint/indent */
+import React from 'react';
+import withLocaleProvider from '../utils/withLocaleProvider';
+function EmptyStub() {
+    return null;
+}
+const Table = React.memo(({ options, columns, toolbar = true, footer = true, hasRowLink = false, emptyNodeText = '', ...rest }) => {
+    const { locale, t } = useLocaleContext();
+    const theme = useTheme();
+    const isMobile = useMediaQuery(theme.breakpoints.down('md'));
+    const defaultOptions = {
+        print: false,
+        download: false,
+        filter: false,
+        selectableRows: 'none',
+        rowsPerPage: isMobile ? 5 : 10,
+        rowsPerPageOptions: [5, 10, 20, 50, 100],
+        searchDebounceTime: 300,
+        tableBodyHeight: '100%',
+        loading: true,
+    };
+    const components = {};
+    if (!toolbar) {
+        components.TableToolbar = EmptyStub;
+    }
+    if (!footer) {
+        components.TableFooter = EmptyStub;
+    }
+    // components.TableHead = EmptyStub2
+    return (_jsx(Wrapped, { locale: locale, options: { ...defaultOptions, ...options }, columns: columns.map((x) => {
+            x.options = x.options || {};
+            x.options.filter = x.options.filter || false;
+            x.options.sort = x.options.sort || false;
+            return x;
+        }), emptyNode: _jsx(Empty, { children: emptyNodeText || t('empty') }), ...rest, components: components, hasRowLink: hasRowLink, isMobile: isMobile }));
+});
+const Wrapped = styled(Datatable) `
+  ${(props) => (props === null || props === void 0 ? void 0 : props.hasRowLink)
+    ? `.MuiTableCell-root {
+    font-size: 0.875rem !important;
+  }`
+    : ''}
+  .MuiPaper-root {
+    border-radius: 8px;
+    overflow: hidden;
+  }
+  table.MuiTable-root {
+    outline: 1px solid;
+    outline-color: ${({ theme }) => theme.palette.grey[100]};
+    border-radius: ${({ theme }) => `${2 * theme.shape.borderRadius}px`};
+    overflow: hidden;
+  }
+  [class*='MUIDataTable-responsiveBase'] {
+    outline: 1px solid;
+    outline-color: ${({ theme }) => theme.palette.grey[100]};
+    border-radius: ${({ theme }) => `${2 * theme.shape.borderRadius}px`};
+  }
+
+  th.MuiTableCell-head {
+    padding: 8px 16px 8px 16px;
+    text-transform: inherit;
+    background: ${({ theme }) => theme.palette.grey[50]};
+    border-bottom: none;
+    &:first-of-type {
+      border-top-left-radius: 8px;
+      padding-left: 20px;
+    }
+    &:last-of-type {
+      border-top-right-radius: 8px;
+    }
+  }
+
+  tr.MuiTableRow-root:not(.MuiTableRow-footer):hover {
+    background: ${({ theme }) => theme.palette.grey[100]};
+  }
+  tr.MuiTableRow-root:last-of-type td:first-of-type {
+    border-bottom-left-radius: 8px;
+  }
+
+  tr.MuiTableRow-root:last-of-type td:last-of-type {
+    border-bottom-right-radius: 8px;
+  }
+
+  tr.MuiTableRow-root:nth-of-type(even) {
+    background: ${({ theme }) => theme.palette.grey[50]};
+  }
+  td.MuiTableCell-root {
+    border-bottom: none;
+    padding-top: 12px;
+    padding-bottom: 12px;
+    padding-left: 16px;
+    padding-right: 16px;
+    &:first-of-type {
+      padding-left: 20px;
+    }
+    &.MuiTableCell-footer {
+      border: none;
+    }
+  }
+
+  .datatable-footer {
+    .MuiTableRow-root.MuiTableRow-footer {
+      border: none;
+    }
+    table.MuiTable-root {
+      outline: none;
+      overflow: hidden;
+    }
+    .MuiTablePagination-input {
+      background: none;
+    }
+    div.MuiSelect-select {
+      padding: 0 24px 0 0;
+    }
+  }
+
+  th a,
+  td a {
+    text-decoration: none;
+    display: block;
+    color: inherit;
+    &:first-of-type {
+      padding-left: 0;
+    }
+  }
+
+  > div {
+    overflow: auto;
+  }
+  .custom-toobar-title-inner {
+    display: flex;
+    align-items: center;
+  }
+  @media (max-width: ${({ theme }) => theme.breakpoints.values.md}px) {
+    th a,
+    td a {
+      text-decoration: none;
+      display: block;
+      color: inherit;
+      padding-top: 0;
+      padding-bottom: 0;
+      padding-right: 0;
+    }
+    tr.MuiTableRow-root {
+      border: none;
+      padding: 20px;
+      display: block;
+    }
+    td.MuiTableCell-root:first-of-type {
+      padding-left: 0;
+      margin-top: 0;
+    }
+    td.MuiTableCell-root {
+      margin: 0;
+      margin-top: 8px;
+      align-items: center;
+      padding: 0;
+      flex-wrap: wrap;
+      flex-direction: ${({ mobileTDFlexDirection = 'column' }) => mobileTDFlexDirection || 'row'};
+      align-items: ${({ mobileTDFlexDirection = 'column' }) => mobileTDFlexDirection === 'column' ? 'flex-start' : 'center'};
+      justify-content: ${({ mobileTDFlexDirection = 'column' }) => mobileTDFlexDirection === 'column' ? 'flex-start' : 'space-between'};
+    }
+    td.MuiTableCell-root > div {
+      margin-bottom: 4px;
+    }
+    .MuiTable-root > .MuiTableBody-root > .MuiTableRow-root > td.MuiTableCell-root {
+      display: flex;
+      flex-direction: ${({ mobileTDFlexDirection = 'column' }) => mobileTDFlexDirection || 'row'};
+      align-items: flex-start;
+      justify-content: ${({ mobileTDFlexDirection = 'column' }) => mobileTDFlexDirection === 'row' ? 'space-between' : 'flex-start'};
+      flex-wrap: ${({ mobileTDFlexDirection = 'column' }) => (mobileTDFlexDirection === 'row' ? 'nowrap' : 'wrap')};
+      word-break: break-all;
+      &.datatables-noprint {
+        justify-content: center;
+      }
+    }
+    [class*='MUIDataTable-responsiveBase'] tr:not([class*='responsiveSimple']) td.MuiTableCell-body > div {
+      width: inherit;
+    }
+  }
+`;
+export default withLocaleProvider(Table, {
+    translations: {
+        en: {
+            empty: 'No data',
+        },
+        zh: {
+            empty: '暂无数据',
+        },
+    },
+});

package/lib/esm/index.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/libs/logger.js

@@ -0,0 +1,3 @@
+import createLogger from '@blocklet/logger';
+const logger = createLogger('aigne-hub:sdk');
+export default logger;

package/lib/esm/utils/withLocaleProvider.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { LocaleProvider, useLocaleContext } from '@arcblock/ux/lib/Locale/context';
+export default function withLocaleProvider(C, { translations, fallbackLocale = 'en', }) {
+    return ((args) => {
+        const { locale } = useLocaleContext();
+        return (_jsx(LocaleProvider, { translations: translations, fallbackLocale: fallbackLocale, locale: locale, onLoadingTranslation: undefined, languages: undefined, children: _jsx(C, { ...args }) }));
+    });
+}

package/lib/types/api/ai-kit.d.ts

@@ -0,0 +1,70 @@
+import { AxiosInstance } from 'axios';
+import { ChatCompletionMessageParam } from 'openai/resources/index';
+export declare const createStatusApi: ({ axios, path }: {
+    axios: AxiosInstance;
+    path: string;
+}) => (() => Promise<{
+    available: boolean;
+}>);
+export interface TextCompletions {
+    text?: string;
+}
+export interface TextCompletionOptions {
+    model?: string;
+    temperature?: number;
+}
+export interface TextCompletionFn<P extends {}> {
+    (options: {
+        stream: true;
+    } & TextCompletionOptions & P): Promise<ReadableStream<Uint8Array>>;
+    (options: {
+        stream?: boolean;
+    } & TextCompletionOptions & P): Promise<TextCompletions>;
+    (options: {
+        stream?: boolean;
+    } & TextCompletionOptions & P): Promise<TextCompletions | ReadableStream<Uint8Array>>;
+}
+export declare const createTextCompletionApi: <P extends {} = {
+    prompt: string;
+} | {
+    messages: ChatCompletionMessageParam[];
+}>({ fetch, path, timeout, }: {
+    fetch: typeof globalThis.fetch;
+    path: string;
+    timeout?: number;
+}) => TextCompletionFn<P>;
+export interface ImageGenerations<T extends {
+    url: string;
+} | {
+    b64_json: string;
+}> {
+    data: T[];
+}
+export type ImageGenerationSize = '256x256' | '512x512' | '1024x1024' | '1024x1792' | '1792x1024' | '1536x1024' | '1024x1536' | 'auto';
+export interface ImageGenerationFn<P extends {}> {
+    (options: P & {
+        response_format?: 'url';
+    }): Promise<ImageGenerations<{
+        url: string;
+    }>>;
+    (options: P & {
+        response_format?: 'b64_json';
+    }): Promise<ImageGenerations<{
+        b64_json: string;
+    }>>;
+    (options: P & {
+        response_format?: 'url' | 'b64_json';
+    }): Promise<ImageGenerations<{
+        url: string;
+    } | {
+        b64_json: string;
+    }>>;
+}
+export declare const createImageGenerationApi: <P extends {} = {
+    prompt: string;
+    size: ImageGenerationSize;
+    n: number;
+}>({ axios, path, }: {
+    axios: AxiosInstance;
+    path: string;
+}) => ImageGenerationFn<P>;

package/lib/types/api/api.d.ts

@@ -0,0 +1,4 @@
+export declare const PREFIX: string;
+export declare const API_TIMEOUT: number;
+declare const api: import("axios").AxiosInstance;
+export default api;

package/lib/types/api/app.d.ts

@@ -0,0 +1,113 @@
+export interface AppStatusResult {
+    id: string;
+    subscription?: any;
+    subscriptionDetailUrl?: string;
+    config?: AIKitServiceConfig | null;
+}
+export declare function appStatus(): Promise<AppStatusResult>;
+export interface AIKitServiceConfig {
+    useAIKitService?: boolean;
+}
+export declare function appConfig(): Promise<AIKitServiceConfig | null>;
+export declare function setAppConfig(payload: AIKitServiceConfig): Promise<AIKitServiceConfig>;
+export interface AppRegisterResult {
+    appId: string;
+    paymentLink?: string;
+}
+export declare function appServiceRegister(): Promise<AppRegisterResult>;
+export interface AppUsedCreditsResult {
+    model: string;
+    date: string;
+    usedCredits: string;
+    promptTokens: number;
+    completionTokens: number;
+    numberOfImageGeneration: number;
+}
+export declare function appUsedCredits(query: {
+    startTime?: string;
+    endTime: string;
+}, options?: {
+    useAIKitService?: boolean;
+}): Promise<{
+    list: AppUsedCreditsResult[];
+}>;
+export declare function unsubscribe(): Promise<void>;
+export declare function getCreditPaymentLink(options?: {
+    useAIKitService?: boolean;
+}): Promise<string>;
+export interface CreditBalanceResult {
+    balance: string;
+    currency: {
+        id: string;
+        symbol: string;
+        name: string;
+        decimal: number;
+        maximum_precision: number;
+    };
+    total: string;
+    grantCount: number;
+}
+export interface CreditGrant {
+    id: string;
+    name: string;
+    status: string;
+    remainingCredit: number;
+    scope: string;
+    effectiveDate: string;
+    expirationDate?: string;
+}
+export interface CreditGrantsResult {
+    creditGrants: {
+        data: CreditGrant[];
+        pagination: {
+            page: number;
+            pageSize: number;
+            total: number;
+            totalPages: number;
+        };
+    };
+}
+export interface CreditTransaction {
+    id: string;
+    quantity: string;
+    credit_amount: string;
+    remaining_balance: string;
+    description: string;
+    created_at: string;
+    creditGrant: {
+        id: string;
+        name: string;
+    };
+    paymentCurrency: {
+        id: string;
+        symbol: string;
+        decimal: number;
+    };
+}
+export interface CreditTransactionsResult {
+    count: number;
+    list: CreditTransaction[];
+    paging: {
+        page: number;
+        pageSize: number;
+    };
+}
+export declare function getCreditBalance(options?: {
+    useAIKitService?: boolean;
+}): Promise<CreditBalanceResult>;
+export declare function getCreditGrants(params?: {
+    page?: number;
+    pageSize?: number;
+    start?: number;
+    end?: number;
+}, options?: {
+    useAIKitService?: boolean;
+}): Promise<CreditGrantsResult>;
+export declare function getCreditTransactions(params?: {
+    page?: number;
+    pageSize?: number;
+    start?: number;
+    end?: number;
+}, options?: {
+    useAIKitService?: boolean;
+}): Promise<CreditTransactionsResult>;

package/lib/types/api/call/api.d.ts

@@ -0,0 +1,2 @@
+export declare const aiKitApi: import("axios").AxiosInstance;
+export declare function catchAndRethrowUpstreamError(response: Promise<any>): Promise<any>;

package/lib/types/api/call/app.d.ts

@@ -0,0 +1,50 @@
+import type { IncomingMessage } from 'http';
+import { TSubscriptionExpanded } from '@blocklet/payment-js';
+import { AxiosResponse } from 'axios';
+export interface AppStatusResult {
+    id: string;
+    subscription?: TSubscriptionExpanded;
+}
+export declare function appStatus({ description }: {
+    description?: string;
+}, options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+}): Promise<AppStatusResult | null>;
+export declare function appStatus({ description }: {
+    description?: string;
+}, options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+}): Promise<AxiosResponse<IncomingMessage, any>>;
+export interface RegisterPayload {
+    publicKey: string;
+}
+export interface RegisterResult {
+    appId: string;
+    paymentLink?: string;
+}
+export declare function appRegister(payload: RegisterPayload, options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+}): Promise<RegisterResult>;
+export declare function appRegister(payload: RegisterPayload, options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+}): Promise<AxiosResponse<IncomingMessage, any>>;
+export declare function cancelSubscription(options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+}): Promise<null>;
+export declare function cancelSubscription(options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+}): Promise<AxiosResponse<IncomingMessage, any>>;
+export declare function recoverSubscription(options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+}): Promise<null>;
+export declare function recoverSubscription(options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+}): Promise<AxiosResponse<IncomingMessage, any>>;

package/lib/types/api/call/index.d.ts

@@ -0,0 +1,3 @@
+export * from './v1';
+export * from './v2';
+export * from './proxy';