Z.AI-Chat-for-Android/node_modules/@nicepkg/gpt-runner-shared/dist/env-config-3be2ee5d.d.ts

declare enum ChatModelType {
    Openai = "openai",
    HuggingFace = "huggingFace",
    Anthropic = "anthropic"
}
declare enum ChatRole {
    User = "user",
    Assistant = "assistant",
    System = "system"
}
declare enum ChatMessageStatus {
    Pending = "pending",
    Success = "success",
    Error = "error"
}
declare enum ClientEventName {
    InitSuccess = "initSuccess",
    RefreshTree = "refreshTree",
    RefreshChatTree = "refreshChatTree",
    RefreshFileTree = "refreshFileTree",
    InsertCodes = "insertCodes",
    DiffCodes = "diffCodes",
    UpdateIdeOpeningFiles = "updateIdeOpeningFiles",
    UpdateIdeActiveFilePath = "updateIdeActiveFilePath",
    UpdateUserSelectedText = "updateUserSelectedText",
    OpenFileInIde = "openFileInIde",
    OpenFileInFileEditor = "openFileInFileEditor",
    GoToChatPanel = "goToChatPanel"
}
declare enum GptFileTreeItemType {
    Folder = "folder",
    File = "file",
    Chat = "chat"
}
declare enum ServerStorageName {
    FrontendState = "frontend-state",
    SecretsConfig = "secrets-config",
    GlobalState = "global-state",
    WebPreset = "web-preset"
}
declare enum WssActionName {
    Error = "error",
    StorageGetItem = "storageGetItem",
    StorageSetItem = "storageSetItem",
    StorageRemoveItem = "storageRemoveItem",
    StorageClear = "storageClear"
}
declare enum LocaleLang {
    English = "en",
    ChineseSimplified = "zh_CN",
    ChineseTraditional = "zh_Hant",
    Japanese = "ja",
    German = "de"
}
declare enum SecretStorageKey {
    Anthropic = "anthropic",
    HuggingFace = "huggingFace",
    Openai = "openai",
    Proxy = "proxy"
}
declare enum VendorTag {
    Free = "free",
    Official = "official",
    Unofficial = "unofficial",
    Recommended = "recommended"
}

interface HuggingFaceSecrets extends BaseSecrets {
    /**
     * The API key to use for Hugging Face API requests.
     */
    apiKey?: string;
}
interface HuggingFaceModelConfig extends BaseModelConfig {
    /**
     * mode type
     */
    type: ChatModelType.HuggingFace;
    /**
     * huggingFace secret config
     */
    secrets?: HuggingFaceSecrets;
    /**
     * Sampling temperature to use
     */
    temperature?: number;
    /**
     * Maximum number of tokens to generate in the completion. -1 returns as many
     * tokens as possible given the prompt and the model's maximum context size.
     */
    maxTokens?: number;
    /**
     * Total probability mass of tokens to consider at each step
     */
    topP?: number;
    /**
     * Integer to define the top tokens considered within the sample operation to create new text.
     */
    topK?: number;
    /**
     * Penalizes repeated tokens according to frequency
     */
    frequencyPenalty?: number;
}

interface OpenaiSecrets extends BaseSecrets {
    /**
       * The API key to use for OpenAI API requests.
       */
    apiKey?: string;
    /**
     * OpenAI organization id
     */
    organization?: string;
    /**
     * OpenAI access token
     */
    accessToken?: string;
}
interface OpenaiModelConfig extends BaseModelConfig {
    /**
     * mode type
     */
    type: ChatModelType.Openai;
    /**
     * openai secret config
     */
    secrets?: OpenaiSecrets;
    /**
     * Sampling temperature to use
     */
    temperature?: number;
    /**
     * Maximum number of tokens to generate in the completion. -1 returns as many
     * tokens as possible given the prompt and the model's maximum context size.
     */
    maxTokens?: number;
    /**
     * Total probability mass of tokens to consider at each step
     */
    topP?: number;
    /**
     * Penalizes repeated tokens according to frequency
     */
    frequencyPenalty?: number;
    /**
     * Penalizes repeated tokens
     */
    presencePenalty?: number;
}

interface BaseSecrets {
    /**
     * override api request base url
     */
    basePath?: string;
}
interface BaseModelConfig {
    /**
     * mode type
     */
    type?: ChatModelType;
    /**
     * Model name to use
     */
    modelName?: string;
    /**
     * some secrets config, that will not send to client
     */
    secrets?: Record<string, any>;
}
interface ChatModelTypeMap {
    [ChatModelType.Anthropic]: AnthropicModelConfig;
    [ChatModelType.HuggingFace]: HuggingFaceModelConfig;
    [ChatModelType.Openai]: OpenaiModelConfig;
}
type PartialChatModelTypeMap = Partial<ChatModelTypeMap>;
type GetModelConfigType<T extends ChatModelType, P extends 'config' | 'secrets'> = {
    config: ChatModelTypeMap[T];
    secrets: ChatModelTypeMap[T]['secrets'];
}[P];
type ChatModel = ChatModelTypeMap[ChatModelType];

interface AnthropicSecrets extends BaseSecrets {
    /**
       * The API key to use for Anthropic API requests.
       */
    apiKey?: string;
}
interface AnthropicModelConfig extends BaseModelConfig {
    /**
     * mode type
     */
    type: ChatModelType.Anthropic;
    /**
     * openai secret config
     */
    secrets?: AnthropicSecrets;
    /** Amount of randomness injected into the response. Ranges
     * from 0 to 1. Use temp closer to 0 for analytical /
     * multiple choice, and temp closer to 1 for creative
     * and generative tasks.
     */
    temperature?: number;
    /**
     * Maximum number of tokens to generate in the completion. -1 returns as many
     * tokens as possible given the prompt and the model's maximum context size.
     */
    maxTokens?: number;
    /** Does nucleus sampling, in which we compute the
     * cumulative distribution over all the options for each
     * subsequent token in decreasing probability order and
     * cut it off once it reaches a particular probability
     * specified by top_p. Defaults to -1, which disables it.
     * Note that you should either alter temperature or top_p,
     * but not both.
     */
    topP?: number;
    /**
     * Only sample from the top K options for each subsequent
     * token. Used to remove "long tail" low probability
     * responses. Defaults to -1, which disables it.
     */
    topK?: number;
}

type MaybePromise<T> = T | Promise<T>;
type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | ((source: string) => boolean) | null | undefined;
type TreeItem<T> = T & {
    children?: TreeItem<T>[];
};
type ReadonlyDeep<T> = {
    readonly [P in keyof T]: ReadonlyDeep<T[P]>;
};
type ValueOf<T> = T[keyof T];
type DeepRequired<T> = {
    [P in keyof T]-?: DeepRequired<T[P]>;
};
type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

interface UserConfig {
    /**
     * chat model
     */
    model?: ChatModel;
    /**
     * @default process.cwd()
     */
    rootPath?: string;
    /**
     * @default ['.gpt.md']
     */
    exts?: string[];
    /**
     * @default null
     */
    includes?: FilterPattern;
    /**
     * @default null
     */
    excludes?: FilterPattern;
    /**
     * @default true
     */
    respectGitIgnore?: boolean;
    /**
     * custom http request headers for specific urls
     * @default {}
     *
     * @example
     * {
     *  'https://api.openai.com/*': {
     *     modelNames: [
     *       'gpt-3.5-turbo-16k',
     *       'gpt-4',
     *     ],
     *     httpRequestHeader: {
     *       'host': 'api.openai.com',
     *     }
     *  }
     * }
     */
    urlConfig?: {
        [urlMatch: string]: {
            modelNames?: string[];
            httpRequestHeader?: Record<string, string>;
        };
    };
}
type UserConfigForUser = Omit<UserConfig, 'rootPath'>;
interface SingleChatMessage {
    name: ChatRole;
    text: string;
}
type OmitChatModelTypeSecrets<T> = T extends ChatModel ? Omit<T, 'secrets'> : never;
interface SingleFileConfig {
    model?: OmitChatModelTypeSecrets<ChatModel>;
    title?: string;
    userPrompt?: string;
    systemPrompt?: string;
    messages?: SingleChatMessage[];
    forms?: Record<string, FormItemConfig & {
        name: string;
    }>;
}
interface FormOption {
    label?: string;
    value: string;
}
interface FormFieldBaseConfig<DefaultValue = string> {
    type: string;
    defaultValue?: DefaultValue;
    description?: string;
}
interface FormInputConfig extends FormFieldBaseConfig {
    type: 'input';
}
interface FormTextareaConfig extends FormFieldBaseConfig {
    type: 'textarea';
    row?: number;
}
interface FormSelectConfig extends FormFieldBaseConfig {
    type: 'select';
    options: FormOption[];
}
interface FormCheckboxGroupConfig extends FormFieldBaseConfig<string[]> {
    type: 'checkbox-group';
    options: FormOption[];
}
interface FormRadioGroupConfig extends FormFieldBaseConfig {
    type: 'radio-group';
    options: FormOption[];
}
type FormItemConfig = FormInputConfig | FormTextareaConfig | FormSelectConfig | FormCheckboxGroupConfig | FormRadioGroupConfig;

type MarkdownString = string;
interface BaseConfig {
    /**
     * create time like 2023-04-23 12:34:56, for diff update
     */
    createAt: string;
}
interface ChangeLogConfig {
    /**
     * like 2023-04-23 12:34:56
     */
    releaseDate: string;
    version: string;
    changes: MarkdownString;
}
interface ReleaseConfig extends BaseConfig {
    changeLogs: ChangeLogConfig[];
}
interface NotificationConfig extends BaseConfig {
    title: string;
    message: MarkdownString;
}
interface BaseApiVendor {
    vendorName: string;
    vendorShortDescription?: string;
    vendorOfficialUrl?: string;
    vendorLogoUrl?: string;
    vendorDescription?: MarkdownString;
    vendorTags?: VendorTag[];
}
type ModelApiVendor<T extends ChatModelType> = BaseApiVendor & {
    vendorSecrets?: GetModelConfigType<T, 'secrets'>;
};
type ModelTypeVendorsMap = {
    [Key in ChatModelType]?: ModelApiVendor<Key>[];
};
interface VendorsConfig extends BaseConfig, ModelTypeVendorsMap {
}
interface CommonAppConfig {
    notificationConfig: NotificationConfig;
    releaseConfig: ReleaseConfig;
    vendorsConfig: VendorsConfig;
}
type AppConfig = {
    common: CommonAppConfig;
} & {
    [K in LocaleLang]?: Partial<CommonAppConfig>;
};
interface CurrentAppConfig {
    showNotificationModal: boolean;
    showReleaseModal: boolean;
    currentConfig?: CommonAppConfig;
}
interface LastVisitModalDateRecord {
    notificationDate?: string;
    releaseDate?: string;
}
type MarkedAsVisitedType = keyof LastVisitModalDateRecord;

interface FileBaseInfo {
    id: string;
    parentId: string | null;
    projectRelativePath: string;
    fullPath: string;
    name: string;
    tokenNum: number;
}
interface FileInfo extends FileBaseInfo {
    isFile: true;
    ext: string;
}
interface FolderInfo extends FileBaseInfo {
    isFile: false;
}
type FileInfoTreeItem = TreeItem<FolderInfo | FileInfo>;
type FileInfoTree = FileInfoTreeItem[];

interface GptPathBaseInfo {
    id: string;
    parentId: string | null;
    path: string;
    name: string;
    type: GptFileTreeItemType;
}
interface GptFileInfo extends GptPathBaseInfo {
    type: GptFileTreeItemType.File;
    content: string;
    singleFileConfig: SingleFileConfig;
}
interface GptFolderInfo extends GptPathBaseInfo {
    type: GptFileTreeItemType.Folder;
}
interface GptChatInfo extends GptPathBaseInfo {
    type: GptFileTreeItemType.Chat;
    createAt: number;
}
type GptFileInfoTreeItem = TreeItem<GptFolderInfo | GptFileInfo | GptChatInfo>;
type GptFileInfoTree = GptFileInfoTreeItem[];

interface BaseResponse<T = any> {
    type: 'Success' | 'Fail';
    status?: number;
    message?: string;
    data?: T;
}
type SuccessResponse<T = any> = Omit<BaseResponse<T>, 'type'> & {
    type: 'Success';
};
type FailResponse<T = any> = Omit<BaseResponse<T>, 'type'> & {
    type: 'Fail';
};
interface ProxySecrets {
    proxyUrl: string;
}
type ModelTypeVendorNameMap = {
    [K in ChatModelType]?: string;
};
interface ChatStreamReqParams {
    messages: SingleChatMessage[];
    prompt: string;
    /**
     * most times we don't use systemPrompt, we parse .gpt.md file
     * and get the real time systemPrompt and then provide  systemPrompt + appendSystemPrompt to LangchainJs
     */
    systemPrompt?: string;
    appendSystemPrompt?: string;
    /**
     * send system prompt as user prompt
     * @default false
     */
    systemPromptAsUserPrompt?: boolean;
    singleFilePath?: string;
    /**
     * most times we don't use singleFileConfig, we parse .gpt.md file
     * and get the real time singleFileConfig and then provide singleFileConfig to LangchainJs
     */
    singleFileConfig?: SingleFileConfig;
    overrideModelType?: ChatModelType;
    overrideModelsConfig?: PartialChatModelTypeMap;
    /**
     * models type vendor name map
     */
    modelTypeVendorNameMap?: ModelTypeVendorNameMap;
    contextFilePaths?: string[];
    editingFilePath?: string;
    rootPath?: string;
}
interface GetModelNamesForChooseReqParams {
    rootPath: string;
    modelType: ChatModelType;
    modelTypeVendorNameMap?: ModelTypeVendorNameMap;
}
interface GetModelNamesForChooseResData {
    modelNames: string[];
}
interface GetGptFilesReqParams {
    rootPath: string;
}
interface GetGptFilesResData {
    filesInfo: GptFileInfo[];
    filesInfoTree: GptFileInfoTree;
}
interface GetGptFileInfoReqParams {
    rootPath: string;
    filePath: string;
}
interface GetGptFileInfoResData {
    userConfig: UserConfig;
    singleFileConfig: SingleFileConfig;
}
interface InitGptFilesReqParams {
    rootPath: string;
    gptFilesNames: string[];
}
type InitGptFilesResData = null;
type GetProjectConfigReqParams = null;
interface GetProjectConfigResData {
    gptRunnerVersion: string;
    nodeVersion: string;
    nodeVersionValidMessage: string;
}
interface GetAppConfigReqParams {
    langId?: LocaleLang;
}
type GetAppConfigResData = CurrentAppConfig | null;
interface MarkAsVisitedAppConfigReqParams {
    types: MarkedAsVisitedType[];
}
type MarkAsVisitedAppConfigResData = null;
interface GetUserConfigReqParams {
    rootPath: string;
}
interface GetUserConfigResData {
    userConfig: UserConfig;
}
interface StorageGetItemReqParams {
    storageName: ServerStorageName;
    key: string;
}
type ServerStorageValue = Record<string, any> | null | undefined;
interface StorageGetItemResData {
    value: ServerStorageValue;
    cacheDir: string;
}
interface StorageSetItemReqParams {
    storageName: ServerStorageName;
    key: string;
    value?: ServerStorageValue;
}
type StorageSetItemResData = null;
interface StorageRemoveItemReqParams {
    storageName: ServerStorageName;
    key: string;
}
type StorageRemoveItemResData = null;
interface StorageClearReqParams {
    storageName: ServerStorageName;
}
type StorageClearResData = null;
interface GetCommonFilesReqParams {
    rootPath: string;
    excludeExts?: string[];
}
interface GetCommonFilesResData {
    filesInfoTree: FileInfoTree;
    includeFileExts: string[];
    allFileExts: string[];
}
interface OpenEditorReqParams {
    rootPath?: string;
    path: string;
    matchContent?: string;
}
type OpenEditorResData = null;
interface CreateFilePathReqParams {
    fileFullPath: string;
    isDir: boolean;
}
type CreateFilePathResData = null;
interface RenameFilePathReqParams {
    oldFileFullPath: string;
    newFileFullPath: string;
}
type RenameFilePathResData = null;
interface DeleteFilePathReqParams {
    fileFullPath: string;
}
type DeleteFilePathResData = null;
interface GetFileInfoReqParams {
    fileFullPath: string;
}
interface GetFileInfoResData {
    content: string;
    isDir: boolean;
}
interface SaveFileContentReqParams {
    fileFullPath: string;
    content: string;
}
type SaveFileContentResData = null;

interface Env {
    NODE_ENV?: 'development' | 'production';
    OPENAI_API_KEY?: string;
    GPTR_DEFAULT_ROOT_PATH?: string;
    GPTR_ONLY_LOAD_CONFIG_PATH?: string;
    GPTR_BASE_SERVER_URL?: string;
}
type EnvName = keyof Env;
declare class EnvConfig {
    static get<T extends EnvName>(key: T): string;
    /**
     * get all env vars on server or client side
     * @param type server or client, get all allowed env vars on that scope
     * @param getWays all or process, get  env vars both on process and window.__env__ or only process.env
     * @returns env vars key value map
     */
    static getAllEnvVarsOnScopes(type: 'client' | 'server', getWays?: 'all' | 'process'): Partial<Record<EnvName, string>>;
    static logServerSideEnvVars(): void;
    static logClientSideEnvVars(): void;
    /**
     * for /api/config
     * @returns env vars key value map for window.__env__
     */
    static getClientEnvVarsInServerSide(): Partial<Record<EnvName, string>>;
}
declare global {
    namespace NodeJS {
        interface ProcessEnv extends Env {
        }
    }
    interface Window {
        __env__?: Partial<Env>;
    }
}

export { PartialKeys as $, AnthropicModelConfig as A, BaseResponse as B, ChatMessageStatus as C, LastVisitModalDateRecord as D, Env as E, FilterPattern as F, GetModelConfigType as G, HuggingFaceModelConfig as H, MarkedAsVisitedType as I, FileBaseInfo as J, FileInfo as K, LocaleLang as L, MaybePromise as M, NotificationConfig as N, OpenaiModelConfig as O, FolderInfo as P, FileInfoTreeItem as Q, ReleaseConfig as R, SingleChatMessage as S, TreeItem as T, UserConfig as U, VendorsConfig as V, WssActionName as W, FileInfoTree as X, ReadonlyDeep as Y, ValueOf as Z, DeepRequired as _, ClientEventName as a, AnthropicSecrets as a0, BaseSecrets as a1, BaseModelConfig as a2, ChatModelTypeMap as a3, PartialChatModelTypeMap as a4, ChatModel as a5, HuggingFaceSecrets as a6, OpenaiSecrets as a7, UserConfigForUser as a8, FormOption as a9, GetProjectConfigReqParams as aA, GetProjectConfigResData as aB, GetAppConfigReqParams as aC, GetAppConfigResData as aD, MarkAsVisitedAppConfigReqParams as aE, MarkAsVisitedAppConfigResData as aF, GetUserConfigReqParams as aG, GetUserConfigResData as aH, ServerStorageValue as aI, GetCommonFilesReqParams as aJ, GetCommonFilesResData as aK, OpenEditorReqParams as aL, OpenEditorResData as aM, CreateFilePathReqParams as aN, CreateFilePathResData as aO, RenameFilePathReqParams as aP, RenameFilePathResData as aQ, DeleteFilePathReqParams as aR, DeleteFilePathResData as aS, GetFileInfoReqParams as aT, GetFileInfoResData as aU, SaveFileContentReqParams as aV, SaveFileContentResData as aW, FormFieldBaseConfig as aa, FormInputConfig as ab, FormTextareaConfig as ac, FormSelectConfig as ad, FormCheckboxGroupConfig as ae, FormRadioGroupConfig as af, FormItemConfig as ag, SecretStorageKey as ah, VendorTag as ai, GptPathBaseInfo as aj, GptFileInfo as ak, GptFolderInfo as al, GptChatInfo as am, GptFileInfoTreeItem as an, GptFileInfoTree as ao, ProxySecrets as ap, ModelTypeVendorNameMap as aq, ChatStreamReqParams as ar, GetModelNamesForChooseReqParams as as, GetModelNamesForChooseResData as at, GetGptFilesReqParams as au, GetGptFilesResData as av, GetGptFileInfoReqParams as aw, GetGptFileInfoResData as ax, InitGptFilesReqParams as ay, InitGptFilesResData as az, StorageGetItemReqParams as b, StorageGetItemResData as c, StorageSetItemReqParams as d, StorageSetItemResData as e, StorageRemoveItemReqParams as f, StorageRemoveItemResData as g, StorageClearReqParams as h, StorageClearResData as i, SingleFileConfig as j, ChatModelType as k, SuccessResponse as l, FailResponse as m, ChatRole as n, GptFileTreeItemType as o, ServerStorageName as p, EnvConfig as q, MarkdownString as r, BaseConfig as s, ChangeLogConfig as t, BaseApiVendor as u, ModelApiVendor as v, ModelTypeVendorsMap as w, CommonAppConfig as x, AppConfig as y, CurrentAppConfig as z };