@redonvn/event-ws-cliproxyapi-sdk 0.1.0

package/dist/codec.d.ts

@@ -0,0 +1,8 @@
+import type { HTTPRequest, HTTPResponse, WSErrorPayload, WSHttpRequestPayload, WSHttpResponsePayload, WSStreamChunkPayload } from './types.js';
+export declare function decodeRequest(payload?: WSHttpRequestPayload): HTTPRequest;
+export declare function encodeResponse(resp: HTTPResponse): WSHttpResponsePayload;
+export declare function decodeResponse(payload?: WSHttpResponsePayload): HTTPResponse;
+export declare function encodeChunk(chunk: string): WSStreamChunkPayload;
+export declare function decodeChunk(payload?: WSStreamChunkPayload): string;
+export declare function encodeError(message: string, status?: number): WSErrorPayload;
+export declare function decodeError(payload?: WSErrorPayload): string;

package/dist/codec.js

@@ -0,0 +1,79 @@
+export function decodeRequest(payload) {
+    const method = typeof payload?.method === 'string' ? payload.method : 'GET';
+    const url = typeof payload?.url === 'string' ? payload.url : '';
+    const rawHeaders = payload?.headers;
+    const headers = {};
+    if (rawHeaders) {
+        for (const [key, raw] of Object.entries(rawHeaders)) {
+            if (Array.isArray(raw)) {
+                headers[key] = raw.map(String);
+            }
+            else if (typeof raw === 'string') {
+                headers[key] = [raw];
+            }
+        }
+    }
+    const body = typeof payload?.body === 'string' ? payload.body : '';
+    const sent_at = typeof payload?.sent_at === 'string' ? payload.sent_at : undefined;
+    return { method, url, headers, body, sent_at };
+}
+export function encodeResponse(resp) {
+    const headers = {};
+    if (resp.headers) {
+        for (const [key, value] of Object.entries(resp.headers)) {
+            if (Array.isArray(value))
+                headers[key] = value.map(String);
+            else
+                headers[key] = [String(value)];
+        }
+    }
+    return {
+        status: resp.status ?? 200,
+        headers,
+        body: resp.body ?? ''
+    };
+}
+export function decodeResponse(payload) {
+    const status = typeof payload?.status === 'number'
+        ? payload.status
+        : typeof payload?.status === 'string'
+            ? Number(payload.status)
+            : 200;
+    const headers = {};
+    const rawHeaders = payload?.headers;
+    if (rawHeaders) {
+        for (const [key, raw] of Object.entries(rawHeaders)) {
+            if (Array.isArray(raw)) {
+                headers[key] = raw.map(String);
+            }
+            else if (typeof raw === 'string') {
+                headers[key] = raw;
+            }
+        }
+    }
+    const body = typeof payload?.body === 'string' ? payload.body : '';
+    return { status, headers, body };
+}
+export function encodeChunk(chunk) {
+    return { data: chunk ?? '' };
+}
+export function decodeChunk(payload) {
+    const data = payload?.data;
+    return typeof data === 'string' ? data : '';
+}
+export function encodeError(message, status) {
+    const payload = { error: message || 'wsrelay: upstream error' };
+    if (typeof status === 'number' && !Number.isNaN(status)) {
+        payload.status = status;
+    }
+    return payload;
+}
+export function decodeError(payload) {
+    const message = typeof payload?.error === 'string' ? payload.error : 'wsrelay: upstream error';
+    const status = typeof payload?.status === 'number'
+        ? payload.status
+        : typeof payload?.status === 'string'
+            ? Number(payload.status)
+            : 0;
+    return status ? `${message} (status=${status})` : message;
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAIErrorResponse, ErrorResponse, StatusResponse, JsonObject } from '../http/types.js';
+export type ManagementErrorResponse = ErrorResponse;
+export type ApiErrorPayload = OpenAIErrorResponse | ManagementErrorResponse | StatusResponse | JsonObject | {
+    error: string;
+};
+export declare class APIError extends Error {
+    readonly status: number;
+    readonly payload?: ApiErrorPayload;
+    constructor(message: string, status: number, payload?: ApiErrorPayload);
+}
+export declare function isOpenAIError(payload: unknown): payload is OpenAIErrorResponse;
+export declare function isStatusError(payload: unknown): payload is StatusResponse;
+export declare function isManagementError(payload: unknown): payload is ManagementErrorResponse;

package/dist/errors/index.js

@@ -0,0 +1,26 @@
+export class APIError extends Error {
+    constructor(message, status, payload) {
+        super(message);
+        this.name = 'APIError';
+        this.status = status;
+        this.payload = payload;
+    }
+}
+export function isOpenAIError(payload) {
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const obj = payload;
+    return !!obj.error && typeof obj.error.message === 'string' && typeof obj.error.type === 'string';
+}
+export function isStatusError(payload) {
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const obj = payload;
+    return typeof obj.status === 'string' && (obj.status === 'error' || obj.status === 'wait' || obj.status === 'ok');
+}
+export function isManagementError(payload) {
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const obj = payload;
+    return typeof obj.error === 'string';
+}

package/dist/gemini/client.d.ts

@@ -0,0 +1,9 @@
+import type { GeminiCompatibleRequest } from '../shared/types.js';
+import type { RequestOptions } from '../shared/http.js';
+import { BaseHttpClient } from '../shared/http.js';
+export declare class GeminiClient extends BaseHttpClient {
+    getModels(options?: RequestOptions): Promise<Response>;
+    postModelsAction(action: string, body: GeminiCompatibleRequest, options?: RequestOptions): Promise<Response>;
+    getModelsAction(action: string, query?: Record<string, string | number | boolean | undefined>, options?: RequestOptions): Promise<Response>;
+    postV1Internal(method: string, body: GeminiCompatibleRequest, options?: RequestOptions): Promise<Response>;
+}

package/dist/gemini/client.js

@@ -0,0 +1,19 @@
+import { BaseHttpClient } from '../shared/http.js';
+export class GeminiClient extends BaseHttpClient {
+    // GET /v1beta/models
+    getModels(options) {
+        return this.requestRaw('GET', '/v1beta/models', undefined, options, 'access');
+    }
+    // POST /v1beta/models/*action
+    postModelsAction(action, body, options) {
+        return this.requestRaw('POST', `/v1beta/models/${action}`, JSON.stringify(body), options, 'access');
+    }
+    // GET /v1beta/models/*action
+    getModelsAction(action, query, options) {
+        return this.requestRaw('GET', `/v1beta/models/${action}`, undefined, { ...options, query }, 'access');
+    }
+    // POST /v1internal:method (localhost only)
+    postV1Internal(method, body, options) {
+        return this.requestRaw('POST', `/v1internal:${method}`, JSON.stringify(body), options);
+    }
+}

package/dist/gemini/index.d.ts

@@ -0,0 +1,2 @@
+export { GeminiClient } from './client.js';
+export type { GeminiInlineData, GeminiFunctionCall, GeminiFunctionResponse, GeminiPart, GeminiContent, GeminiGenerationConfig, GeminiToolDeclaration, GeminiGenerateContentRequest, GeminiCandidate, GeminiPromptFeedback, GeminiGenerateContentResponse, GeminiStreamChunk, GeminiCompatibleRequest, GeminiCompatibleResponse } from '../shared/types.js';

package/dist/gemini/index.js

@@ -0,0 +1 @@
+export { GeminiClient } from './client.js';

package/dist/http/client.d.ts

@@ -0,0 +1,260 @@
+import type { AmpModelMapping, AmpModelMappingsPatch, AmpUpstreamAPIKeyEntry, AmpUpstreamAPIKeysPatch, ApiCallRequest, ApiCallResponse, AuthFileDeleteResponse, AuthFileListQuery, AuthFileListResponse, AuthFileModelsQuery, AuthFileModelsResponse, AuthFileStatusRequest, AuthFileStatusResponse, AuthStatusResponse, ClaudeKey, ClaudeKeyPatch, ClaudeMessagesRequest, CliproxyAuthsQuery, CliproxyAuthsResponse, CliproxyChatRequest, CliproxyModelsQuery, CliproxyModelsResponse, CodexKey, CodexKeyPatch, Config, DeleteLogsResponse, ErrorLogFilesResponse, GeminiCompatibleRequest, GeminiGenerateContentRequest, GeminiKey, GeminiKeyPatch, KeepAliveResponse, KeyedValueResponse, LogLinesResponse, ModelListResponse, OAuthCallbackRequest, OAuthCallbackResponse, OAuthExcludedModelsPatch, OAuthModelAlias, OAuthModelAliasPatch, OAuthStartResponse, OpenAIChatCompletionRequest, OpenAICompatibility, OpenAICompatPatch, OpenAICompletionRequest, OpenAIResponsesRequest, PatchByIndexOrMatch, PatchStringListRequest, RootResponse, UsageExportResponse, UsageGetResponse, UsageImportRequest, UsageImportResponse, VertexCompatKey, VertexCompatPatch } from './types.js';
+export interface HttpClientOptions {
+    baseUrl: string;
+    accessKey?: string;
+    managementKey?: string;
+    localPassword?: string;
+    fetch?: typeof fetch;
+}
+export interface RequestOptions {
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+}
+export declare class CliproxyApiClient {
+    readonly baseUrl: string;
+    private accessKey?;
+    private managementKey?;
+    private localPassword?;
+    private fetchImpl;
+    constructor(options: HttpClientOptions);
+    setAccessKey(key?: string): void;
+    setManagementKey(key?: string): void;
+    setLocalPassword(value?: string): void;
+    private buildUrl;
+    private requestJson;
+    private requestText;
+    private requestRaw;
+    private applyAuth;
+    private throwApiError;
+    getWebsocketUrl(path?: string): string;
+    getRoot(): Promise<RootResponse>;
+    getManagementHtml(): Promise<Response>;
+    keepAlive(): Promise<KeepAliveResponse>;
+    anthropicCallback(query: {
+        code?: string;
+        state?: string;
+        error?: string;
+        error_description?: string;
+    }): Promise<Response>;
+    codexCallback(query: {
+        code?: string;
+        state?: string;
+        error?: string;
+        error_description?: string;
+    }): Promise<Response>;
+    googleCallback(query: {
+        code?: string;
+        state?: string;
+        error?: string;
+        error_description?: string;
+    }): Promise<Response>;
+    iflowCallback(query: {
+        code?: string;
+        state?: string;
+        error?: string;
+        error_description?: string;
+    }): Promise<Response>;
+    antigravityCallback(query: {
+        code?: string;
+        state?: string;
+        error?: string;
+        error_description?: string;
+    }): Promise<Response>;
+    postV1Internal(method: string, body: GeminiGenerateContentRequest, options?: RequestOptions): Promise<Response>;
+    getModels(): Promise<ModelListResponse>;
+    postChatCompletions(body: OpenAIChatCompletionRequest, options?: RequestOptions): Promise<Response>;
+    postCompletions(body: OpenAICompletionRequest, options?: RequestOptions): Promise<Response>;
+    postMessages(body: ClaudeMessagesRequest, options?: RequestOptions): Promise<Response>;
+    postMessagesCountTokens(body: ClaudeMessagesRequest, options?: RequestOptions): Promise<Response>;
+    postResponses(body: OpenAIResponsesRequest, options?: RequestOptions): Promise<Response>;
+    postResponsesCompact(body: OpenAIResponsesRequest, options?: RequestOptions): Promise<Response>;
+    getCliproxyAuths(query?: CliproxyAuthsQuery): Promise<CliproxyAuthsResponse>;
+    getCliproxyModels(query?: CliproxyModelsQuery): Promise<CliproxyModelsResponse>;
+    postCliproxyChat(body: CliproxyChatRequest, options?: RequestOptions): Promise<Response>;
+    getGeminiModels(options?: RequestOptions): Promise<Response>;
+    postGeminiModelsAction(action: string, body: GeminiCompatibleRequest, options?: RequestOptions): Promise<Response>;
+    getGeminiModelsAction(action: string, query?: Record<string, string | number | boolean | undefined>, options?: RequestOptions): Promise<Response>;
+    getUsage(): Promise<UsageGetResponse>;
+    exportUsage(): Promise<UsageExportResponse>;
+    importUsage(body: UsageImportRequest): Promise<UsageImportResponse>;
+    getConfig(): Promise<Config>;
+    getConfigYaml(): Promise<string>;
+    putConfigYaml(body: string): Promise<KeyedValueResponse<"status", "ok">>;
+    getLatestVersion(): Promise<KeyedValueResponse<"latest-version", string>>;
+    getDebug(): Promise<KeyedValueResponse<"debug", boolean>>;
+    putDebug(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchDebug(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getLoggingToFile(): Promise<KeyedValueResponse<"logging-to-file", boolean>>;
+    putLoggingToFile(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchLoggingToFile(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getLogsMaxTotalSizeMB(): Promise<KeyedValueResponse<"logs-max-total-size-mb", number>>;
+    putLogsMaxTotalSizeMB(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchLogsMaxTotalSizeMB(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    getErrorLogsMaxFiles(): Promise<KeyedValueResponse<"error-logs-max-files", number>>;
+    putErrorLogsMaxFiles(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchErrorLogsMaxFiles(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    getUsageStatisticsEnabled(): Promise<KeyedValueResponse<"usage-statistics-enabled", boolean>>;
+    putUsageStatisticsEnabled(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchUsageStatisticsEnabled(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getProxyUrl(): Promise<KeyedValueResponse<"proxy-url", string>>;
+    putProxyUrl(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchProxyUrl(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteProxyUrl(): Promise<KeyedValueResponse<"status", "ok">>;
+    apiCall(body: ApiCallRequest): Promise<ApiCallResponse>;
+    getSwitchProject(): Promise<KeyedValueResponse<"switch-project", boolean>>;
+    putSwitchProject(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchSwitchProject(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getSwitchPreviewModel(): Promise<KeyedValueResponse<"switch-preview-model", boolean>>;
+    putSwitchPreviewModel(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchSwitchPreviewModel(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getApiKeys(): Promise<KeyedValueResponse<"api-keys", string[]>>;
+    putApiKeys(body: string[] | {
+        items: string[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchApiKeys(body: PatchStringListRequest): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteApiKeys(query?: {
+        index?: number;
+        value?: string;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getGeminiKeys(): Promise<KeyedValueResponse<"gemini-api-key", GeminiKey[]>>;
+    putGeminiKeys(body: GeminiKey[] | {
+        items: GeminiKey[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchGeminiKey(body: PatchByIndexOrMatch<GeminiKeyPatch>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteGeminiKey(query?: {
+        'api-key'?: string;
+        index?: number;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getLogs(query?: {
+        limit?: number;
+        after?: number;
+    }): Promise<LogLinesResponse>;
+    deleteLogs(): Promise<DeleteLogsResponse>;
+    getRequestErrorLogs(): Promise<ErrorLogFilesResponse>;
+    downloadRequestErrorLog(name: string): Promise<Response>;
+    getRequestLogById(id: string): Promise<Response>;
+    getRequestLog(): Promise<KeyedValueResponse<"request-log", boolean>>;
+    putRequestLog(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchRequestLog(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getWebsocketAuth(): Promise<KeyedValueResponse<"ws-auth", boolean>>;
+    putWebsocketAuth(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchWebsocketAuth(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpCode(): Promise<KeyedValueResponse<"ampcode", import("./types.js").AmpCodeConfig>>;
+    getAmpUpstreamUrl(): Promise<KeyedValueResponse<"upstream-url", string>>;
+    putAmpUpstreamUrl(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpUpstreamUrl(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteAmpUpstreamUrl(): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpUpstreamApiKey(): Promise<KeyedValueResponse<"upstream-api-key", string>>;
+    putAmpUpstreamApiKey(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpUpstreamApiKey(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteAmpUpstreamApiKey(): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpRestrictManagementToLocalhost(): Promise<KeyedValueResponse<"restrict-management-to-localhost", boolean>>;
+    putAmpRestrictManagementToLocalhost(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpRestrictManagementToLocalhost(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpModelMappings(): Promise<KeyedValueResponse<"model-mappings", AmpModelMapping[]>>;
+    putAmpModelMappings(body: AmpModelMapping[] | AmpModelMappingsPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpModelMappings(body: AmpModelMappingsPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteAmpModelMappings(query?: {
+        index?: number;
+        match?: string;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpForceModelMappings(): Promise<KeyedValueResponse<"force-model-mappings", boolean>>;
+    putAmpForceModelMappings(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpForceModelMappings(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpUpstreamApiKeys(): Promise<KeyedValueResponse<"upstream-api-keys", AmpUpstreamAPIKeyEntry[]>>;
+    putAmpUpstreamApiKeys(body: AmpUpstreamAPIKeyEntry[] | AmpUpstreamAPIKeysPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpUpstreamApiKeys(body: AmpUpstreamAPIKeysPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteAmpUpstreamApiKeys(query?: {
+        index?: number;
+        match?: string;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getRequestRetry(): Promise<KeyedValueResponse<"request-retry", number>>;
+    putRequestRetry(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchRequestRetry(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    getMaxRetryInterval(): Promise<KeyedValueResponse<"max-retry-interval", number>>;
+    putMaxRetryInterval(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchMaxRetryInterval(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    getForceModelPrefix(): Promise<KeyedValueResponse<"force-model-prefix", boolean>>;
+    putForceModelPrefix(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchForceModelPrefix(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getRoutingStrategy(): Promise<KeyedValueResponse<"strategy", string>>;
+    putRoutingStrategy(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchRoutingStrategy(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    getClaudeKeys(): Promise<KeyedValueResponse<"claude-api-key", ClaudeKey[]>>;
+    putClaudeKeys(body: ClaudeKey[] | {
+        items: ClaudeKey[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchClaudeKey(body: PatchByIndexOrMatch<ClaudeKeyPatch>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteClaudeKey(query?: {
+        'api-key'?: string;
+        index?: number;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getCodexKeys(): Promise<KeyedValueResponse<"codex-api-key", CodexKey[]>>;
+    putCodexKeys(body: CodexKey[] | {
+        items: CodexKey[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchCodexKey(body: PatchByIndexOrMatch<CodexKeyPatch>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteCodexKey(query?: {
+        'api-key'?: string;
+        index?: number;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getOpenAICompatibility(): Promise<KeyedValueResponse<"openai-compatibility", OpenAICompatibility[]>>;
+    putOpenAICompatibility(body: OpenAICompatibility[] | {
+        items: OpenAICompatibility[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchOpenAICompatibility(body: PatchByIndexOrMatch<OpenAICompatPatch>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteOpenAICompatibility(query?: {
+        name?: string;
+        index?: number;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getVertexCompatKeys(): Promise<KeyedValueResponse<"vertex-api-key", VertexCompatKey[]>>;
+    putVertexCompatKeys(body: VertexCompatKey[] | {
+        items: VertexCompatKey[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchVertexCompatKey(body: PatchByIndexOrMatch<VertexCompatPatch>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteVertexCompatKey(query?: {
+        'api-key'?: string;
+        index?: number;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getOAuthExcludedModels(): Promise<KeyedValueResponse<"oauth-excluded-models", Record<string, string[]>>>;
+    putOAuthExcludedModels(body: Record<string, string[]> | {
+        items: Record<string, string[]>;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchOAuthExcludedModels(body: OAuthExcludedModelsPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteOAuthExcludedModels(query?: {
+        provider?: string;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getOAuthModelAlias(): Promise<KeyedValueResponse<"oauth-model-alias", Record<string, OAuthModelAlias[]>>>;
+    putOAuthModelAlias(body: Record<string, OAuthModelAlias[]> | {
+        items: Record<string, OAuthModelAlias[]>;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchOAuthModelAlias(body: PatchByIndexOrMatch<OAuthModelAliasPatch> | OAuthModelAliasPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteOAuthModelAlias(query?: {
+        provider?: string;
+        channel?: string;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    listAuthFiles(query?: AuthFileListQuery): Promise<AuthFileListResponse>;
+    getAuthFileModels(query: AuthFileModelsQuery): Promise<AuthFileModelsResponse>;
+    getStaticModelDefinitions(channel: string): Promise<Response>;
+    downloadAuthFile(query: {
+        name: string;
+    }): Promise<Response>;
+    uploadAuthFile(file: Blob, name?: string): Promise<Response>;
+    deleteAuthFile(query: {
+        name: string;
+    }): Promise<AuthFileDeleteResponse>;
+    patchAuthFileStatus(body: AuthFileStatusRequest): Promise<AuthFileStatusResponse>;
+    importVertexCredential(file: Blob): Promise<Response>;
+    requestAnthropicAuthUrl(): Promise<OAuthStartResponse>;
+    requestCodexAuthUrl(): Promise<OAuthStartResponse>;
+    requestGeminiCliAuthUrl(): Promise<OAuthStartResponse>;
+    requestAntigravityAuthUrl(): Promise<OAuthStartResponse>;
+    requestQwenAuthUrl(): Promise<OAuthStartResponse>;
+    requestKimiAuthUrl(): Promise<OAuthStartResponse>;
+    requestIFlowAuthUrl(): Promise<OAuthStartResponse>;
+    requestIFlowCookieToken(body: KeyedValueResponse<'cookie', string>): Promise<OAuthStartResponse>;
+    postOAuthCallback(body: OAuthCallbackRequest): Promise<OAuthCallbackResponse>;
+    getAuthStatus(query?: {
+        state?: string;
+    }): Promise<AuthStatusResponse>;
+}