@figulus/schema 0.4.0-alpha-dev → 0.5.0-alpha-dev-1

package/dist/volume.d.ts

@@ -1,140 +0,0 @@
-import { z } from 'zod';
-export declare const EnsureVolumeRequestSchema: z.ZodObject<{
-    volume_name: z.ZodString;
-    driver: z.ZodOptional<z.ZodString>;
-    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    volume_name: string;
-    driver?: string | undefined;
-    labels?: Record<string, string> | undefined;
-}, {
-    volume_name: string;
-    driver?: string | undefined;
-    labels?: Record<string, string> | undefined;
-}>;
-export type EnsureVolumeRequest = z.infer<typeof EnsureVolumeRequestSchema>;
-export declare const EnsureVolumeResponseSchema: z.ZodObject<{
-    volume_name: z.ZodString;
-    created: z.ZodBoolean;
-    message: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    volume_name: string;
-    created: boolean;
-    message?: string | undefined;
-}, {
-    volume_name: string;
-    created: boolean;
-    message?: string | undefined;
-}>;
-export type EnsureVolumeResponse = z.infer<typeof EnsureVolumeResponseSchema>;
-export declare const VolumeInfoSchema: z.ZodObject<{
-    name: z.ZodString;
-    driver: z.ZodString;
-    mountpoint: z.ZodString;
-    created_at: z.ZodString;
-    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    scope: z.ZodString;
-    size_bytes: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    driver: string;
-    mountpoint: string;
-    created_at: string;
-    scope: string;
-    labels?: Record<string, string> | undefined;
-    size_bytes?: number | undefined;
-}, {
-    name: string;
-    driver: string;
-    mountpoint: string;
-    created_at: string;
-    scope: string;
-    labels?: Record<string, string> | undefined;
-    size_bytes?: number | undefined;
-}>;
-export type VolumeInfo = z.infer<typeof VolumeInfoSchema>;
-export declare const ListVolumesResponseSchema: z.ZodObject<{
-    volumes: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        driver: z.ZodString;
-        mountpoint: z.ZodString;
-        created_at: z.ZodString;
-        labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        scope: z.ZodString;
-        size_bytes: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        driver: string;
-        mountpoint: string;
-        created_at: string;
-        scope: string;
-        labels?: Record<string, string> | undefined;
-        size_bytes?: number | undefined;
-    }, {
-        name: string;
-        driver: string;
-        mountpoint: string;
-        created_at: string;
-        scope: string;
-        labels?: Record<string, string> | undefined;
-        size_bytes?: number | undefined;
-    }>, "many">;
-    count: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    volumes: {
-        name: string;
-        driver: string;
-        mountpoint: string;
-        created_at: string;
-        scope: string;
-        labels?: Record<string, string> | undefined;
-        size_bytes?: number | undefined;
-    }[];
-    count: number;
-}, {
-    volumes: {
-        name: string;
-        driver: string;
-        mountpoint: string;
-        created_at: string;
-        scope: string;
-        labels?: Record<string, string> | undefined;
-        size_bytes?: number | undefined;
-    }[];
-    count: number;
-}>;
-export type ListVolumesResponse = z.infer<typeof ListVolumesResponseSchema>;
-export declare const DeleteVolumeResponseSchema: z.ZodObject<{
-    volume_name: z.ZodString;
-    message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-    volume_name: string;
-}, {
-    message: string;
-    volume_name: string;
-}>;
-export type DeleteVolumeResponse = z.infer<typeof DeleteVolumeResponseSchema>;
-export declare const PruneVolumesRequestSchema: z.ZodObject<{
-    filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-}, "strip", z.ZodTypeAny, {
-    filters?: Record<string, string[]> | undefined;
-}, {
-    filters?: Record<string, string[]> | undefined;
-}>;
-export type PruneVolumesRequest = z.infer<typeof PruneVolumesRequestSchema>;
-export declare const PruneVolumesResponseSchema: z.ZodObject<{
-    volumes_deleted: z.ZodArray<z.ZodString, "many">;
-    space_reclaimed: z.ZodNumber;
-    message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-    volumes_deleted: string[];
-    space_reclaimed: number;
-}, {
-    message: string;
-    volumes_deleted: string[];
-    space_reclaimed: number;
-}>;
-export type PruneVolumesResponse = z.infer<typeof PruneVolumesResponseSchema>;
-//# sourceMappingURL=volume.d.ts.map

package/dist/volume.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"volume.d.ts","sourceRoot":"","sources":["../src/volume.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAIpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAIrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;EAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,0BAA0B;;;;;;;;;EAGrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,yBAAyB;;;;;;EAEpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAIrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/volume.js

@@ -1,37 +0,0 @@
-import { z } from 'zod';
-export const EnsureVolumeRequestSchema = z.object({
-    volume_name: z.string().min(1),
-    driver: z.string().optional(),
-    labels: z.record(z.string()).optional(),
-});
-export const EnsureVolumeResponseSchema = z.object({
-    volume_name: z.string(),
-    created: z.boolean(),
-    message: z.string().optional(),
-});
-export const VolumeInfoSchema = z.object({
-    name: z.string(),
-    driver: z.string(),
-    mountpoint: z.string(),
-    created_at: z.string(),
-    labels: z.record(z.string()).optional(),
-    scope: z.string(),
-    size_bytes: z.number().int().optional(),
-});
-export const ListVolumesResponseSchema = z.object({
-    volumes: z.array(VolumeInfoSchema),
-    count: z.number().int(),
-});
-export const DeleteVolumeResponseSchema = z.object({
-    volume_name: z.string(),
-    message: z.string(),
-});
-export const PruneVolumesRequestSchema = z.object({
-    filters: z.record(z.array(z.string())).optional(),
-});
-export const PruneVolumesResponseSchema = z.object({
-    volumes_deleted: z.array(z.string()),
-    space_reclaimed: z.number().int(),
-    message: z.string(),
-});
-//# sourceMappingURL=volume.js.map

package/dist/volume.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"volume.js","sourceRoot":"","sources":["../src/volume.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;CACxC,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IACjD,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACvC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;CACxC,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC;IAClC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;CACxB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IACjD,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;CACpB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;CAClD,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IACjD,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACpC,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IACjC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;CACpB,CAAC,CAAC"}

package/src/figspec.ts

@@ -1,279 +0,0 @@
-import { z } from 'zod';
-
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-
-export const fileContentSchema = z.object({
-  data: z.string(),
-  encoding: z.string().optional(),
-});
-export type FileContent = z.infer<typeof fileContentSchema>;
-
-export const filePermissionsSchema = z.object({
-  read: z.number().int(),
-  write: z.number().int(),
-  execute: z.number().int(),
-});
-export type FilePermissions = z.infer<typeof filePermissionsSchema>;
-
-// portMappingSchema is local to figspec; the canonical PortMapping export is in shared.ts.
-const portMappingSchema = z.object({
-  container: z.number().int(),
-  host: z.number().int().optional(),
-});
-
-// ---------------------------------------------------------------------------
-// Package installation
-// ---------------------------------------------------------------------------
-
-export const packageSpecSchema = z.object({
-  name: z.string(),
-  version: z.string().optional(),
-  args: z.array(z.string()).optional(),
-});
-export type PackageSpec = z.infer<typeof packageSpecSchema>;
-
-export const installGroupSchema = z.object({
-  packageManager: z.string().min(1),
-  packages: z.array(z.union([z.string(), packageSpecSchema])),
-  globalArgs: z.array(z.string()).optional(),
-});
-export type InstallGroup = z.infer<typeof installGroupSchema>;
-
-// ---------------------------------------------------------------------------
-// Build-time volume mounts
-// ---------------------------------------------------------------------------
-
-export const buildVolumeMountRegularSchema = z.object({
-  type: z.literal('regular'),
-  host_path: z.string().optional(),
-  container_path: z.string().optional(),
-  read_only: z.boolean().optional(),
-});
-
-export const buildVolumeMountNewFileSchema = z.object({
-  type: z.literal('new-file'),
-  container_path: z.string(),
-  content: fileContentSchema,
-  owner: z.string().optional(),
-  permissions: filePermissionsSchema.optional(),
-});
-
-export const buildVolumeMountSchema = z.discriminatedUnion('type', [
-  buildVolumeMountRegularSchema,
-  buildVolumeMountNewFileSchema,
-]);
-export type BuildVolumeMount = z.infer<typeof buildVolumeMountSchema>;
-
-// ---------------------------------------------------------------------------
-// Run-time volume mounts
-// ---------------------------------------------------------------------------
-
-export const runVolumeMountRegularSchema = z.object({
-  type: z.literal('regular'),
-  host_path: z.string().optional(),
-  container_path: z.string().optional(),
-  read_only: z.boolean().optional(),
-});
-
-export const runVolumeMountDockerSocketSchema = z.object({
-  type: z.literal('docker-socket'),
-  container_path: z.string().optional(),
-});
-
-export const runVolumeMountNewFileSchema = z.object({
-  type: z.literal('new-file'),
-  container_path: z.string(),
-  content: fileContentSchema,
-  owner: z.string().optional(),
-  permissions: filePermissionsSchema.optional(),
-});
-
-export const runVolumeMountNamedSchema = z.object({
-  type: z.literal('named'),
-  name: z.string(),
-  container_path: z.string(),
-  read_only: z.boolean().optional(),
-});
-
-export const runVolumeMountAnonymousSchema = z.object({
-  type: z.literal('anonymous'),
-  container_path: z.string(),
-});
-
-export const runVolumeMountTmpfsSchema = z.object({
-  type: z.literal('tmpfs'),
-  container_path: z.string(),
-  size_mb: z.number().int().optional(),
-});
-
-export const runVolumeMountCopyInSchema = z.object({
-  type: z.literal('copy-in'),
-  host_path: z.string(),
-  container_path: z.string(),
-});
-
-export const runVolumeMountCopyOutSchema = z.object({
-  type: z.literal('copy-out'),
-  container_path: z.string(),
-  host_path: z.string(),
-  changed_only: z.boolean().optional(),
-});
-
-export const runVolumeMountSchema = z.discriminatedUnion('type', [
-  runVolumeMountRegularSchema,
-  runVolumeMountDockerSocketSchema,
-  runVolumeMountNewFileSchema,
-  runVolumeMountNamedSchema,
-  runVolumeMountAnonymousSchema,
-  runVolumeMountTmpfsSchema,
-  runVolumeMountCopyInSchema,
-  runVolumeMountCopyOutSchema,
-]);
-export type RunVolumeMount = z.infer<typeof runVolumeMountSchema>;
-
-// ---------------------------------------------------------------------------
-// Execute model
-// ---------------------------------------------------------------------------
-
-export const mainCmdOnExitWithCodeSchema = z.object({
-  cmd: z.union([z.string(), z.null()]).optional(),
-  exitCode: z.number().int(),
-});
-export type MainCmdOnExitWithCode = z.infer<typeof mainCmdOnExitWithCodeSchema>;
-
-// onExit accepts: null | "persist" | "shutdown" | command-string | dispatch-table
-export const onExitBehaviorSchema = z.union([
-  z.string(),
-  z.null(),
-  z.array(mainCmdOnExitWithCodeSchema),
-]);
-export type OnExitBehavior = z.infer<typeof onExitBehaviorSchema>;
-
-export const executeStartupCmdSchema = z.object({
-  cmd: z.string(),
-  async: z.boolean().optional(),
-});
-export type ExecuteStartupCmd = z.infer<typeof executeStartupCmdSchema>;
-
-export const executeMainCmdSchema = z.object({
-  cmd: z.string(),
-  onExit: onExitBehaviorSchema.optional(),
-  parser: z.string().optional(),
-});
-export type ExecuteMainCmd = z.infer<typeof executeMainCmdSchema>;
-
-export const executeShutdownCmdSchema = z.object({
-  cmd: z.string(),
-});
-export type ExecuteShutdownCmd = z.infer<typeof executeShutdownCmdSchema>;
-
-export const scheduleExpressionStructSchema = z.object({
-  interval: z.number().int().optional(),
-  time: z.string().optional(),
-  cron: z.string().optional(),
-});
-export type ScheduleExpressionStruct = z.infer<typeof scheduleExpressionStructSchema>;
-
-export const scheduleExpressionSchema = z.union([
-  z.string(),
-  scheduleExpressionStructSchema,
-]);
-export type ScheduleExpression = z.infer<typeof scheduleExpressionSchema>;
-
-export const scheduledCmdSchema = z.object({
-  cmd: z.string(),
-  runAt: scheduleExpressionSchema,
-  onExit: onExitBehaviorSchema.optional(),
-  parser: z.string().optional(),
-});
-export type ScheduledCmd = z.infer<typeof scheduledCmdSchema>;
-
-export const figSpecExecuteSchema = z.object({
-  startup: z.array(executeStartupCmdSchema).optional(),
-  main: executeMainCmdSchema,
-  shutdown: z.array(executeShutdownCmdSchema).optional(),
-  scheduled: z.array(scheduledCmdSchema).optional(),
-});
-export type FigSpecExecute = z.infer<typeof figSpecExecuteSchema>;
-
-// ---------------------------------------------------------------------------
-// Build spec
-// ---------------------------------------------------------------------------
-
-export const buildExecuteStepSchema = z.object({
-  cmd: z.string().min(1),
-});
-export type BuildExecuteStep = z.infer<typeof buildExecuteStepSchema>;
-
-export const figSpecBuildBaseSchema = z.object({
-  schemaVersion: z.string().optional(),
-  specName: z.string().optional(),
-  packagesToInstall: z.array(installGroupSchema).optional(),
-  platform: z.string().optional(),
-  env: z.record(z.string()).optional(),
-  volumes: z.array(buildVolumeMountSchema).optional(),
-  execute: z.array(buildExecuteStepSchema).optional(),
-  workDir: z.string().optional(),
-  user: z.string().optional(),
-});
-
-export const figSpecBuildStandaloneSchema = figSpecBuildBaseSchema.extend({
-  baseImage: z.string(),
-});
-export type FigSpecBuildStandalone = z.infer<typeof figSpecBuildStandaloneSchema>;
-
-export const figSpecBuildWithBaseSpecSchema = figSpecBuildBaseSchema.extend({
-  baseSpec: z.string(),
-  baseImage: z.string().optional(),
-});
-export type FigSpecBuildWithBaseSpec = z.infer<typeof figSpecBuildWithBaseSpecSchema>;
-
-export const figSpecBuildSchema = z.union([
-  figSpecBuildStandaloneSchema,
-  figSpecBuildWithBaseSpecSchema,
-]);
-export type FigSpecBuild = z.infer<typeof figSpecBuildSchema>;
-
-// ---------------------------------------------------------------------------
-// Run spec
-// ---------------------------------------------------------------------------
-
-export const figSpecRunSchema = z.object({
-  schemaVersion: z.string().optional(),
-  specName: z.string().optional(),
-  execute: figSpecExecuteSchema,
-  env: z.record(z.string()).optional(),
-  secrets: z.record(z.string()).optional(),
-  volumes: z.array(runVolumeMountSchema).optional(),
-  workDir: z.string().optional(),
-  user: z.string().optional(),
-  ports: z.array(portMappingSchema).optional(),
-});
-export type FigSpecRun = z.infer<typeof figSpecRunSchema>;
-
-// ---------------------------------------------------------------------------
-// Top-level Figspec document
-// ---------------------------------------------------------------------------
-
-export const figSpecBuildInputSchema = z.union([
-  figSpecBuildSchema,
-  z.string(),
-  z.array(z.string()),
-]);
-export type FigSpecBuildInput = z.infer<typeof figSpecBuildInputSchema>;
-
-export const figSpecRunInputSchema = z.union([
-  figSpecRunSchema,
-  z.string(),
-]);
-export type FigSpecRunInput = z.infer<typeof figSpecRunInputSchema>;
-
-export const figSpecSchema = z.object({
-  schemaVersion: z.string(),
-  specName: z.string().optional(),
-  build: figSpecBuildInputSchema,
-  run: figSpecRunInputSchema.optional(),
-});
-export type FigSpec = z.infer<typeof figSpecSchema>;

package/src/figstack.ts

@@ -1,92 +0,0 @@
-import { z } from 'zod';
-import { PortMappingSchema } from './shared.js';
-
-// ---------------------------------------------------------------------------
-// FigStackDependency
-// ---------------------------------------------------------------------------
-
-export const figStackDependencySchema = z.object({
-  name: z.string().min(1),
-  condition: z.enum(['started', 'healthy', 'completed']).default('started').optional(),
-});
-export type FigStackDependency = z.infer<typeof figStackDependencySchema>;
-
-// ---------------------------------------------------------------------------
-// FigStackHealthCheck (discriminated union flattened into one object)
-// ---------------------------------------------------------------------------
-
-export const figStackHealthCheckSchema = z.object({
-  type: z.enum(['exec', 'http', 'tcp']),
-  // exec
-  cmd: z.string().optional(),
-  // http
-  path: z.string().optional(),
-  port: z.number().int().optional(),
-  method: z.enum(['GET', 'HEAD']).optional(),
-  expectedStatus: z.number().int().optional(),
-  // shared timing
-  intervalSeconds: z.number().int().optional(),
-  timeoutSeconds: z.number().int().optional(),
-  retries: z.number().int().optional(),
-  startPeriodSeconds: z.number().int().optional(),
-});
-export type FigStackHealthCheck = z.infer<typeof figStackHealthCheckSchema>;
-
-// ---------------------------------------------------------------------------
-// FigStackEntry
-// ---------------------------------------------------------------------------
-
-export const figStackEntrySchema = z.object({
-  name: z.string().min(1),
-  spec: z.union([z.record(z.unknown()), z.string()]),
-  ports: z.array(PortMappingSchema).optional(),
-  dependsOn: z.array(figStackDependencySchema).optional(),
-  healthCheck: figStackHealthCheckSchema.optional(),
-  env: z.record(z.string()).optional(),
-});
-export type FigStackEntry = z.infer<typeof figStackEntrySchema>;
-
-// ---------------------------------------------------------------------------
-// FigStackNetworkConfig
-// ---------------------------------------------------------------------------
-
-export const figStackNetworkConfigSchema = z.object({
-  name: z.string().optional(),
-  subnet: z.string().optional(),
-  external: z.string().optional(),
-});
-export type FigStackNetworkConfig = z.infer<typeof figStackNetworkConfigSchema>;
-
-// ---------------------------------------------------------------------------
-// FigStackVolumeDeclaration
-// ---------------------------------------------------------------------------
-
-export const figStackVolumeDeclarationSchema = z.object({
-  name: z.string().min(1),
-  external: z.boolean().optional(),
-});
-export type FigStackVolumeDeclaration = z.infer<typeof figStackVolumeDeclarationSchema>;
-
-// ---------------------------------------------------------------------------
-// FigStackEnvGroup
-// ---------------------------------------------------------------------------
-
-export const figStackEnvGroupSchema = z.object({
-  vars: z.record(z.string()),
-  inject: z.array(z.string()).optional(),
-});
-export type FigStackEnvGroup = z.infer<typeof figStackEnvGroupSchema>;
-
-// ---------------------------------------------------------------------------
-// FigStack (top-level)
-// ---------------------------------------------------------------------------
-
-export const figStackSchema = z.object({
-  schemaVersion: z.literal('1.0'),
-  stackName: z.string().min(1),
-  containers: z.array(figStackEntrySchema).min(1),
-  env: z.array(figStackEnvGroupSchema).optional(),
-  network: figStackNetworkConfigSchema.optional(),
-  volumes: z.array(figStackVolumeDeclarationSchema).optional(),
-});
-export type FigStack = z.infer<typeof figStackSchema>;

package/src/health.ts

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-
-export const HealthResponseSchema = z.object({
-  status: z.enum(['healthy', 'unhealthy']),
-  docker_api: z.string().optional(),
-  message: z.string().optional(),
-});
-export type HealthResponse = z.infer<typeof HealthResponseSchema>;

package/src/image.ts

@@ -1,55 +0,0 @@
-import { z } from 'zod';
-
-export const BuildImageRequestSchema = z.object({
-  spec: z.record(z.unknown()),
-  platform: z.string().optional(),
-  parser_script: z.string().optional(),
-  root_dir: z.string().optional(),
-});
-export type BuildImageRequest = z.infer<typeof BuildImageRequestSchema>;
-
-export const BuildImageResponseSchema = z.object({
-  image_tag: z.string().min(1),
-  hash: z.string().min(1),
-  cached: z.boolean(),
-  message: z.string().optional(),
-});
-export type BuildImageResponse = z.infer<typeof BuildImageResponseSchema>;
-
-export const PruneImagesRequestSchema = z.object({
-  retention_days: z.number().int().min(1).optional(),
-  all: z.boolean().optional(),
-});
-export type PruneImagesRequest = z.infer<typeof PruneImagesRequestSchema>;
-
-export const PruneImagesResponseSchema = z.object({
-  removed: z.number().int(),
-  bytes_freed: z.number().int(),
-  mb_freed: z.number(),
-  message: z.string(),
-  docker_images_pruned: z.number().int().optional(),
-  docker_bytes_freed: z.number().int().optional(),
-});
-export type PruneImagesResponse = z.infer<typeof PruneImagesResponseSchema>;
-
-export const PruneCacheResponseSchema = z.object({
-  freed_bytes: z.number().int(),
-});
-export type PruneCacheResponse = z.infer<typeof PruneCacheResponseSchema>;
-
-export const ExtractArtifactsRequestSchema = z.object({
-  container_id: z.string().min(1),
-  container_path: z.string().min(1),
-  host_path: z.string().min(1),
-});
-export type ExtractArtifactsRequest = z.infer<typeof ExtractArtifactsRequestSchema>;
-
-export const ExtractArtifactsResponseSchema = z.object({
-  container_id: z.string(),
-  container_path: z.string(),
-  host_path: z.string(),
-  files_count: z.number().int().optional(),
-  total_bytes: z.number().int().optional(),
-  message: z.string(),
-});
-export type ExtractArtifactsResponse = z.infer<typeof ExtractArtifactsResponseSchema>;

package/src/run-request.ts

@@ -1,55 +0,0 @@
-import { z } from 'zod';
-import {
-  JobStatusSchema,
-  ParsedOutputSchema,
-  ResourceLimitsSchema,
-  VolumeMountSchema,
-  NamedVolumeMountSchema,
-  PortMappingSchema,
-} from './shared.js';
-
-export const RunRequestSchema = z.object({
-  job_id: z.string().min(1),
-  image: z.string().min(1),
-  command: z.array(z.string()).optional(),
-  environment: z.record(z.string()).optional(),
-  volumes: z.array(VolumeMountSchema).optional(),
-  named_volumes: z.array(NamedVolumeMountSchema).optional(),
-  resources: ResourceLimitsSchema.optional(),
-  timeout: z.number().int().positive().max(86400).optional(),
-  parser_script: z.string().optional(),
-  root_dir: z.string().optional(),
-  env_files: z.array(z.string()).optional(),
-  secrets: z.record(z.string()).optional(),
-  extra_hosts: z.array(z.string()).optional(),
-  network_mode: z.string().optional(),
-  working_dir: z.string().optional(),
-  ports: z.array(PortMappingSchema).optional(),
-});
-export type RunRequest = z.infer<typeof RunRequestSchema>;
-
-export const RunResponseSchema = z.object({
-  job_id: z.string(),
-  status: JobStatusSchema,
-  message: z.string().optional(),
-  container_id: z.string().optional(),
-  exit_code: z.number().int().nullable().optional(),
-  stdout: z.string().optional(),
-  stderr: z.string().optional(),
-  parsed_output: ParsedOutputSchema.optional(),
-  started_at: z.string().datetime().optional(),
-  completed_at: z.string().datetime().optional(),
-  duration: z.number().optional(),
-  command: z.array(z.string()).optional(),
-  final_command: z.array(z.string()).optional(),
-});
-export type RunResponse = z.infer<typeof RunResponseSchema>;
-
-export const DryRunResponseSchema = z.object({
-  command: z.array(z.string()),
-  final_command: z.array(z.string()),
-  image: z.string(),
-  working_dir: z.string(),
-  volumes: z.array(VolumeMountSchema).optional(),
-});
-export type DryRunResponse = z.infer<typeof DryRunResponseSchema>;