@redonvn/event-ws-cliproxyapi-sdk 0.1.0

package/dist/management/client.d.ts

@@ -0,0 +1,187 @@
+import type { AmpModelMapping, AmpModelMappingsPatch, AmpUpstreamAPIKeyEntry, AmpUpstreamAPIKeysPatch, ApiCallRequest, ApiCallResponse, AuthFileDeleteResponse, AuthFileListQuery, AuthFileListResponse, AuthFileModelsQuery, AuthFileModelsResponse, AuthFileStatusRequest, AuthFileStatusResponse, AuthStatusResponse, ClaudeKey, ClaudeKeyPatch, CodexKey, CodexKeyPatch, Config, DeleteLogsResponse, ErrorLogFilesResponse, GeminiKey, GeminiKeyPatch, KeyedValueResponse, LogLinesResponse, OAuthCallbackRequest, OAuthCallbackResponse, OAuthExcludedModelsPatch, OAuthModelAlias, OAuthModelAliasPatch, OAuthStartResponse, OpenAICompatibility, OpenAICompatPatch, PatchByIndexOrMatch, PatchStringListRequest, UsageExportResponse, UsageGetResponse, UsageImportRequest, UsageImportResponse, VertexCompatKey, VertexCompatPatch } from '../shared/types.js';
+import { BaseHttpClient } from '../shared/http.js';
+export declare class ManagementClient extends BaseHttpClient {
+    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("../shared/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>;
+}

package/dist/management/client.js

@@ -0,0 +1,399 @@
+import { BaseHttpClient } from '../shared/http.js';
+export class ManagementClient extends BaseHttpClient {
+    getUsage() {
+        return this.requestJson('GET', '/v0/management/usage', undefined, undefined, 'management');
+    }
+    exportUsage() {
+        return this.requestJson('GET', '/v0/management/usage/export', undefined, undefined, 'management');
+    }
+    importUsage(body) {
+        return this.requestJson('POST', '/v0/management/usage/import', body, undefined, 'management');
+    }
+    getConfig() {
+        return this.requestJson('GET', '/v0/management/config', undefined, undefined, 'management');
+    }
+    getConfigYaml() {
+        return this.requestText('GET', '/v0/management/config.yaml', undefined, undefined, 'management');
+    }
+    putConfigYaml(body) {
+        return this.requestRaw('PUT', '/v0/management/config.yaml', body, { headers: { 'Content-Type': 'text/yaml' } }, 'management').then(async (res) => {
+            const text = await res.text();
+            return text ? JSON.parse(text) : { status: 'ok' };
+        });
+    }
+    getLatestVersion() {
+        return this.requestJson('GET', '/v0/management/latest-version', undefined, undefined, 'management');
+    }
+    getDebug() {
+        return this.requestJson('GET', '/v0/management/debug', undefined, undefined, 'management');
+    }
+    putDebug(body) {
+        return this.requestJson('PUT', '/v0/management/debug', body, undefined, 'management');
+    }
+    patchDebug(body) {
+        return this.requestJson('PATCH', '/v0/management/debug', body, undefined, 'management');
+    }
+    getLoggingToFile() {
+        return this.requestJson('GET', '/v0/management/logging-to-file', undefined, undefined, 'management');
+    }
+    putLoggingToFile(body) {
+        return this.requestJson('PUT', '/v0/management/logging-to-file', body, undefined, 'management');
+    }
+    patchLoggingToFile(body) {
+        return this.requestJson('PATCH', '/v0/management/logging-to-file', body, undefined, 'management');
+    }
+    getLogsMaxTotalSizeMB() {
+        return this.requestJson('GET', '/v0/management/logs-max-total-size-mb', undefined, undefined, 'management');
+    }
+    putLogsMaxTotalSizeMB(body) {
+        return this.requestJson('PUT', '/v0/management/logs-max-total-size-mb', body, undefined, 'management');
+    }
+    patchLogsMaxTotalSizeMB(body) {
+        return this.requestJson('PATCH', '/v0/management/logs-max-total-size-mb', body, undefined, 'management');
+    }
+    getErrorLogsMaxFiles() {
+        return this.requestJson('GET', '/v0/management/error-logs-max-files', undefined, undefined, 'management');
+    }
+    putErrorLogsMaxFiles(body) {
+        return this.requestJson('PUT', '/v0/management/error-logs-max-files', body, undefined, 'management');
+    }
+    patchErrorLogsMaxFiles(body) {
+        return this.requestJson('PATCH', '/v0/management/error-logs-max-files', body, undefined, 'management');
+    }
+    getUsageStatisticsEnabled() {
+        return this.requestJson('GET', '/v0/management/usage-statistics-enabled', undefined, undefined, 'management');
+    }
+    putUsageStatisticsEnabled(body) {
+        return this.requestJson('PUT', '/v0/management/usage-statistics-enabled', body, undefined, 'management');
+    }
+    patchUsageStatisticsEnabled(body) {
+        return this.requestJson('PATCH', '/v0/management/usage-statistics-enabled', body, undefined, 'management');
+    }
+    getProxyUrl() {
+        return this.requestJson('GET', '/v0/management/proxy-url', undefined, undefined, 'management');
+    }
+    putProxyUrl(body) {
+        return this.requestJson('PUT', '/v0/management/proxy-url', body, undefined, 'management');
+    }
+    patchProxyUrl(body) {
+        return this.requestJson('PATCH', '/v0/management/proxy-url', body, undefined, 'management');
+    }
+    deleteProxyUrl() {
+        return this.requestJson('DELETE', '/v0/management/proxy-url', undefined, undefined, 'management');
+    }
+    apiCall(body) {
+        return this.requestJson('POST', '/v0/management/api-call', body, undefined, 'management');
+    }
+    getSwitchProject() {
+        return this.requestJson('GET', '/v0/management/quota-exceeded/switch-project', undefined, undefined, 'management');
+    }
+    putSwitchProject(body) {
+        return this.requestJson('PUT', '/v0/management/quota-exceeded/switch-project', body, undefined, 'management');
+    }
+    patchSwitchProject(body) {
+        return this.requestJson('PATCH', '/v0/management/quota-exceeded/switch-project', body, undefined, 'management');
+    }
+    getSwitchPreviewModel() {
+        return this.requestJson('GET', '/v0/management/quota-exceeded/switch-preview-model', undefined, undefined, 'management');
+    }
+    putSwitchPreviewModel(body) {
+        return this.requestJson('PUT', '/v0/management/quota-exceeded/switch-preview-model', body, undefined, 'management');
+    }
+    patchSwitchPreviewModel(body) {
+        return this.requestJson('PATCH', '/v0/management/quota-exceeded/switch-preview-model', body, undefined, 'management');
+    }
+    getApiKeys() {
+        return this.requestJson('GET', '/v0/management/api-keys', undefined, undefined, 'management');
+    }
+    putApiKeys(body) {
+        return this.requestJson('PUT', '/v0/management/api-keys', body, undefined, 'management');
+    }
+    patchApiKeys(body) {
+        return this.requestJson('PATCH', '/v0/management/api-keys', body, undefined, 'management');
+    }
+    deleteApiKeys(query) {
+        return this.requestJson('DELETE', '/v0/management/api-keys', undefined, { query }, 'management');
+    }
+    getGeminiKeys() {
+        return this.requestJson('GET', '/v0/management/gemini-api-key', undefined, undefined, 'management');
+    }
+    putGeminiKeys(body) {
+        return this.requestJson('PUT', '/v0/management/gemini-api-key', body, undefined, 'management');
+    }
+    patchGeminiKey(body) {
+        return this.requestJson('PATCH', '/v0/management/gemini-api-key', body, undefined, 'management');
+    }
+    deleteGeminiKey(query) {
+        return this.requestJson('DELETE', '/v0/management/gemini-api-key', undefined, { query }, 'management');
+    }
+    getLogs(query) {
+        return this.requestJson('GET', '/v0/management/logs', undefined, { query }, 'management');
+    }
+    deleteLogs() {
+        return this.requestJson('DELETE', '/v0/management/logs', undefined, undefined, 'management');
+    }
+    getRequestErrorLogs() {
+        return this.requestJson('GET', '/v0/management/request-error-logs', undefined, undefined, 'management');
+    }
+    downloadRequestErrorLog(name) {
+        return this.requestRaw('GET', `/v0/management/request-error-logs/${encodeURIComponent(name)}`, undefined, undefined, 'management');
+    }
+    getRequestLogById(id) {
+        return this.requestRaw('GET', `/v0/management/request-log-by-id/${encodeURIComponent(id)}`, undefined, undefined, 'management');
+    }
+    getRequestLog() {
+        return this.requestJson('GET', '/v0/management/request-log', undefined, undefined, 'management');
+    }
+    putRequestLog(body) {
+        return this.requestJson('PUT', '/v0/management/request-log', body, undefined, 'management');
+    }
+    patchRequestLog(body) {
+        return this.requestJson('PATCH', '/v0/management/request-log', body, undefined, 'management');
+    }
+    getWebsocketAuth() {
+        return this.requestJson('GET', '/v0/management/ws-auth', undefined, undefined, 'management');
+    }
+    putWebsocketAuth(body) {
+        return this.requestJson('PUT', '/v0/management/ws-auth', body, undefined, 'management');
+    }
+    patchWebsocketAuth(body) {
+        return this.requestJson('PATCH', '/v0/management/ws-auth', body, undefined, 'management');
+    }
+    getAmpCode() {
+        return this.requestJson('GET', '/v0/management/ampcode', undefined, undefined, 'management');
+    }
+    getAmpUpstreamUrl() {
+        return this.requestJson('GET', '/v0/management/ampcode/upstream-url', undefined, undefined, 'management');
+    }
+    putAmpUpstreamUrl(body) {
+        return this.requestJson('PUT', '/v0/management/ampcode/upstream-url', body, undefined, 'management');
+    }
+    patchAmpUpstreamUrl(body) {
+        return this.requestJson('PATCH', '/v0/management/ampcode/upstream-url', body, undefined, 'management');
+    }
+    deleteAmpUpstreamUrl() {
+        return this.requestJson('DELETE', '/v0/management/ampcode/upstream-url', undefined, undefined, 'management');
+    }
+    getAmpUpstreamApiKey() {
+        return this.requestJson('GET', '/v0/management/ampcode/upstream-api-key', undefined, undefined, 'management');
+    }
+    putAmpUpstreamApiKey(body) {
+        return this.requestJson('PUT', '/v0/management/ampcode/upstream-api-key', body, undefined, 'management');
+    }
+    patchAmpUpstreamApiKey(body) {
+        return this.requestJson('PATCH', '/v0/management/ampcode/upstream-api-key', body, undefined, 'management');
+    }
+    deleteAmpUpstreamApiKey() {
+        return this.requestJson('DELETE', '/v0/management/ampcode/upstream-api-key', undefined, undefined, 'management');
+    }
+    getAmpRestrictManagementToLocalhost() {
+        return this.requestJson('GET', '/v0/management/ampcode/restrict-management-to-localhost', undefined, undefined, 'management');
+    }
+    putAmpRestrictManagementToLocalhost(body) {
+        return this.requestJson('PUT', '/v0/management/ampcode/restrict-management-to-localhost', body, undefined, 'management');
+    }
+    patchAmpRestrictManagementToLocalhost(body) {
+        return this.requestJson('PATCH', '/v0/management/ampcode/restrict-management-to-localhost', body, undefined, 'management');
+    }
+    getAmpModelMappings() {
+        return this.requestJson('GET', '/v0/management/ampcode/model-mappings', undefined, undefined, 'management');
+    }
+    putAmpModelMappings(body) {
+        return this.requestJson('PUT', '/v0/management/ampcode/model-mappings', body, undefined, 'management');
+    }
+    patchAmpModelMappings(body) {
+        return this.requestJson('PATCH', '/v0/management/ampcode/model-mappings', body, undefined, 'management');
+    }
+    deleteAmpModelMappings(query) {
+        return this.requestJson('DELETE', '/v0/management/ampcode/model-mappings', undefined, { query }, 'management');
+    }
+    getAmpForceModelMappings() {
+        return this.requestJson('GET', '/v0/management/ampcode/force-model-mappings', undefined, undefined, 'management');
+    }
+    putAmpForceModelMappings(body) {
+        return this.requestJson('PUT', '/v0/management/ampcode/force-model-mappings', body, undefined, 'management');
+    }
+    patchAmpForceModelMappings(body) {
+        return this.requestJson('PATCH', '/v0/management/ampcode/force-model-mappings', body, undefined, 'management');
+    }
+    getAmpUpstreamApiKeys() {
+        return this.requestJson('GET', '/v0/management/ampcode/upstream-api-keys', undefined, undefined, 'management');
+    }
+    putAmpUpstreamApiKeys(body) {
+        return this.requestJson('PUT', '/v0/management/ampcode/upstream-api-keys', body, undefined, 'management');
+    }
+    patchAmpUpstreamApiKeys(body) {
+        return this.requestJson('PATCH', '/v0/management/ampcode/upstream-api-keys', body, undefined, 'management');
+    }
+    deleteAmpUpstreamApiKeys(query) {
+        return this.requestJson('DELETE', '/v0/management/ampcode/upstream-api-keys', undefined, { query }, 'management');
+    }
+    getRequestRetry() {
+        return this.requestJson('GET', '/v0/management/request-retry', undefined, undefined, 'management');
+    }
+    putRequestRetry(body) {
+        return this.requestJson('PUT', '/v0/management/request-retry', body, undefined, 'management');
+    }
+    patchRequestRetry(body) {
+        return this.requestJson('PATCH', '/v0/management/request-retry', body, undefined, 'management');
+    }
+    getMaxRetryInterval() {
+        return this.requestJson('GET', '/v0/management/max-retry-interval', undefined, undefined, 'management');
+    }
+    putMaxRetryInterval(body) {
+        return this.requestJson('PUT', '/v0/management/max-retry-interval', body, undefined, 'management');
+    }
+    patchMaxRetryInterval(body) {
+        return this.requestJson('PATCH', '/v0/management/max-retry-interval', body, undefined, 'management');
+    }
+    getForceModelPrefix() {
+        return this.requestJson('GET', '/v0/management/force-model-prefix', undefined, undefined, 'management');
+    }
+    putForceModelPrefix(body) {
+        return this.requestJson('PUT', '/v0/management/force-model-prefix', body, undefined, 'management');
+    }
+    patchForceModelPrefix(body) {
+        return this.requestJson('PATCH', '/v0/management/force-model-prefix', body, undefined, 'management');
+    }
+    getRoutingStrategy() {
+        return this.requestJson('GET', '/v0/management/routing/strategy', undefined, undefined, 'management');
+    }
+    putRoutingStrategy(body) {
+        return this.requestJson('PUT', '/v0/management/routing/strategy', body, undefined, 'management');
+    }
+    patchRoutingStrategy(body) {
+        return this.requestJson('PATCH', '/v0/management/routing/strategy', body, undefined, 'management');
+    }
+    getClaudeKeys() {
+        return this.requestJson('GET', '/v0/management/claude-api-key', undefined, undefined, 'management');
+    }
+    putClaudeKeys(body) {
+        return this.requestJson('PUT', '/v0/management/claude-api-key', body, undefined, 'management');
+    }
+    patchClaudeKey(body) {
+        return this.requestJson('PATCH', '/v0/management/claude-api-key', body, undefined, 'management');
+    }
+    deleteClaudeKey(query) {
+        return this.requestJson('DELETE', '/v0/management/claude-api-key', undefined, { query }, 'management');
+    }
+    getCodexKeys() {
+        return this.requestJson('GET', '/v0/management/codex-api-key', undefined, undefined, 'management');
+    }
+    putCodexKeys(body) {
+        return this.requestJson('PUT', '/v0/management/codex-api-key', body, undefined, 'management');
+    }
+    patchCodexKey(body) {
+        return this.requestJson('PATCH', '/v0/management/codex-api-key', body, undefined, 'management');
+    }
+    deleteCodexKey(query) {
+        return this.requestJson('DELETE', '/v0/management/codex-api-key', undefined, { query }, 'management');
+    }
+    getOpenAICompatibility() {
+        return this.requestJson('GET', '/v0/management/openai-compatibility', undefined, undefined, 'management');
+    }
+    putOpenAICompatibility(body) {
+        return this.requestJson('PUT', '/v0/management/openai-compatibility', body, undefined, 'management');
+    }
+    patchOpenAICompatibility(body) {
+        return this.requestJson('PATCH', '/v0/management/openai-compatibility', body, undefined, 'management');
+    }
+    deleteOpenAICompatibility(query) {
+        return this.requestJson('DELETE', '/v0/management/openai-compatibility', undefined, { query }, 'management');
+    }
+    getVertexCompatKeys() {
+        return this.requestJson('GET', '/v0/management/vertex-api-key', undefined, undefined, 'management');
+    }
+    putVertexCompatKeys(body) {
+        return this.requestJson('PUT', '/v0/management/vertex-api-key', body, undefined, 'management');
+    }
+    patchVertexCompatKey(body) {
+        return this.requestJson('PATCH', '/v0/management/vertex-api-key', body, undefined, 'management');
+    }
+    deleteVertexCompatKey(query) {
+        return this.requestJson('DELETE', '/v0/management/vertex-api-key', undefined, { query }, 'management');
+    }
+    getOAuthExcludedModels() {
+        return this.requestJson('GET', '/v0/management/oauth-excluded-models', undefined, undefined, 'management');
+    }
+    putOAuthExcludedModels(body) {
+        return this.requestJson('PUT', '/v0/management/oauth-excluded-models', body, undefined, 'management');
+    }
+    patchOAuthExcludedModels(body) {
+        return this.requestJson('PATCH', '/v0/management/oauth-excluded-models', body, undefined, 'management');
+    }
+    deleteOAuthExcludedModels(query) {
+        return this.requestJson('DELETE', '/v0/management/oauth-excluded-models', undefined, { query }, 'management');
+    }
+    getOAuthModelAlias() {
+        return this.requestJson('GET', '/v0/management/oauth-model-alias', undefined, undefined, 'management');
+    }
+    putOAuthModelAlias(body) {
+        return this.requestJson('PUT', '/v0/management/oauth-model-alias', body, undefined, 'management');
+    }
+    patchOAuthModelAlias(body) {
+        return this.requestJson('PATCH', '/v0/management/oauth-model-alias', body, undefined, 'management');
+    }
+    deleteOAuthModelAlias(query) {
+        return this.requestJson('DELETE', '/v0/management/oauth-model-alias', undefined, { query }, 'management');
+    }
+    listAuthFiles(query) {
+        return this.requestJson('GET', '/v0/management/auth-files', undefined, { query: query }, 'management');
+    }
+    getAuthFileModels(query) {
+        return this.requestJson('GET', '/v0/management/auth-files/models', undefined, { query: query }, 'management');
+    }
+    getStaticModelDefinitions(channel) {
+        return this.requestRaw('GET', `/v0/management/model-definitions/${encodeURIComponent(channel)}`, undefined, undefined, 'management');
+    }
+    downloadAuthFile(query) {
+        return this.requestRaw('GET', '/v0/management/auth-files/download', undefined, { query }, 'management');
+    }
+    uploadAuthFile(file, name) {
+        const form = new FormData();
+        form.append('file', file);
+        if (name)
+            form.append('name', name);
+        return this.requestRaw('POST', '/v0/management/auth-files', form, undefined, 'management');
+    }
+    deleteAuthFile(query) {
+        return this.requestJson('DELETE', '/v0/management/auth-files', undefined, { query }, 'management');
+    }
+    patchAuthFileStatus(body) {
+        return this.requestJson('PATCH', '/v0/management/auth-files/status', body, undefined, 'management');
+    }
+    importVertexCredential(file) {
+        const form = new FormData();
+        form.append('file', file);
+        return this.requestRaw('POST', '/v0/management/vertex/import', form, undefined, 'management');
+    }
+    requestAnthropicAuthUrl() {
+        return this.requestJson('GET', '/v0/management/anthropic-auth-url', undefined, undefined, 'management');
+    }
+    requestCodexAuthUrl() {
+        return this.requestJson('GET', '/v0/management/codex-auth-url', undefined, undefined, 'management');
+    }
+    requestGeminiCliAuthUrl() {
+        return this.requestJson('GET', '/v0/management/gemini-cli-auth-url', undefined, undefined, 'management');
+    }
+    requestAntigravityAuthUrl() {
+        return this.requestJson('GET', '/v0/management/antigravity-auth-url', undefined, undefined, 'management');
+    }
+    requestQwenAuthUrl() {
+        return this.requestJson('GET', '/v0/management/qwen-auth-url', undefined, undefined, 'management');
+    }
+    requestKimiAuthUrl() {
+        return this.requestJson('GET', '/v0/management/kimi-auth-url', undefined, undefined, 'management');
+    }
+    requestIFlowAuthUrl() {
+        return this.requestJson('GET', '/v0/management/iflow-auth-url', undefined, undefined, 'management');
+    }
+    requestIFlowCookieToken(body) {
+        return this.requestJson('POST', '/v0/management/iflow-auth-url', body, undefined, 'management');
+    }
+    postOAuthCallback(body) {
+        return this.requestJson('POST', '/v0/management/oauth-callback', body, undefined, 'management');
+    }
+    getAuthStatus(query) {
+        return this.requestJson('GET', '/v0/management/get-auth-status', undefined, { query }, 'management');
+    }
+}

package/dist/management/index.d.ts

@@ -0,0 +1,2 @@
+export { ManagementClient } from './client.js';
+export type { SDKConfig, StreamingConfig, AccessConfig, AccessProvider, TLSConfig, PprofConfig, RemoteManagementConfig, QuotaExceededConfig, RoutingConfig, OAuthModelAlias, AmpModelMapping, AmpUpstreamAPIKeyEntry, AmpCodeConfig, PayloadConfig, PayloadFilterRule, PayloadRule, PayloadModelRule, CloakConfig, ClaudeModel, ClaudeKey, CodexModel, CodexKey, GeminiModel, GeminiKey, OpenAICompatibilityAPIKey, OpenAICompatibilityModel, OpenAICompatibility, VertexCompatModel, VertexCompatKey, Config, UsageTokenStats, UsageRequestDetail, UsageModelSnapshot, UsageApiSnapshot, UsageStatisticsSnapshot, UsageGetResponse, UsageExportResponse, UsageImportRequest, UsageImportResponse, ApiCallRequest, ApiCallResponse, ErrorResponse, StatusResponse, LogLinesResponse, DeleteLogsResponse, ErrorLogFileInfo, ErrorLogFilesResponse, AuthFileEntry, AuthFileListResponse, AuthFileModelsResponse, AuthFileUploadResponse, AuthFileDeleteResponse, AuthFileStatusRequest, AuthFileStatusResponse, OAuthCallbackRequest, OAuthCallbackResponse, OAuthStartResponse, AuthStatusResponse, AuthFileDownloadRequest, AuthFileListQuery, AuthFileModelsQuery, PatchStringListRequest, PatchByIndexOrMatch, GeminiKeyPatch, ClaudeKeyPatch, CodexKeyPatch, OpenAICompatPatch, VertexCompatPatch, OAuthExcludedModelsPatch, OAuthModelAliasPatch, AmpModelMappingsPatch, AmpUpstreamAPIKeysPatch, AmpStringListPatch, AuthFileUploadRequest, VertexImportRequest, RootResponse, KeepAliveResponse, ModelThinkingSupport, ModelInfo, ModelListResponse } from '../shared/types.js';

package/dist/management/index.js

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

package/dist/openai/client.d.ts

@@ -0,0 +1,10 @@
+import type { ModelListResponse, OpenAIChatCompletionRequest, OpenAICompletionRequest, OpenAIResponsesRequest } from '../shared/types.js';
+import type { RequestOptions } from '../shared/http.js';
+import { BaseHttpClient } from '../shared/http.js';
+export declare class OpenAIClient extends BaseHttpClient {
+    getModels(options?: RequestOptions): Promise<ModelListResponse>;
+    postChatCompletions(body: OpenAIChatCompletionRequest, options?: RequestOptions): Promise<Response>;
+    postCompletions(body: OpenAICompletionRequest, options?: RequestOptions): Promise<Response>;
+    postResponses(body: OpenAIResponsesRequest, options?: RequestOptions): Promise<Response>;
+    postResponsesCompact(body: OpenAIResponsesRequest, options?: RequestOptions): Promise<Response>;
+}

package/dist/openai/client.js

@@ -0,0 +1,23 @@
+import { BaseHttpClient } from '../shared/http.js';
+export class OpenAIClient extends BaseHttpClient {
+    // GET /v1/models (OpenAI or Claude depending on User-Agent)
+    getModels(options) {
+        return this.requestJson('GET', '/v1/models', undefined, options, 'access');
+    }
+    // POST /v1/chat/completions
+    postChatCompletions(body, options) {
+        return this.requestRaw('POST', '/v1/chat/completions', JSON.stringify(body), options, 'access');
+    }
+    // POST /v1/completions
+    postCompletions(body, options) {
+        return this.requestRaw('POST', '/v1/completions', JSON.stringify(body), options, 'access');
+    }
+    // POST /v1/responses
+    postResponses(body, options) {
+        return this.requestRaw('POST', '/v1/responses', JSON.stringify(body), options, 'access');
+    }
+    // POST /v1/responses/compact
+    postResponsesCompact(body, options) {
+        return this.requestRaw('POST', '/v1/responses/compact', JSON.stringify(body), options, 'access');
+    }
+}

package/dist/openai/index.d.ts

@@ -0,0 +1,2 @@
+export { OpenAIClient } from './client.js';
+export type { OpenAIChatRole, OpenAIChatMessageContentText, OpenAIChatMessageContentImageUrl, OpenAIChatMessageContentPart, OpenAIChatMessage, OpenAIChatCompletionRequest, OpenAICompletionRequest, OpenAIResponsesInputText, OpenAIResponsesInputImage, OpenAIResponsesInputContent, OpenAIResponsesInputMessage, OpenAIResponsesRequest, OpenAIChatCompletionChoice, OpenAIChatCompletionResponse, OpenAIChatCompletionChunkChoice, OpenAIChatCompletionChunk, OpenAICompletionChoice, OpenAICompletionResponse, OpenAICompletionChunk, OpenAIResponsesOutput, OpenAIResponsesResponse, OpenAIResponsesChunk, OpenAICompatibleRequest, OpenAICompatibleResponse, OpenAIErrorDetail, OpenAIErrorResponse } from '../shared/types.js';

package/dist/openai/index.js

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