@ebowwa/codespaces-types 1.1.0 → 1.2.0

package/dist/runtime/database.d.ts

@@ -1,376 +0,0 @@
-/**
- * Zod schemas for database operations validation
- */
-import { z } from "zod";
-/**
- * Active port schema
- */
-export declare const ActivePortSchema: z.ZodObject<{
-    port: z.ZodNumber;
-    protocol: z.ZodEnum<["tcp", "udp"]>;
-    service: z.ZodOptional<z.ZodString>;
-    state: z.ZodEnum<["open", "closed", "filtered"]>;
-}, "strip", z.ZodTypeAny, {
-    port: number;
-    protocol: "tcp" | "udp";
-    state: "open" | "closed" | "filtered";
-    service?: string | undefined;
-}, {
-    port: number;
-    protocol: "tcp" | "udp";
-    state: "open" | "closed" | "filtered";
-    service?: string | undefined;
-}>;
-/**
- * Environment metadata schema for database operations
- */
-export declare const EnvironmentMetadataSchema: z.ZodObject<{
-    id: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    project: z.ZodOptional<z.ZodString>;
-    owner: z.ZodOptional<z.ZodString>;
-    purpose: z.ZodOptional<z.ZodString>;
-    environmentType: z.ZodOptional<z.ZodEnum<["development", "staging", "production", "testing"]>>;
-    hoursActive: z.ZodOptional<z.ZodNumber>;
-    lastActive: z.ZodOptional<z.ZodString>;
-    activePorts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        port: z.ZodNumber;
-        protocol: z.ZodEnum<["tcp", "udp"]>;
-        service: z.ZodOptional<z.ZodString>;
-        state: z.ZodEnum<["open", "closed", "filtered"]>;
-    }, "strip", z.ZodTypeAny, {
-        port: number;
-        protocol: "tcp" | "udp";
-        state: "open" | "closed" | "filtered";
-        service?: string | undefined;
-    }, {
-        port: number;
-        protocol: "tcp" | "udp";
-        state: "open" | "closed" | "filtered";
-        service?: string | undefined;
-    }>, "many">>;
-    sshKeyPath: z.ZodOptional<z.ZodString>;
-    bootstrapStatus: z.ZodOptional<z.ZodEnum<["bootstrapping", "ready", "failed"]>>;
-    permissions: z.ZodOptional<z.ZodObject<{
-        seedConfig: z.ZodOptional<z.ZodObject<{
-            sourceEnvironmentId: z.ZodOptional<z.ZodString>;
-            dependencySnapshot: z.ZodOptional<z.ZodString>;
-            setupScript: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            sourceEnvironmentId?: string | undefined;
-            dependencySnapshot?: string | undefined;
-            setupScript?: string | undefined;
-        }, {
-            sourceEnvironmentId?: string | undefined;
-            dependencySnapshot?: string | undefined;
-            setupScript?: string | undefined;
-        }>>;
-        logins: z.ZodOptional<z.ZodObject<{
-            github: z.ZodOptional<z.ZodObject<{
-                enabled: z.ZodBoolean;
-                username: z.ZodOptional<z.ZodString>;
-                tokenScopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, "strip", z.ZodTypeAny, {
-                enabled: boolean;
-                username?: string | undefined;
-                tokenScopes?: string[] | undefined;
-            }, {
-                enabled: boolean;
-                username?: string | undefined;
-                tokenScopes?: string[] | undefined;
-            }>>;
-            doppler: z.ZodOptional<z.ZodObject<{
-                enabled: z.ZodBoolean;
-                project: z.ZodOptional<z.ZodString>;
-                config: z.ZodOptional<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                enabled: boolean;
-                project?: string | undefined;
-                config?: string | undefined;
-            }, {
-                enabled: boolean;
-                project?: string | undefined;
-                config?: string | undefined;
-            }>>;
-            tailscale: z.ZodOptional<z.ZodObject<{
-                enabled: z.ZodBoolean;
-                authKey: z.ZodOptional<z.ZodString>;
-                hostname: z.ZodOptional<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                enabled: boolean;
-                authKey?: string | undefined;
-                hostname?: string | undefined;
-            }, {
-                enabled: boolean;
-                authKey?: string | undefined;
-                hostname?: string | undefined;
-            }>>;
-        }, "strip", z.ZodTypeAny, {
-            github?: {
-                enabled: boolean;
-                username?: string | undefined;
-                tokenScopes?: string[] | undefined;
-            } | undefined;
-            doppler?: {
-                enabled: boolean;
-                project?: string | undefined;
-                config?: string | undefined;
-            } | undefined;
-            tailscale?: {
-                enabled: boolean;
-                authKey?: string | undefined;
-                hostname?: string | undefined;
-            } | undefined;
-        }, {
-            github?: {
-                enabled: boolean;
-                username?: string | undefined;
-                tokenScopes?: string[] | undefined;
-            } | undefined;
-            doppler?: {
-                enabled: boolean;
-                project?: string | undefined;
-                config?: string | undefined;
-            } | undefined;
-            tailscale?: {
-                enabled: boolean;
-                authKey?: string | undefined;
-                hostname?: string | undefined;
-            } | undefined;
-        }>>;
-        vpns: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            type: z.ZodEnum<["wireguard", "openvpn", "tailscale"]>;
-            config: z.ZodString;
-            connected: z.ZodBoolean;
-        }, "strip", z.ZodTypeAny, {
-            type: "tailscale" | "wireguard" | "openvpn";
-            name: string;
-            config: string;
-            connected: boolean;
-        }, {
-            type: "tailscale" | "wireguard" | "openvpn";
-            name: string;
-            config: string;
-            connected: boolean;
-        }>, "many">>;
-        plugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, "strip", z.ZodTypeAny, {
-        plugins?: Record<string, any> | undefined;
-        seedConfig?: {
-            sourceEnvironmentId?: string | undefined;
-            dependencySnapshot?: string | undefined;
-            setupScript?: string | undefined;
-        } | undefined;
-        logins?: {
-            github?: {
-                enabled: boolean;
-                username?: string | undefined;
-                tokenScopes?: string[] | undefined;
-            } | undefined;
-            doppler?: {
-                enabled: boolean;
-                project?: string | undefined;
-                config?: string | undefined;
-            } | undefined;
-            tailscale?: {
-                enabled: boolean;
-                authKey?: string | undefined;
-                hostname?: string | undefined;
-            } | undefined;
-        } | undefined;
-        vpns?: {
-            type: "tailscale" | "wireguard" | "openvpn";
-            name: string;
-            config: string;
-            connected: boolean;
-        }[] | undefined;
-    }, {
-        plugins?: Record<string, any> | undefined;
-        seedConfig?: {
-            sourceEnvironmentId?: string | undefined;
-            dependencySnapshot?: string | undefined;
-            setupScript?: string | undefined;
-        } | undefined;
-        logins?: {
-            github?: {
-                enabled: boolean;
-                username?: string | undefined;
-                tokenScopes?: string[] | undefined;
-            } | undefined;
-            doppler?: {
-                enabled: boolean;
-                project?: string | undefined;
-                config?: string | undefined;
-            } | undefined;
-            tailscale?: {
-                enabled: boolean;
-                authKey?: string | undefined;
-                hostname?: string | undefined;
-            } | undefined;
-        } | undefined;
-        vpns?: {
-            type: "tailscale" | "wireguard" | "openvpn";
-            name: string;
-            config: string;
-            connected: boolean;
-        }[] | undefined;
-    }>>;
-    updatedAt: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    description?: string | undefined;
-    project?: string | undefined;
-    owner?: string | undefined;
-    purpose?: string | undefined;
-    environmentType?: "development" | "staging" | "production" | "testing" | undefined;
-    hoursActive?: number | undefined;
-    lastActive?: string | undefined;
-    activePorts?: {
-        port: number;
-        protocol: "tcp" | "udp";
-        state: "open" | "closed" | "filtered";
-        service?: string | undefined;
-    }[] | undefined;
-    sshKeyPath?: string | undefined;
-    bootstrapStatus?: "bootstrapping" | "ready" | "failed" | undefined;
-    permissions?: {
-        plugins?: Record<string, any> | undefined;
-        seedConfig?: {
-            sourceEnvironmentId?: string | undefined;
-            dependencySnapshot?: string | undefined;
-            setupScript?: string | undefined;
-        } | undefined;
-        logins?: {
-            github?: {
-                enabled: boolean;
-                username?: string | undefined;
-                tokenScopes?: string[] | undefined;
-            } | undefined;
-            doppler?: {
-                enabled: boolean;
-                project?: string | undefined;
-                config?: string | undefined;
-            } | undefined;
-            tailscale?: {
-                enabled: boolean;
-                authKey?: string | undefined;
-                hostname?: string | undefined;
-            } | undefined;
-        } | undefined;
-        vpns?: {
-            type: "tailscale" | "wireguard" | "openvpn";
-            name: string;
-            config: string;
-            connected: boolean;
-        }[] | undefined;
-    } | undefined;
-    updatedAt?: string | undefined;
-}, {
-    id: string;
-    description?: string | undefined;
-    project?: string | undefined;
-    owner?: string | undefined;
-    purpose?: string | undefined;
-    environmentType?: "development" | "staging" | "production" | "testing" | undefined;
-    hoursActive?: number | undefined;
-    lastActive?: string | undefined;
-    activePorts?: {
-        port: number;
-        protocol: "tcp" | "udp";
-        state: "open" | "closed" | "filtered";
-        service?: string | undefined;
-    }[] | undefined;
-    sshKeyPath?: string | undefined;
-    bootstrapStatus?: "bootstrapping" | "ready" | "failed" | undefined;
-    permissions?: {
-        plugins?: Record<string, any> | undefined;
-        seedConfig?: {
-            sourceEnvironmentId?: string | undefined;
-            dependencySnapshot?: string | undefined;
-            setupScript?: string | undefined;
-        } | undefined;
-        logins?: {
-            github?: {
-                enabled: boolean;
-                username?: string | undefined;
-                tokenScopes?: string[] | undefined;
-            } | undefined;
-            doppler?: {
-                enabled: boolean;
-                project?: string | undefined;
-                config?: string | undefined;
-            } | undefined;
-            tailscale?: {
-                enabled: boolean;
-                authKey?: string | undefined;
-                hostname?: string | undefined;
-            } | undefined;
-        } | undefined;
-        vpns?: {
-            type: "tailscale" | "wireguard" | "openvpn";
-            name: string;
-            config: string;
-            connected: boolean;
-        }[] | undefined;
-    } | undefined;
-    updatedAt?: string | undefined;
-}>;
-/**
- * Activity update schema
- */
-export declare const ActivityUpdateSchema: z.ZodObject<{
-    hoursActive: z.ZodOptional<z.ZodNumber>;
-    lastActive: z.ZodOptional<z.ZodString>;
-    activePorts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        port: z.ZodNumber;
-        protocol: z.ZodEnum<["tcp", "udp"]>;
-        service: z.ZodOptional<z.ZodString>;
-        state: z.ZodEnum<["open", "closed", "filtered"]>;
-    }, "strip", z.ZodTypeAny, {
-        port: number;
-        protocol: "tcp" | "udp";
-        state: "open" | "closed" | "filtered";
-        service?: string | undefined;
-    }, {
-        port: number;
-        protocol: "tcp" | "udp";
-        state: "open" | "closed" | "filtered";
-        service?: string | undefined;
-    }>, "many">>;
-}, "strip", z.ZodTypeAny, {
-    hoursActive?: number | undefined;
-    lastActive?: string | undefined;
-    activePorts?: {
-        port: number;
-        protocol: "tcp" | "udp";
-        state: "open" | "closed" | "filtered";
-        service?: string | undefined;
-    }[] | undefined;
-}, {
-    hoursActive?: number | undefined;
-    lastActive?: string | undefined;
-    activePorts?: {
-        port: number;
-        protocol: "tcp" | "udp";
-        state: "open" | "closed" | "filtered";
-        service?: string | undefined;
-    }[] | undefined;
-}>;
-/**
- * Plugins update schema
- */
-export declare const PluginsUpdateSchema: z.ZodObject<{
-    plugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-}, "strip", z.ZodTypeAny, {
-    plugins?: Record<string, any> | undefined;
-}, {
-    plugins?: Record<string, any> | undefined;
-}>;
-/**
- * Type exports for TypeScript inference
- */
-export type EnvironmentMetadataInput = z.infer<typeof EnvironmentMetadataSchema>;
-export type ActivityUpdateInput = z.infer<typeof ActivityUpdateSchema>;
-export type PluginsUpdateInput = z.infer<typeof PluginsUpdateSchema>;
-//# sourceMappingURL=database.d.ts.map

package/dist/runtime/database.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../runtime/database.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;EAK3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8DpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;EAE9B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,yBAAyB,CACjC,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/runtime/database.js

@@ -1,91 +0,0 @@
-/**
- * Zod schemas for database operations validation
- */
-import { z } from "zod";
-/**
- * Active port schema
- */
-export const ActivePortSchema = z.object({
-    port: z.number().int().min(1).max(65535),
-    protocol: z.enum(["tcp", "udp"]),
-    service: z.string().optional(),
-    state: z.enum(["open", "closed", "filtered"]),
-});
-/**
- * Environment metadata schema for database operations
- */
-export const EnvironmentMetadataSchema = z.object({
-    id: z.string(),
-    description: z.string().optional(),
-    project: z.string().optional(),
-    owner: z.string().optional(),
-    purpose: z.string().optional(),
-    environmentType: z
-        .enum(["development", "staging", "production", "testing"])
-        .optional(),
-    hoursActive: z.number().min(0).optional(),
-    lastActive: z.string().datetime().optional(),
-    activePorts: z.array(ActivePortSchema).optional(),
-    sshKeyPath: z.string().optional(), // Path to SSH private key for terminal connections
-    bootstrapStatus: z.enum(["bootstrapping", "ready", "failed"]).optional(), // Cloud-init bootstrap status
-    permissions: z
-        .object({
-        seedConfig: z
-            .object({
-            sourceEnvironmentId: z.string().optional(),
-            dependencySnapshot: z.string().optional(),
-            setupScript: z.string().optional(),
-        })
-            .optional(),
-        logins: z
-            .object({
-            github: z
-                .object({
-                enabled: z.boolean(),
-                username: z.string().optional(),
-                tokenScopes: z.array(z.string()).optional(),
-            })
-                .optional(),
-            doppler: z
-                .object({
-                enabled: z.boolean(),
-                project: z.string().optional(),
-                config: z.string().optional(),
-            })
-                .optional(),
-            tailscale: z
-                .object({
-                enabled: z.boolean(),
-                authKey: z.string().optional(),
-                hostname: z.string().optional(),
-            })
-                .optional(),
-        })
-            .optional(),
-        vpns: z
-            .array(z.object({
-            name: z.string(),
-            type: z.enum(["wireguard", "openvpn", "tailscale"]),
-            config: z.string(),
-            connected: z.boolean(),
-        }))
-            .optional(),
-        plugins: z.record(z.string(), z.any()).optional(),
-    })
-        .optional(),
-    updatedAt: z.string().datetime().optional(),
-});
-/**
- * Activity update schema
- */
-export const ActivityUpdateSchema = z.object({
-    hoursActive: z.number().min(0).optional(),
-    lastActive: z.string().datetime().optional(),
-    activePorts: z.array(ActivePortSchema).optional(),
-});
-/**
- * Plugins update schema
- */
-export const PluginsUpdateSchema = z.object({
-    plugins: z.record(z.string(), z.any()).optional(),
-});

package/dist/runtime/env.d.ts

@@ -1,121 +0,0 @@
-/**
- * Zod schemas for environment variable validation
- */
-import { z } from 'zod';
-/**
- * Server environment variables schema
- */
-export declare const ServerEnvSchema: z.ZodObject<{
-    TEMP_UPLOAD_DIR: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    HETZNER_API_TOKEN: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    TEMP_UPLOAD_DIR: string;
-    HETZNER_API_TOKEN?: string | undefined;
-}, {
-    TEMP_UPLOAD_DIR?: string | undefined;
-    HETZNER_API_TOKEN?: string | undefined;
-}>;
-/**
- * AI client environment variables schema
- * At least one API key must be provided
- */
-export declare const AIEnvSchema: z.ZodEffects<z.ZodObject<{
-    Z_AI_API_KEY: z.ZodOptional<z.ZodString>;
-    ZAI_API_KEY: z.ZodOptional<z.ZodString>;
-    GLM_API_KEY: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}, {
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}>, {
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}, {
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}>;
-/**
- * Full environment variables schema
- */
-export declare const EnvSchema: z.ZodEffects<z.ZodObject<{
-    TEMP_UPLOAD_DIR: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    HETZNER_API_TOKEN: z.ZodOptional<z.ZodString>;
-    Z_AI_API_KEY: z.ZodOptional<z.ZodString>;
-    ZAI_API_KEY: z.ZodOptional<z.ZodString>;
-    GLM_API_KEY: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    TEMP_UPLOAD_DIR: string;
-    HETZNER_API_TOKEN?: string | undefined;
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}, {
-    TEMP_UPLOAD_DIR?: string | undefined;
-    HETZNER_API_TOKEN?: string | undefined;
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}>, {
-    TEMP_UPLOAD_DIR: string;
-    HETZNER_API_TOKEN?: string | undefined;
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}, {
-    TEMP_UPLOAD_DIR?: string | undefined;
-    HETZNER_API_TOKEN?: string | undefined;
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}>;
-/**
- * Validate and parse environment variables
- */
-export declare function validateEnv(env?: Record<string, string | undefined>): z.SafeParseReturnType<{
-    TEMP_UPLOAD_DIR?: string | undefined;
-    HETZNER_API_TOKEN?: string | undefined;
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}, {
-    TEMP_UPLOAD_DIR: string;
-    HETZNER_API_TOKEN?: string | undefined;
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}>;
-/**
- * Validate and parse server environment variables
- */
-export declare function validateServerEnv(env?: Record<string, string | undefined>): z.SafeParseReturnType<{
-    TEMP_UPLOAD_DIR?: string | undefined;
-    HETZNER_API_TOKEN?: string | undefined;
-}, {
-    TEMP_UPLOAD_DIR: string;
-    HETZNER_API_TOKEN?: string | undefined;
-}>;
-/**
- * Validate and parse AI environment variables
- */
-export declare function validateAIEnv(env?: Record<string, string | undefined>): z.SafeParseReturnType<{
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}, {
-    Z_AI_API_KEY?: string | undefined;
-    ZAI_API_KEY?: string | undefined;
-    GLM_API_KEY?: string | undefined;
-}>;
-/**
- * Type exports for TypeScript inference
- */
-export type ServerEnv = z.infer<typeof ServerEnvSchema>;
-export type AIEnv = z.infer<typeof AIEnvSchema>;
-export type Env = z.infer<typeof EnvSchema>;
-//# sourceMappingURL=env.d.ts.map

package/dist/runtime/env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../runtime/env.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;EAG1B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;EAQpB,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQpB,CAAA;AAEF;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe;;;;;;;;;;;;GAEhF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe;;;;;;GAEtF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe;;;;;;;;GAElF;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAC/C,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/runtime/env.js

@@ -1,54 +0,0 @@
-/**
- * Zod schemas for environment variable validation
- */
-import { z } from 'zod';
-/**
- * Server environment variables schema
- */
-export const ServerEnvSchema = z.object({
-    TEMP_UPLOAD_DIR: z.string().optional().default('/tmp/cheapspaces-uploads'),
-    HETZNER_API_TOKEN: z.string().min(1).optional(),
-});
-/**
- * AI client environment variables schema
- * At least one API key must be provided
- */
-export const AIEnvSchema = z
-    .object({
-    Z_AI_API_KEY: z.string().min(1).optional(),
-    ZAI_API_KEY: z.string().min(1).optional(),
-    GLM_API_KEY: z.string().min(1).optional(),
-})
-    .refine((data) => data.Z_AI_API_KEY || data.ZAI_API_KEY || data.GLM_API_KEY, {
-    message: 'At least one AI API key must be provided (Z_AI_API_KEY, ZAI_API_KEY, or GLM_API_KEY)',
-});
-/**
- * Full environment variables schema
- */
-export const EnvSchema = z.object({
-    TEMP_UPLOAD_DIR: z.string().optional().default('/tmp/cheapspaces-uploads'),
-    HETZNER_API_TOKEN: z.string().min(1).optional(),
-    Z_AI_API_KEY: z.string().min(1).optional(),
-    ZAI_API_KEY: z.string().min(1).optional(),
-    GLM_API_KEY: z.string().min(1).optional(),
-}).refine((data) => data.Z_AI_API_KEY || data.ZAI_API_KEY || data.GLM_API_KEY, {
-    message: 'At least one AI API key must be provided (Z_AI_API_KEY, ZAI_API_KEY, or GLM_API_KEY)',
-});
-/**
- * Validate and parse environment variables
- */
-export function validateEnv(env = process.env) {
-    return EnvSchema.safeParse(env);
-}
-/**
- * Validate and parse server environment variables
- */
-export function validateServerEnv(env = process.env) {
-    return ServerEnvSchema.safeParse(env);
-}
-/**
- * Validate and parse AI environment variables
- */
-export function validateAIEnv(env = process.env) {
-    return AIEnvSchema.safeParse(env);
-}

package/dist/runtime/glm.d.ts

@@ -1,17 +0,0 @@
-/**
- * Zod schemas for Z.AI GLM API
- *
- * Provider-specific schemas for Z.AI (GLM) models.
- * Generic AI schemas (chat messages, streaming, etc.) are in ./ai.ts
- */
-import { z } from "zod";
-/**
- * Available GLM models from Z.AI API
- */
-export declare const GLMModelSchema: z.ZodEnum<["GLM-4.7", "GLM-4.6", "GLM-4.5", "GLM-4.5-air"]>;
-export type GLMModel = z.infer<typeof GLMModelSchema>;
-declare const _default: {
-    GLMModelSchema: z.ZodEnum<["GLM-4.7", "GLM-4.6", "GLM-4.5", "GLM-4.5-air"]>;
-};
-export default _default;
-//# sourceMappingURL=glm.d.ts.map

package/dist/runtime/glm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glm.d.ts","sourceRoot":"","sources":["../../runtime/glm.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,cAAc,6DAKzB,CAAC;AAMH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;;;;AAMtD,wBAEE"}

package/dist/runtime/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Central export point for all Zod schemas
- *
- * Note: Hetzner schemas are in app/backend/shared/lib/hetzner/schemas.ts
- * to keep them with the Hetzner client implementation.
- */
-export * from "./api.js";
-export * from "./ai.js";
-export * from "./database.js";
-export * from "./env.js";
-export * from "./glm.js";
-export * from "./ssh.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../runtime/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}