@dhbw-cloud/llm-client 0.0.0-stage → 0.1.0-test.14

package/dist/types.gen.d.ts

@@ -0,0 +1,882 @@
+export type ClientOptions = {
+    baseUrl: `${string}://${string}` | (string & {});
+};
+export type AccessRole = '' | 'user' | 'fleet-admin' | 'admin';
+export type AccessRule = {
+    /**
+     * Bootstrap rules come from the configuration, not from the database. They
+     * guarantee that someone can always administer the list, and they cannot be
+     * edited or deleted through the API.
+     */
+    bootstrap?: boolean;
+    comment?: string;
+    gpu_tier?: string;
+    id?: number;
+    role?: AccessRole;
+    tier?: string;
+    token?: string;
+    updated_at?: string;
+    updated_by?: string;
+};
+export type FleetFleetView = {
+    allowed_serials?: number;
+    capacity?: number;
+    enabled?: boolean;
+    endpoint_v6?: string;
+    enroll_host?: string;
+    enroll_token?: string;
+    listen_port?: number;
+    package?: FleetPackageInfo;
+    package_id?: string;
+    peers?: Array<FleetPeerView>;
+    pool?: string;
+    profiles?: Array<FleetProfile>;
+    reenroll_seconds?: number;
+    self_update?: {
+        canary?: Array<string>;
+        mode?: string;
+        scripts?: {
+            [key: string]: string;
+        };
+    };
+};
+export type FleetPackageInfo = {
+    file?: string;
+    sha256?: string;
+    size?: number;
+    uploaded_at?: string;
+    version?: string;
+};
+export type FleetPeerView = {
+    address?: string;
+    api_base?: string;
+    blocked?: boolean;
+    busy?: boolean;
+    canary?: boolean;
+    contact?: string;
+    controls?: boolean;
+    enabled?: boolean;
+    gate?: string;
+    hardware?: string;
+    hostname?: string;
+    inference?: 'angehalten' | 'unbekannt' | 'nicht registriert' | 'erreichbar' | 'gestört' | 'teilweise';
+    inference_error?: string;
+    last_seen?: string;
+    location?: string;
+    model?: string;
+    model_state?: 'fremdverwaltet' | 'erfüllt' | 'abweichend' | 'unbekannt';
+    models?: Array<string>;
+    name?: string;
+    operator?: string;
+    os?: string;
+    pkg_version?: string;
+    profile?: string;
+    quiet_seconds?: number;
+    ram_gb?: number;
+    script_state?: string;
+    serial?: string;
+    serving?: Array<string>;
+    state?: 'aktiv' | 'ohne Rückmeldung' | 'gesperrt';
+    transport?: string;
+};
+export type FleetProfile = {
+    context?: number;
+    minRamMb?: number;
+    model?: string;
+    name?: string;
+    weight?: number;
+    wiredLimitMb?: number;
+};
+export type GpuEnvironment = {
+    branch?: string;
+    commit?: string;
+    created_at?: string;
+    git_url?: string;
+    id?: number;
+    image?: string;
+    message?: string;
+    name?: string;
+    owner?: string;
+    ref?: string;
+    status?: GpuStatus;
+    updated_at?: string;
+};
+export type GpuServer = {
+    image?: string;
+    name?: string;
+    pending?: string;
+    profile?: string;
+    ready?: boolean;
+    url?: string;
+};
+export type GpuStatus = 'building' | 'ready' | 'failed';
+export type KeysKeyView = {
+    budget?: number;
+    budget_duration?: string;
+    chat?: boolean;
+    id?: string;
+    name?: string;
+    reset_at?: string;
+    spend?: number;
+};
+export type KeysUsage = {
+    budget?: number;
+    budget_duration?: string;
+    keys?: Array<KeysKeyView>;
+    max_keys?: number;
+    models?: Array<string>;
+    own_keys?: number;
+    reset_at?: string;
+    rpm?: number;
+    spend?: number;
+    tpm?: number;
+};
+export type RoleproviderGroup = {
+    description?: string;
+    /**
+     * Display name, left out when it only repeats the group ID (imported groups).
+     */
+    label?: string;
+    token?: string;
+};
+export type WebserverBuildLogResponse = {
+    log?: string;
+};
+export type WebserverCreateKeyRequest = {
+    name: string;
+};
+export type WebserverCreateKeyResponse = {
+    key?: string;
+    name?: string;
+};
+export type WebserverEnvironmentRequest = {
+    git_url: string;
+    name?: string;
+    /**
+     * Branch, tag or commit; empty = default branch.
+     */
+    ref?: string;
+};
+export type WebserverErrorResponse = {
+    /**
+     * Stable machine-readable reason.
+     */
+    code?: string;
+    /**
+     * Readable text, in the field the self-service-ui reads (as with the other DHBW Cloud APIs).
+     */
+    error?: string;
+};
+export type WebserverMeResponse = {
+    /**
+     * Only for admins: autologin link to the LiteLLM admin UI.
+     */
+    admin_ui_url?: string;
+    api_url?: string;
+    chat_url?: string;
+    email?: string;
+    /**
+     * GPU part: tier and JupyterHub, only with GPU access (and the GPU part enabled).
+     */
+    gpu_tier?: string;
+    jupyter_url?: string;
+    matched_token?: string;
+    role?: 'user' | 'fleet-admin' | 'admin';
+    tier?: string;
+};
+export type WebserverPrincipalSearchResponse = {
+    groups?: Array<RoleproviderGroup>;
+    users?: Array<string>;
+};
+export type WebserverRuleRequest = {
+    comment?: string;
+    /**
+     * GPU tier (GPU notebooks and environments); empty = no GPU access.
+     */
+    gpu_tier?: string;
+    role: 'user' | 'fleet-admin' | 'admin';
+    tier: string;
+    token: string;
+};
+export type WebserverStartRequest = {
+    /**
+     * With a GPU (waits in the queue if all GPUs are busy; counts against the GPU quota).
+     */
+    gpu?: boolean;
+};
+export type WebserverStartResponse = {
+    server?: string;
+    url?: string;
+};
+export type WebserverRuleRequest2 = WebserverRuleRequest;
+export type ListAccessRulesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/access-rules';
+};
+export type ListAccessRulesErrors = {
+    /**
+     * Forbidden
+     */
+    403: WebserverErrorResponse;
+};
+export type ListAccessRulesError = ListAccessRulesErrors[keyof ListAccessRulesErrors];
+export type ListAccessRulesResponses = {
+    /**
+     * OK
+     */
+    200: Array<AccessRule>;
+};
+export type ListAccessRulesResponse = ListAccessRulesResponses[keyof ListAccessRulesResponses];
+export type CreateAccessRuleData = {
+    /**
+     * Rule
+     */
+    body: WebserverRuleRequest2;
+    path?: never;
+    query?: never;
+    url: '/v1/access-rules';
+};
+export type CreateAccessRuleErrors = {
+    /**
+     * Bad Request
+     */
+    400: WebserverErrorResponse;
+    /**
+     * Conflict
+     */
+    409: WebserverErrorResponse;
+};
+export type CreateAccessRuleError = CreateAccessRuleErrors[keyof CreateAccessRuleErrors];
+export type CreateAccessRuleResponses = {
+    /**
+     * Created
+     */
+    201: AccessRule;
+};
+export type CreateAccessRuleResponse = CreateAccessRuleResponses[keyof CreateAccessRuleResponses];
+export type DeleteAccessRuleData = {
+    body?: never;
+    path: {
+        /**
+         * Rule id
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/access-rules/{id}';
+};
+export type DeleteAccessRuleErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type DeleteAccessRuleError = DeleteAccessRuleErrors[keyof DeleteAccessRuleErrors];
+export type DeleteAccessRuleResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteAccessRuleResponse = DeleteAccessRuleResponses[keyof DeleteAccessRuleResponses];
+export type UpdateAccessRuleData = {
+    /**
+     * Rule
+     */
+    body: WebserverRuleRequest2;
+    path: {
+        /**
+         * Rule id
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/access-rules/{id}';
+};
+export type UpdateAccessRuleErrors = {
+    /**
+     * Bad Request
+     */
+    400: WebserverErrorResponse;
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type UpdateAccessRuleError = UpdateAccessRuleErrors[keyof UpdateAccessRuleErrors];
+export type UpdateAccessRuleResponses = {
+    /**
+     * OK
+     */
+    200: AccessRule;
+};
+export type UpdateAccessRuleResponse = UpdateAccessRuleResponses[keyof UpdateAccessRuleResponses];
+export type GetFleetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/fleet';
+};
+export type GetFleetErrors = {
+    /**
+     * Forbidden
+     */
+    403: WebserverErrorResponse;
+};
+export type GetFleetError = GetFleetErrors[keyof GetFleetErrors];
+export type GetFleetResponses = {
+    /**
+     * OK
+     */
+    200: FleetFleetView;
+};
+export type GetFleetResponse = GetFleetResponses[keyof GetFleetResponses];
+export type GetFleetInventoryCsvData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/fleet/inventory.csv';
+};
+export type GetFleetInventoryCsvResponses = {
+    /**
+     * OK
+     */
+    200: string;
+};
+export type GetFleetInventoryCsvResponse = GetFleetInventoryCsvResponses[keyof GetFleetInventoryCsvResponses];
+export type DeleteFleetPackageData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/fleet/package';
+};
+export type DeleteFleetPackageResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteFleetPackageResponse = DeleteFleetPackageResponses[keyof DeleteFleetPackageResponses];
+export type GetFleetPackageData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/fleet/package';
+};
+export type GetFleetPackageErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type GetFleetPackageError = GetFleetPackageErrors[keyof GetFleetPackageErrors];
+export type GetFleetPackageResponses = {
+    /**
+     * OK
+     */
+    200: Blob | File;
+};
+export type GetFleetPackageResponse = GetFleetPackageResponses[keyof GetFleetPackageResponses];
+export type GetFleetProfileData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Standort
+         */
+        location?: string;
+        /**
+         * Betreiber
+         */
+        operator?: string;
+        /**
+         * Kontakt
+         */
+        contact?: string;
+    };
+    url: '/v1/fleet/profile';
+};
+export type GetFleetProfileResponses = {
+    /**
+     * OK
+     */
+    200: string;
+};
+export type GetFleetProfileResponse = GetFleetProfileResponses[keyof GetFleetProfileResponses];
+export type GetFleetReadmeData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/fleet/readme';
+};
+export type GetFleetReadmeResponses = {
+    /**
+     * OK
+     */
+    200: string;
+};
+export type GetFleetReadmeResponse = GetFleetReadmeResponses[keyof GetFleetReadmeResponses];
+export type ForgetMachineData = {
+    body?: never;
+    path: {
+        /**
+         * Serial number
+         */
+        serial: string;
+    };
+    query?: never;
+    url: '/v1/fleet/{serial}';
+};
+export type ForgetMachineErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type ForgetMachineError = ForgetMachineErrors[keyof ForgetMachineErrors];
+export type ForgetMachineResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type ForgetMachineResponse = ForgetMachineResponses[keyof ForgetMachineResponses];
+export type BlockMachineData = {
+    body?: never;
+    path: {
+        /**
+         * Serial number
+         */
+        serial: string;
+    };
+    query?: never;
+    url: '/v1/fleet/{serial}/block';
+};
+export type BlockMachineErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type BlockMachineError = BlockMachineErrors[keyof BlockMachineErrors];
+export type BlockMachineResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type BlockMachineResponse = BlockMachineResponses[keyof BlockMachineResponses];
+export type UnblockMachineData = {
+    body?: never;
+    path: {
+        /**
+         * Serial number
+         */
+        serial: string;
+    };
+    query?: never;
+    url: '/v1/fleet/{serial}/unblock';
+};
+export type UnblockMachineErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type UnblockMachineError = UnblockMachineErrors[keyof UnblockMachineErrors];
+export type UnblockMachineResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type UnblockMachineResponse = UnblockMachineResponses[keyof UnblockMachineResponses];
+export type ListGpuTiersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/gpu-tiers';
+};
+export type ListGpuTiersResponses = {
+    /**
+     * OK
+     */
+    200: Array<string>;
+};
+export type ListGpuTiersResponse = ListGpuTiersResponses[keyof ListGpuTiersResponses];
+export type ListGpuEnvironmentsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/gpu/environments';
+};
+export type ListGpuEnvironmentsErrors = {
+    /**
+     * Forbidden
+     */
+    403: WebserverErrorResponse;
+};
+export type ListGpuEnvironmentsError = ListGpuEnvironmentsErrors[keyof ListGpuEnvironmentsErrors];
+export type ListGpuEnvironmentsResponses = {
+    /**
+     * OK
+     */
+    200: Array<GpuEnvironment>;
+};
+export type ListGpuEnvironmentsResponse = ListGpuEnvironmentsResponses[keyof ListGpuEnvironmentsResponses];
+export type CreateGpuEnvironmentData = {
+    /**
+     * Repository
+     */
+    body: WebserverEnvironmentRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/gpu/environments';
+};
+export type CreateGpuEnvironmentErrors = {
+    /**
+     * Bad Request
+     */
+    400: WebserverErrorResponse;
+    /**
+     * Bad Gateway
+     */
+    502: WebserverErrorResponse;
+};
+export type CreateGpuEnvironmentError = CreateGpuEnvironmentErrors[keyof CreateGpuEnvironmentErrors];
+export type CreateGpuEnvironmentResponses = {
+    /**
+     * Created
+     */
+    201: GpuEnvironment;
+};
+export type CreateGpuEnvironmentResponse = CreateGpuEnvironmentResponses[keyof CreateGpuEnvironmentResponses];
+export type DeleteGpuEnvironmentData = {
+    body?: never;
+    path: {
+        /**
+         * Environment id
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/gpu/environments/{id}';
+};
+export type DeleteGpuEnvironmentErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type DeleteGpuEnvironmentError = DeleteGpuEnvironmentErrors[keyof DeleteGpuEnvironmentErrors];
+export type DeleteGpuEnvironmentResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteGpuEnvironmentResponse = DeleteGpuEnvironmentResponses[keyof DeleteGpuEnvironmentResponses];
+export type GetGpuEnvironmentData = {
+    body?: never;
+    path: {
+        /**
+         * Environment id
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/gpu/environments/{id}';
+};
+export type GetGpuEnvironmentErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type GetGpuEnvironmentError = GetGpuEnvironmentErrors[keyof GetGpuEnvironmentErrors];
+export type GetGpuEnvironmentResponses = {
+    /**
+     * OK
+     */
+    200: GpuEnvironment;
+};
+export type GetGpuEnvironmentResponse = GetGpuEnvironmentResponses[keyof GetGpuEnvironmentResponses];
+export type GetGpuEnvironmentLogData = {
+    body?: never;
+    path: {
+        /**
+         * Environment id
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/gpu/environments/{id}/log';
+};
+export type GetGpuEnvironmentLogErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type GetGpuEnvironmentLogError = GetGpuEnvironmentLogErrors[keyof GetGpuEnvironmentLogErrors];
+export type GetGpuEnvironmentLogResponses = {
+    /**
+     * OK
+     */
+    200: WebserverBuildLogResponse;
+};
+export type GetGpuEnvironmentLogResponse = GetGpuEnvironmentLogResponses[keyof GetGpuEnvironmentLogResponses];
+export type RebuildGpuEnvironmentData = {
+    body?: never;
+    path: {
+        /**
+         * Environment id
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/gpu/environments/{id}/rebuild';
+};
+export type RebuildGpuEnvironmentErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type RebuildGpuEnvironmentError = RebuildGpuEnvironmentErrors[keyof RebuildGpuEnvironmentErrors];
+export type RebuildGpuEnvironmentResponses = {
+    /**
+     * OK
+     */
+    200: GpuEnvironment;
+};
+export type RebuildGpuEnvironmentResponse = RebuildGpuEnvironmentResponses[keyof RebuildGpuEnvironmentResponses];
+export type StartGpuEnvironmentData = {
+    /**
+     * Options
+     */
+    body?: WebserverStartRequest;
+    path: {
+        /**
+         * Environment id
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/gpu/environments/{id}/start';
+};
+export type StartGpuEnvironmentErrors = {
+    /**
+     * Conflict
+     */
+    409: WebserverErrorResponse;
+};
+export type StartGpuEnvironmentError = StartGpuEnvironmentErrors[keyof StartGpuEnvironmentErrors];
+export type StartGpuEnvironmentResponses = {
+    /**
+     * Accepted
+     */
+    202: WebserverStartResponse;
+};
+export type StartGpuEnvironmentResponse = StartGpuEnvironmentResponses[keyof StartGpuEnvironmentResponses];
+export type ListGpuServersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/gpu/servers';
+};
+export type ListGpuServersErrors = {
+    /**
+     * Bad Gateway
+     */
+    502: WebserverErrorResponse;
+};
+export type ListGpuServersError = ListGpuServersErrors[keyof ListGpuServersErrors];
+export type ListGpuServersResponses = {
+    /**
+     * OK
+     */
+    200: Array<GpuServer>;
+};
+export type ListGpuServersResponse = ListGpuServersResponses[keyof ListGpuServersResponses];
+export type StopGpuServerData = {
+    body?: never;
+    path: {
+        /**
+         * Server name
+         */
+        name: string;
+    };
+    query?: never;
+    url: '/v1/gpu/servers/{name}';
+};
+export type StopGpuServerErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type StopGpuServerError = StopGpuServerErrors[keyof StopGpuServerErrors];
+export type StopGpuServerResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type StopGpuServerResponse = StopGpuServerResponses[keyof StopGpuServerResponses];
+export type ListKeysData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/keys';
+};
+export type ListKeysErrors = {
+    /**
+     * Forbidden
+     */
+    403: WebserverErrorResponse;
+};
+export type ListKeysError = ListKeysErrors[keyof ListKeysErrors];
+export type ListKeysResponses = {
+    /**
+     * OK
+     */
+    200: Array<KeysKeyView>;
+};
+export type ListKeysResponse = ListKeysResponses[keyof ListKeysResponses];
+export type CreateKeyData = {
+    /**
+     * Key
+     */
+    body: WebserverCreateKeyRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/keys';
+};
+export type CreateKeyErrors = {
+    /**
+     * Bad Request
+     */
+    400: WebserverErrorResponse;
+    /**
+     * Conflict
+     */
+    409: WebserverErrorResponse;
+};
+export type CreateKeyError = CreateKeyErrors[keyof CreateKeyErrors];
+export type CreateKeyResponses = {
+    /**
+     * Created
+     */
+    201: WebserverCreateKeyResponse;
+};
+export type CreateKeyResponse = CreateKeyResponses[keyof CreateKeyResponses];
+export type DeleteKeyData = {
+    body?: never;
+    path: {
+        /**
+         * Key id (from the key list, not the secret)
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/v1/keys/{id}';
+};
+export type DeleteKeyErrors = {
+    /**
+     * Not Found
+     */
+    404: WebserverErrorResponse;
+};
+export type DeleteKeyError = DeleteKeyErrors[keyof DeleteKeyErrors];
+export type DeleteKeyResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteKeyResponse = DeleteKeyResponses[keyof DeleteKeyResponses];
+export type GetMeData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/me';
+};
+export type GetMeErrors = {
+    /**
+     * Unauthorized
+     */
+    401: WebserverErrorResponse;
+};
+export type GetMeError = GetMeErrors[keyof GetMeErrors];
+export type GetMeResponses = {
+    /**
+     * OK
+     */
+    200: WebserverMeResponse;
+};
+export type GetMeResponse = GetMeResponses[keyof GetMeResponses];
+export type SearchPrincipalsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Search text
+         */
+        q?: string;
+        /**
+         * Maximum entries per kind (default 10, at most 50)
+         */
+        limit?: number;
+    };
+    url: '/v1/principals/search';
+};
+export type SearchPrincipalsErrors = {
+    /**
+     * Bad Gateway
+     */
+    502: WebserverErrorResponse;
+};
+export type SearchPrincipalsError = SearchPrincipalsErrors[keyof SearchPrincipalsErrors];
+export type SearchPrincipalsResponses = {
+    /**
+     * OK
+     */
+    200: WebserverPrincipalSearchResponse;
+};
+export type SearchPrincipalsResponse = SearchPrincipalsResponses[keyof SearchPrincipalsResponses];
+export type ListTiersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/tiers';
+};
+export type ListTiersResponses = {
+    /**
+     * OK
+     */
+    200: Array<string>;
+};
+export type ListTiersResponse = ListTiersResponses[keyof ListTiersResponses];
+export type GetUsageData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/usage';
+};
+export type GetUsageErrors = {
+    /**
+     * Forbidden
+     */
+    403: WebserverErrorResponse;
+};
+export type GetUsageError = GetUsageErrors[keyof GetUsageErrors];
+export type GetUsageResponses = {
+    /**
+     * OK
+     */
+    200: KeysUsage;
+};
+export type GetUsageResponse = GetUsageResponses[keyof GetUsageResponses];