@blocklet/aigne-hub 0.2.7

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

@@ -0,0 +1,6 @@
+import { NextFunction, Request, Response } from 'express';
+export declare function proxyToAIKit(path: '/api/v1/status' | '/api/v1/chat/completions' | '/api/v1/image/generations' | '/api/v1/embeddings' | '/api/v1/audio/transcriptions' | '/api/v1/audio/speech' | '/api/app/status' | '/api/app/usage' | '/api/app/register' | '/api/user/credit/grants' | '/api/user/credit/balance' | '/api/user/credit/transactions' | '/api/user/credit/payment-link', { useAIKitService, proxyReqHeaders, proxyResHeaders, }?: {
+    useAIKitService?: boolean;
+    proxyReqHeaders?: string[];
+    proxyResHeaders?: string[];
+}): (req: Request, res: Response, next: NextFunction) => void;

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

@@ -0,0 +1,51 @@
+import type { IncomingMessage } from 'http';
+import { ReadableStream } from 'stream/web';
+import { AxiosResponse } from 'axios';
+import { ChatCompletionError, ChatCompletionInput, ChatCompletionResponse, EmbeddingInput, EmbeddingResponse, ImageGenerationInput, ImageGenerationResponse } from '../types';
+import { AudioSpeechInput, AudioTranscriptionsInput } from '../types/audio';
+import { StatusResponse } from '../types/status';
+export declare function status(options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+}): Promise<StatusResponse>;
+export declare function status(options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+}): Promise<AxiosResponse<IncomingMessage, any>>;
+export declare function chatCompletions(input: ChatCompletionInput, options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+}): Promise<ReadableStream<Exclude<ChatCompletionResponse, ChatCompletionError>>>;
+export declare function chatCompletions(input: ChatCompletionInput, options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+}): Promise<AxiosResponse<IncomingMessage, any>>;
+export declare function imageGenerations(input: ImageGenerationInput, options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+    timeout?: number;
+}): Promise<ImageGenerationResponse>;
+export declare function imageGenerations(input: ImageGenerationInput, options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+    timeout?: number;
+}): Promise<AxiosResponse<IncomingMessage, any>>;
+export declare function embeddings(input: EmbeddingInput, options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+}): Promise<EmbeddingResponse>;
+export declare function embeddings(input: EmbeddingInput, options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+}): Promise<AxiosResponse<IncomingMessage, any>>;
+export declare function audioTranscriptions(input: AudioTranscriptionsInput, options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+}): Promise<EmbeddingResponse>;
+export declare function audioTranscriptions(input: AudioTranscriptionsInput, options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+}): Promise<AxiosResponse<IncomingMessage, any>>;
+export declare function audioSpeech(input: AudioSpeechInput, { useAIKitService }?: {
+    useAIKitService?: boolean;
+}): Promise<AxiosResponse<IncomingMessage, any>>;

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

@@ -0,0 +1,30 @@
+import type { IncomingMessage } from 'http';
+import { ReadableStream } from 'stream/web';
+import { AxiosResponse } from 'axios';
+import { ChatCompletionError, ChatCompletionInput, ChatCompletionResponse, EmbeddingInput, EmbeddingResponse, ImageGenerationInput, ImageGenerationResponse } from '../types';
+export declare function chatCompletionsV2(input: ChatCompletionInput, options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+}): Promise<ReadableStream<Exclude<ChatCompletionResponse, ChatCompletionError>>>;
+export declare function chatCompletionsV2(input: ChatCompletionInput, options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+}): Promise<AxiosResponse<IncomingMessage, any>>;
+export declare function imageGenerationsV2(input: ImageGenerationInput, options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+    timeout?: number;
+}): Promise<ImageGenerationResponse>;
+export declare function imageGenerationsV2(input: ImageGenerationInput, options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+    timeout?: number;
+}): Promise<AxiosResponse<IncomingMessage, any>>;
+export declare function embeddingsV2(input: EmbeddingInput, options?: {
+    useAIKitService?: boolean;
+    responseType?: undefined;
+}): Promise<EmbeddingResponse>;
+export declare function embeddingsV2(input: EmbeddingInput, options: {
+    useAIKitService?: boolean;
+    responseType: 'stream';
+}): Promise<AxiosResponse<IncomingMessage, any>>;

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

@@ -0,0 +1,14 @@
+import { EventEmitter } from 'events';
+declare class Config extends EventEmitter {
+    static CONFIG_FILE_PATH: string;
+    constructor();
+    private reloadConfigFile;
+    config: {
+        useAIKitService?: boolean;
+    } | undefined;
+    get useAIKitService(): boolean | undefined;
+    set useAIKitService(value: boolean | undefined);
+    save(): Promise<void>;
+}
+declare const AIKitConfig: Config;
+export default AIKitConfig;

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

@@ -0,0 +1 @@
+export declare const AI_KIT_BASE_URL: string;

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

@@ -0,0 +1,18 @@
+export declare enum SubscriptionErrorType {
+    UNSUBSCRIBED = "UNSUBSCRIBED",
+    UNKNOWN = "UNKNOWN"
+}
+export declare enum CreditErrorType {
+    NOT_ENOUGH = "NOT_ENOUGH",
+    UNKNOWN = "UNKNOWN"
+}
+export declare class SubscriptionError extends Error {
+    timestamp: string;
+    type: SubscriptionErrorType;
+    constructor(type: SubscriptionErrorType);
+}
+export declare class CreditError extends Error {
+    timestamp: string;
+    type: CreditErrorType;
+    constructor(type: CreditErrorType, link?: string);
+}

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

@@ -0,0 +1,3 @@
+export * from './ai-kit';
+export * from './error';
+export * from './app';

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

@@ -0,0 +1,18 @@
+import type { ReadStream } from 'fs';
+import type { Readable } from 'stream';
+import type { ReadableStream } from 'stream/web';
+export interface AudioTranscriptionsInput {
+    file: Buffer | ReadStream | Readable | ReadableStream;
+    model: string;
+    language?: string;
+    prompt?: string;
+    responseFormat?: 'json' | 'text' | 'srt' | 'verbose_json' | 'vtt';
+    temperature?: number;
+}
+export interface AudioSpeechInput {
+    model: string;
+    input: string;
+    voice: string;
+    responseFormat?: 'mp3' | 'opus' | 'aac' | 'and' | 'flac';
+    speed?: 0.25 | 4.0 | 1.0;
+}

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

@@ -0,0 +1,97 @@
+export interface ChatCompletionInput {
+    stream?: boolean;
+    model?: string;
+    messages: ({
+        role: 'system';
+        content: string;
+    } | {
+        role: 'user';
+        content: string | ({
+            type: 'text';
+            text: string;
+        } | {
+            type: 'image_url';
+            imageUrl: {
+                url: string;
+            };
+        })[];
+    } | {
+        role: 'assistant';
+        content?: string;
+        toolCalls?: {
+            id: string;
+            type: 'function';
+            function: {
+                name: string;
+                arguments: string;
+            };
+        }[];
+    } | {
+        role: 'tool';
+        content: string;
+        toolCallId: string;
+    })[];
+    temperature?: number;
+    topP?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    maxTokens?: number;
+    toolChoice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+            description?: string;
+        };
+    };
+    tools?: {
+        type: 'function';
+        function: {
+            name: string;
+            description?: string;
+            parameters: Record<string, any>;
+        };
+    }[];
+    responseFormat?: {
+        type?: 'text' | 'json_object';
+    } | {
+        type: 'json_schema';
+        jsonSchema: {
+            name: string;
+            description?: string;
+            schema: Record<string, any>;
+            strict?: boolean;
+        };
+    };
+}
+export type ChatCompletionResponse = ChatCompletionChunk | ChatCompletionError | ChatCompletionUsage;
+export interface ChatCompletionChunk {
+    delta: {
+        role?: 'system' | 'user' | 'assistant' | 'tool' | 'developer';
+        content?: string | null;
+        toolCalls?: {
+            id?: string;
+            type?: 'function';
+            function?: {
+                name?: string;
+                arguments?: string;
+            };
+        }[];
+    };
+}
+export interface ChatCompletionError {
+    error: {
+        message: string;
+        type?: string;
+        timestamp?: string;
+    };
+}
+export interface ChatCompletionUsage {
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+export declare function isChatCompletionChunk(data: ChatCompletionResponse): data is ChatCompletionChunk;
+export declare function isChatCompletionUsage(data: ChatCompletionResponse): data is ChatCompletionUsage;
+export declare function isChatCompletionError(data: ChatCompletionResponse): data is ChatCompletionError;

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

@@ -0,0 +1,9 @@
+export interface EmbeddingInput {
+    model: string;
+    input: string | Array<string> | Array<number> | Array<Array<number>>;
+}
+export interface EmbeddingResponse {
+    data: {
+        embedding: number[];
+    }[];
+}

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

@@ -0,0 +1,23 @@
+export interface ImageGenerationInput {
+    model?: string;
+    image?: string | string[];
+    prompt: string;
+    size?: '256x256' | '512x512' | '1024x1024' | '1024x1792' | '1792x1024' | '1536x1024' | '1024x1536' | 'auto';
+    n?: number;
+    responseFormat?: 'url' | 'b64_json';
+    style?: 'vivid' | 'natural';
+    quality?: 'standard' | 'hd' | 'high' | 'medium' | 'low' | 'auto';
+    background?: 'transparent' | 'opaque' | 'auto';
+    outputFormat?: 'jpeg' | 'png' | 'webp';
+    moderation?: 'low' | 'auto';
+    outputCompression?: number;
+}
+export interface ImageGenerationResponse {
+    data: ({
+        url: string;
+        b64Json?: undefined;
+    } | {
+        url?: undefined;
+        b64Json: string;
+    })[];
+}

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

@@ -0,0 +1,3 @@
+export * from './chat';
+export * from './image';
+export * from './embedding';

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

@@ -0,0 +1,3 @@
+export interface StatusResponse {
+    available: boolean;
+}

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

@@ -0,0 +1,33 @@
+import type { BytesType } from '@ocap/util';
+import type { WalletObject } from '@ocap/wallet';
+import type { NextFunction, Request, Response } from 'express';
+export declare const wallet: WalletObject;
+export declare const ensureAdmin: (req: Request & {
+    user?: import("@blocklet/sdk/lib/util/login").SessionUser;
+}, res: Response, next: NextFunction) => Promise<void>;
+export declare function appIdFromPublicKey(publicKey: BytesType): string;
+export declare function verifyRemoteComponentCall({ appId, timestamp, data, sig, pk, userDid, expiresIn, }: {
+    appId: string;
+    timestamp: number;
+    data: object;
+    sig: string;
+    pk: BytesType;
+    userDid?: string;
+    expiresIn?: number;
+}): boolean;
+export declare function signRemoteComponentCall({ data, userDid }: {
+    data: object;
+    userDid?: string;
+}): {
+    appId: string;
+    timestamp: number;
+    userDid: string | undefined;
+    sig: string;
+};
+export declare function getRemoteComponentCallHeaders(data: object, userDid?: string): {
+    'x-app-id': string;
+    'x-timestamp': string;
+    'x-component-sig': string;
+    'x-app-user-did': string;
+};
+export declare function ensureRemoteComponentCall(getPublicKey: (appId: string) => Promise<BytesType>, fallback?: (req: Request, res: Response, next: NextFunction) => any): (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/lib/types/api/utils/event-stream.d.ts

@@ -0,0 +1,7 @@
+import { Readable } from 'stream';
+import { ReadableStream, TransformStream } from 'stream/web';
+export declare function readableToWeb(readable: Readable): ReadableStream<any>;
+export declare class EventSourceParserStream<T> extends TransformStream<any, T> {
+    constructor();
+}
+export declare function tryParseJsonFromResponseStream<T>(data: Readable): Promise<T | undefined>;

package/lib/types/components/conversation/conversation.d.ts

@@ -0,0 +1,30 @@
+import { BoxProps } from '@mui/material';
+import { ChatCompletionMessageParam } from 'openai/resources/index';
+import { ReactNode } from 'react';
+import { PromptProps } from './prompt';
+export interface MessageItem {
+    id: string;
+    prompt?: string | ChatCompletionMessageParam[];
+    response?: string | {
+        url: string;
+    }[];
+    loading?: boolean;
+    error?: {
+        message: string;
+        [key: string]: unknown;
+    };
+    meta?: any;
+}
+export interface ConversationRef {
+    scrollToBottom: (options?: {
+        force?: boolean;
+    }) => void;
+}
+export default function Conversation({ ref, messages, onSubmit, customActions, renderAvatar, maxWidth, scrollContainer, promptProps, ...props }: Omit<BoxProps, 'onSubmit'> & {
+    messages: MessageItem[];
+    onSubmit: (prompt: string) => void;
+    customActions?: (item: MessageItem) => Array<ReactNode[]>;
+    renderAvatar?: (item: MessageItem, isAI: boolean) => ReactNode;
+    scrollContainer?: HTMLElement;
+    promptProps?: Partial<PromptProps>;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/types/components/conversation/index.d.ts

@@ -0,0 +1,4 @@
+import Conversation from './conversation';
+export default Conversation;
+export * from './conversation';
+export { default as useConversation } from './use-conversation';

package/lib/types/components/conversation/message.d.ts

@@ -0,0 +1,10 @@
+import { BoxProps } from '@mui/material';
+import { ChatCompletionMessageParam } from 'openai/resources/index';
+import { ReactNode } from 'react';
+export default function Message({ avatar, message, children, loading, actions, ...props }: {
+    avatar?: ReactNode;
+    message?: string | ChatCompletionMessageParam[];
+    children?: ReactNode;
+    loading?: boolean;
+    actions?: ReactNode[];
+} & BoxProps): import("react/jsx-runtime").JSX.Element;

package/lib/types/components/conversation/prompt.d.ts

@@ -0,0 +1,10 @@
+import { BoxProps, SxProps } from '@mui/material';
+import { ReactNode } from 'react';
+export interface PromptProps extends Omit<BoxProps<'form'>, 'onSubmit' | 'sx'> {
+    onSubmit: (prompt: string) => any;
+    startAdornment?: ReactNode;
+    endAdornment?: ReactNode;
+    slotProps?: any;
+    sx?: SxProps;
+}
+export default function Prompt({ startAdornment, endAdornment, onSubmit, slotProps, sx, ...props }: PromptProps): import("react/jsx-runtime").JSX.Element;

package/lib/types/components/conversation/use-conversation.d.ts

@@ -0,0 +1,44 @@
+import { ChatCompletionMessageParam } from 'openai/resources/index';
+import { MessageItem } from './conversation';
+export default function useConversation({ scrollToBottom, textCompletions, imageGenerations, }: {
+    scrollToBottom?: (options?: {
+        force?: boolean;
+    }) => void;
+    textCompletions: (prompt: string | ChatCompletionMessageParam[], options: {
+        meta?: any;
+    }) => Promise<ReadableStream<string | Uint8Array | {
+        type: 'text';
+        text: string;
+    } | {
+        type: 'images';
+        images: {
+            url: string;
+        }[];
+    }>>;
+    imageGenerations?: (prompt: {
+        prompt: string;
+        n: number;
+        size: string;
+    }, options: {
+        meta?: any;
+    }) => Promise<{
+        url: string;
+    }[]>;
+}): {
+    messages: MessageItem[];
+    add: (prompt: string | ChatCompletionMessageParam[], meta?: any) => Promise<{
+        id: string;
+        data: {
+            url: string;
+        }[];
+        text?: undefined;
+    } | {
+        id: string;
+        text: string | {
+            url: string;
+        }[];
+        data?: undefined;
+    }>;
+    cancel: ({ id }: Pick<MessageItem, "id">) => void;
+    setMessages: import("react").Dispatch<import("react").SetStateAction<MessageItem[]>>;
+};

package/lib/types/components/credit/alert.d.ts

@@ -0,0 +1,10 @@
+import { AlertProps } from '@mui/material';
+import { CreditErrorType } from '../../api/error';
+interface CreditError {
+    type: CreditErrorType;
+    message: string;
+}
+declare const _default: import("react").ComponentType<{
+    error: CreditError;
+} & AlertProps>;
+export default _default;

package/lib/types/components/credit/balance.d.ts

@@ -0,0 +1,7 @@
+interface CreditBalanceProps {
+    balance?: number;
+    currency?: string;
+    useAIKitService?: boolean;
+}
+declare const _default: import("react").ComponentType<CreditBalanceProps>;
+export default _default;

package/lib/types/components/credit/button.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import("react").ComponentType<{
+    shouldOpenInNewTab?: boolean;
+    size?: "small" | "medium" | "large";
+    variant?: "text" | "outlined" | "contained";
+    color?: "primary" | "secondary" | "error" | "info" | "success" | "warning";
+    useAIKitService?: boolean;
+    children?: React.ReactNode;
+} & import("@mui/lab").ButtonOwnProps & Omit<import("@mui/material").ButtonBaseOwnProps, "classes"> & import("@mui/material/OverridableComponent").CommonProps & Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLButtonElement> | null | undefined;
+}, "href" | "className" | "style" | "classes" | "children" | "tabIndex" | "color" | "disabled" | "sx" | "action" | "loading" | "size" | "variant" | "centerRipple" | "disableRipple" | "disableTouchRipple" | "focusRipple" | "focusVisibleClassName" | "LinkComponent" | "onFocusVisible" | "TouchRippleProps" | "touchRippleRef" | "disableFocusRipple" | "loadingIndicator" | "disableElevation" | "endIcon" | "fullWidth" | "loadingPosition" | "startIcon">>;
+export default _default;

package/lib/types/components/credit/index.d.ts

@@ -0,0 +1,3 @@
+export { default as CreditButton } from './button';
+export { default as CreditBalance } from './balance';
+export { default as CreditErrorAlert } from './alert';

package/lib/types/components/form-label.d.ts

@@ -0,0 +1,7 @@
+import type { FormLabelProps } from '@mui/material';
+import type { ReactNode } from 'react';
+export default function CustomFormLabel({ children, required, tooltip, description, ...props }: FormLabelProps & {
+    required?: boolean;
+    tooltip?: ReactNode | string;
+    description?: ReactNode | string;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/types/components/image-preview.d.ts

@@ -0,0 +1,17 @@
+interface ImagePreviewProps {
+    dataSource?: Array<{
+        src: string;
+        alt?: string;
+        width?: number;
+        height?: number;
+    }>;
+    spacing?: number;
+    itemWidth?: number;
+    itemHeight?: number;
+    transition?: string;
+    borderRadius?: number;
+    formatDownloadSrc?: (src: string) => string;
+    showDownloadButton?: boolean;
+}
+export default function ImagePreview({ dataSource, itemWidth, itemHeight, spacing, transition, borderRadius, formatDownloadSrc, showDownloadButton, }: ImagePreviewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/components/index.d.ts

@@ -0,0 +1,12 @@
+export { default as LoadingImage } from './loading-image';
+export { default as ImagePreview } from './image-preview';
+export { default as Conversation } from './conversation';
+export * from './conversation';
+export { default as SubscribeButton } from './subscribe/button';
+export { default as SubscribeErrorAlert } from './subscribe/alert';
+export { default as CreditButton } from './credit/button';
+export { default as CreditBalance } from './credit/balance';
+export { default as CreditErrorAlert } from './credit/alert';
+export { default as Switch } from './switch-button';
+export { default as Table } from './table';
+export { default as FormLabel } from './form-label';

package/lib/types/components/loading-image.d.ts

@@ -0,0 +1,6 @@
+import { ImgHTMLAttributes } from 'react';
+declare function LoadingImage({ ref, onLoad, ...props }: {
+    ref?: any;
+    onLoad?: () => void;
+} & Omit<ImgHTMLAttributes<HTMLImageElement>, 'onLoad'>): import("react/jsx-runtime").JSX.Element;
+export default LoadingImage;

package/lib/types/components/subscribe/alert.d.ts

@@ -0,0 +1,5 @@
+import { AlertProps } from '@mui/material';
+declare const _default: import("react").ComponentType<{
+    error: any;
+} & AlertProps>;
+export default _default;

package/lib/types/components/subscribe/button.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("react").ComponentType<{
+    shouldOpenInNewTab?: boolean;
+    showUseAIServiceButton?: boolean;
+}>;
+export default _default;

package/lib/types/components/subscribe/state.d.ts

@@ -0,0 +1,14 @@
+import { AIKitServiceConfig, AppStatusResult } from '../../api/app';
+export interface AIKitServiceStatus {
+    app?: AppStatusResult;
+    loading?: boolean;
+    error?: Error;
+    fetch: () => Promise<void>;
+    setConfig: (config: AIKitServiceConfig) => Promise<void>;
+    computed: {
+        isSubscriptionAvailable?: boolean;
+    };
+}
+export declare const useAIKitServiceStatus: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<AIKitServiceStatus>, "setState"> & {
+    setState(nextStateOrUpdater: AIKitServiceStatus | Partial<AIKitServiceStatus> | ((state: import("immer").WritableDraft<AIKitServiceStatus>) => void), shouldReplace?: boolean | undefined): void;
+}>;

package/lib/types/components/switch-button.d.ts

@@ -0,0 +1,7 @@
+import type { SwitchProps as MuiSwitchProps } from '@mui/material';
+import type { LiteralUnion } from 'type-fest';
+type CustomSwitchProps = {
+    variant?: LiteralUnion<'success' | 'error' | 'warning' | 'info' | 'primary' | 'secondary', string>;
+} & MuiSwitchProps;
+declare const SwitchButton: React.FC<CustomSwitchProps>;
+export default SwitchButton;

package/lib/types/components/table.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: React.ComponentType<any>;
+export default _default;

package/lib/types/index.d.ts

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

package/lib/types/libs/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: Console;
+export default logger;

package/lib/types/utils/withLocaleProvider.d.ts

@@ -0,0 +1,9 @@
+import { ComponentType } from 'react';
+export default function withLocaleProvider<T>(C: ComponentType<T>, { translations, fallbackLocale, }: {
+    fallbackLocale?: string;
+    translations: {
+        [locale: string]: {
+            [key: string]: string;
+        };
+    };
+}): ComponentType<T>;