dabke 0.78.0

package/CHANGELOG.md

@@ -0,0 +1,120 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+This changelog was generated from the git history of the project when it was
+named `scheduling-core`, prior to the rename to `dabke` in v0.78.0.
+
+## 0.78.0 (2026-02-07)
+
+- Rename package from `scheduling-core` to `dabke`
+
+## 0.77.0 (2026-02-02)
+
+### Breaking Changes
+
+- Replace singular `roleId` with `roleIds` array in coverage requirements
+- Enforce `roleIds`/`skillIds` requirement at compile time with discriminated union types
+
+## 0.76.0 (2026-02-01)
+
+- Add validation grouping with `groupKey` for meaningful summary reports
+- Add `summarizeValidation()` to aggregate validation items by source instruction
+
+## 0.75.0 (2026-01-29)
+
+- Add fair distribution of shifts across team members (`fairDistribution` option)
+- Track mandatory coverage constraints as passed validation items
+
+## 0.74.0 (2026-01-27)
+
+- Add `SchedulingPeriod` type for date range with day-of-week filtering
+- Enforce minimum 2 members in `assign-together` rule at the type level
+
+## 0.73.0 (2026-01-25)
+
+- Add schedule violation diagnostics with detailed error reporting
+- Add stable deterministic IDs to validation items
+- Fix: preserve scope when IDs don't match during rule resolution
+
+## 0.72.0 (2026-01-13)
+
+### Breaking Changes
+
+- Drop legacy solver and related rules API — CP-SAT is now the only solver path
+
+### Features
+
+- Add skill-based coverage requirements (`skillIds` on coverage)
+- Add interval variables, `NoOverlap` constraints, and bucketed coverage
+- Better role mapping strategy for multi-role team members
+- Inherit `weekStartsOn` from `ModelBuilder` in weekly rules
+
+## 0.71.0 (2026-01-11)
+
+- Fix coverage constraints to use time-indexed approach for accuracy
+- Make time horizon end date inclusive
+- Handle mandatory coverage priority correctly
+- Make role IDs optional on shift patterns (support role-agnostic shifts)
+- Support multiple role ID restrictions on `ShiftPattern`
+- Improve `ShiftPattern` type documentation and enforce non-empty `roleIds`
+
+## 0.70.0 (2026-01-10)
+
+### Features
+
+- Add CP-SAT compilation path via `ModelBuilder`
+- Add semantic time definitions (`defineSemanticTimes`) with day-specific variants
+- Type-safe coverage requirements using semantic time names
+
+## 0.69.0 (2026-01-09)
+
+- Initial setup for custom CP-SAT solver integration (replacing hosted OR-Tools)
+
+## 0.68.0 (2026-01-07)
+
+- Add comprehensive tests and API documentation
+
+## 0.67.0 (2025-11-23)
+
+- Improved rules system with better priority handling
+- Better prompt injection for LLM code generation
+- Time scope resolution for rules (date ranges, days of week, recurring periods)
+- Refactored coverage requirements
+
+## 0.66.0 (2025-11-05)
+
+- Refactor to visitor pattern for rule compilation
+- Improve LLM performance with better API documentation
+
+## 0.65.0 (2025-10-21)
+
+- Add rules: `max-hours-week`, `min-hours-week`, `max-consecutive-days`,
+  `min-consecutive-days`, `min-rest-between-shifts`, `assign-together`
+
+## 0.64.0 (2025-10-13)
+
+- Refactor date period splitting as shared utility
+- Fix dependency issues
+
+## 0.63.0 (2025-09-26)
+
+- Add `min-hours-day` rule
+- Make rule factory type-safe with `CpsatRuleRegistry`
+
+## 0.62.0 (2025-09-18)
+
+- Add auto-generated `llms.txt` API reference
+- Complete migration to modular architecture
+
+## 0.61.0 (2025-09-01)
+
+- Rename "time window" concept to "named period"
+
+## 0.60.0 (2025-08-28)
+
+- Initial release as `scheduling-core`
+- `ModelBuilder` for building constraint programming models
+- Built-in rules: `max-hours-day`, `max-shifts-day`, `time-off`, `employee-assignment-priority`, `location-preference`
+- `HttpSolverClient` for solver communication
+- Type-safe configuration with TypeScript

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Christian Klotz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# dabke
+
+Scheduling library powered by constraint programming (CP-SAT).
+
+Define your team, shifts, coverage, and rules — dabke turns them into an optimized schedule.
+
+## Features
+
+- **Declarative scheduling** — describe what you need, not how to solve it
+- **Built-in rules** — max hours, time off, rest periods, consecutive days, and more
+- **Semantic time** — define named time periods ("lunch", "closing") that resolve per day
+- **Soft & hard constraints** — priorities from `LOW` (preference) to `MANDATORY` (hard constraint)
+- **Scoped rules** — apply rules globally, per person, per role, or per skill
+- **Validation** — detailed error reporting with coverage gaps and rule violations
+- **LLM-friendly** — ships `llms.txt` with full API docs for AI code generation
+
+## Install
+
+```bash
+npm install dabke
+```
+
+## Quick Start
+
+```typescript
+import {
+  ModelBuilder,
+  HttpSolverClient,
+  parseSolverResponse,
+  resolveAssignments,
+} from "dabke";
+
+// Define team
+const employees = [
+  { id: "alice", roleIds: ["server"] },
+  { id: "bob", roleIds: ["server"] },
+  { id: "charlie", roleIds: ["chef"] },
+];
+
+// Define shift patterns
+const shiftPatterns = [
+  { id: "morning", startTime: { hours: 8 }, endTime: { hours: 16 } },
+  { id: "evening", startTime: { hours: 16 }, endTime: { hours: 23 } },
+];
+
+// Define coverage requirements
+const coverage = [
+  {
+    day: "2026-02-09",
+    startTime: { hours: 8 },
+    endTime: { hours: 16 },
+    roleIds: ["server"],
+    targetCount: 1,
+    priority: "MANDATORY" as const,
+  },
+  {
+    day: "2026-02-09",
+    startTime: { hours: 16 },
+    endTime: { hours: 23 },
+    roleIds: ["server"],
+    targetCount: 1,
+    priority: "MANDATORY" as const,
+  },
+];
+
+// Build the model
+const builder = new ModelBuilder({
+  employees,
+  shiftPatterns,
+  coverage,
+  schedulingPeriod: {
+    specificDates: ["2026-02-09"],
+  },
+  ruleConfigs: [
+    { name: "max-hours-day", config: { hours: 8, priority: "MANDATORY" } },
+    { name: "min-rest-between-shifts", config: { hours: 10, priority: "MANDATORY" } },
+  ],
+});
+
+const { request } = builder.compile();
+
+// Solve (requires a CP-SAT solver endpoint)
+const solver = new HttpSolverClient(fetch, "https://your-solver-endpoint");
+const response = await solver.solve(request);
+const result = parseSolverResponse(response);
+
+if (result.status === "OPTIMAL" || result.status === "FEASIBLE") {
+  const shifts = resolveAssignments(result.assignments, shiftPatterns);
+  for (const shift of shifts) {
+    console.log(
+      `${shift.employeeId}: ${shift.day} ${shift.startTime.hours}:00–${shift.endTime.hours}:00`
+    );
+  }
+}
+```
+
+## Semantic Time
+
+Define named time periods that can vary by day, then write coverage requirements in business terms:
+
+```typescript
+import { defineSemanticTimes } from "dabke";
+
+const times = defineSemanticTimes({
+  lunch: [
+    { startTime: { hours: 11, minutes: 30 }, endTime: { hours: 14 }, days: ["monday", "tuesday", "wednesday", "thursday", "friday"] },
+    { startTime: { hours: 12 }, endTime: { hours: 15 }, days: ["saturday", "sunday"] },
+  ],
+  closing: { startTime: { hours: 21 }, endTime: { hours: 23 } },
+});
+
+const coverage = times.coverage([
+  { semanticTime: "lunch", roleIds: ["server"], targetCount: 3, priority: "MANDATORY" },
+  { semanticTime: "closing", roleIds: ["server"], targetCount: 1, priority: "HIGH" },
+]);
+```
+
+## Built-in Rules
+
+| Rule | Description |
+|------|-------------|
+| `max-hours-day` | Max hours per person per day |
+| `max-hours-week` | Max hours per person per week |
+| `min-hours-day` | Min hours per person per day |
+| `min-hours-week` | Min hours per person per week |
+| `max-shifts-day` | Max shift assignments per day |
+| `max-consecutive-days` | Max consecutive working days |
+| `min-consecutive-days` | Min consecutive working days |
+| `min-rest-between-shifts` | Min rest hours between shifts |
+| `time-off` | Block assignments during periods |
+| `employee-assignment-priority` | Prefer or avoid assigning team members |
+| `assign-together` | Keep team members on the same shifts |
+| `location-preference` | Prefer team members at specific locations |
+
+All rules support scoping by person, role, skill, and time period (date ranges, days of week, recurring periods).
+
+## Validation
+
+dabke validates schedules and reports coverage gaps and rule violations:
+
+```typescript
+import { ValidationReporterImpl, summarizeValidation } from "dabke";
+
+const reporter = new ValidationReporterImpl();
+const builder = new ModelBuilder({ ...config, reporter });
+const { request, validation, canSolve } = builder.compile();
+
+// Pre-solve validation
+if (!canSolve) {
+  for (const error of validation.errors) {
+    console.error(error.reason);
+  }
+}
+
+// Post-solve validation (after solving)
+reporter.analyzeSolution(response);
+const results = reporter.getValidation();
+const summaries = summarizeValidation(results);
+
+for (const s of summaries) {
+  console.log(`${s.description}: ${s.status} (${s.passedCount}/${s.passedCount + s.violatedCount})`);
+}
+```
+
+## LLM Integration
+
+dabke ships an `llms.txt` file with complete API documentation, designed for AI code generation:
+
+```typescript
+import { apiDocs } from "dabke/llms";
+
+// Pass to your LLM as context for generating scheduling code
+```
+
+Or read the file directly:
+
+```bash
+cat node_modules/dabke/llms.txt
+```
+
+## Solver
+
+dabke compiles scheduling problems into a JSON-based constraint model. You need a CP-SAT solver service to solve it. The model format is compatible with Google OR-Tools CP-SAT solver.
+
+## License
+
+[MIT](LICENSE)

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+import { type FetcherLike, type SolverClient, type SolverRequest, type SolverResponse } from "./client.types.js";
+export type { SolverClient, SolverRequest, SolverResponse, SolverVariable, SolverConstraint, SolverTerm, SolverObjective, FetcherLike, } from "./client.types.js";
+/**
+ * Generic HTTP client for the solver service.
+ */
+export declare class HttpSolverClient implements SolverClient {
+    #private;
+    constructor(fetcher: FetcherLike, baseUrl?: string);
+    solve(request: SolverRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<SolverResponse>;
+    health(): Promise<void>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,YAAY,EACZ,aAAa,EACb,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,UAAU,EACV,eAAe,EACf,WAAW,GACZ,MAAM,mBAAmB,CAAC;AAS3B;;GAEG;AACH,qBAAa,gBAAiB,YAAW,YAAY;;gBAIvC,OAAO,EAAE,WAAW,EAAE,OAAO,GAAE,MAAgC;IAKrE,KAAK,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAqB1F,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ9B"}

package/dist/client.js

@@ -0,0 +1,42 @@
+const normalizeFetch = (fetcher) => {
+    if (typeof fetcher === "function")
+        return fetcher;
+    return fetcher.fetch.bind(fetcher);
+};
+/**
+ * Generic HTTP client for the solver service.
+ */
+export class HttpSolverClient {
+    #fetch;
+    #baseUrl;
+    constructor(fetcher, baseUrl = "http://localhost:8080") {
+        this.#fetch = normalizeFetch(fetcher);
+        this.#baseUrl = baseUrl.replace(/\/$/, "");
+    }
+    async solve(request, options) {
+        const res = await this.#fetch(`${this.#baseUrl}/solve`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+            signal: options?.signal,
+        });
+        const bodyText = await res.text();
+        if (!res.ok) {
+            const detail = bodyText ? `: ${bodyText}` : "";
+            throw new Error(`Solver returned ${res.status}${detail}`);
+        }
+        if (!bodyText) {
+            throw new Error("Solver returned an empty response");
+        }
+        return JSON.parse(bodyText);
+    }
+    async health() {
+        const res = await this.#fetch(`${this.#baseUrl}/health`);
+        if (!res.ok) {
+            const detail = await res.text().catch(() => "");
+            const suffix = detail ? `: ${detail}` : "";
+            throw new Error(`Solver health check failed with ${res.status}${suffix}`);
+        }
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAkBA,MAAM,cAAc,GAAG,CACrB,OAAoB,EAC8C,EAAE;IACpE,IAAI,OAAO,OAAO,KAAK,UAAU;QAAE,OAAO,OAAO,CAAC;IAClD,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACrC,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,OAAO,gBAAgB;IAC3B,MAAM,CAAiE;IACvE,QAAQ,CAAS;IAEjB,YAAY,OAAoB,EAAE,UAAkB,uBAAuB;QACzE,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC;QACtC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,OAAsB,EAAE,OAAkC;QACpE,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,QAAQ,EAAE;YACtD,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;YAC7B,MAAM,EAAE,OAAO,EAAE,MAAM;SACxB,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;QAClC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;YACZ,MAAM,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/C,MAAM,IAAI,KAAK,CAAC,mBAAmB,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;QAC5D,CAAC;QAED,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QAED,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAmB,CAAC;IAChD,CAAC;IAED,KAAK,CAAC,MAAM;QACV,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,SAAS,CAAC,CAAC;QACzD,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;YACZ,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;YAChD,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,KAAK,CAAC,mCAAmC,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;QAC5E,CAAC;IACH,CAAC;CACF"}

package/dist/client.schemas.d.ts

@@ -0,0 +1,250 @@
+/**
+ * Zod schemas for CP-SAT solver transport types.
+ *
+ * These schemas define the contract between scheduling clients and the solver service.
+ * TypeScript types are derived from these schemas using z.infer to ensure they stay in sync.
+ *
+ * @see client.types.ts for the derived TypeScript types
+ */
+import { z } from "zod";
+export declare const SolverTermSchema: z.ZodObject<{
+    var: z.ZodString;
+    coeff: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BoolVariableSchema: z.ZodObject<{
+    type: z.ZodLiteral<"bool">;
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const IntVariableSchema: z.ZodObject<{
+    type: z.ZodLiteral<"int">;
+    name: z.ZodString;
+    min: z.ZodNumber;
+    max: z.ZodNumber;
+}, z.core.$strip>;
+export declare const IntervalVariableSchema: z.ZodObject<{
+    type: z.ZodLiteral<"interval">;
+    name: z.ZodString;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    size: z.ZodNumber;
+    presenceVar: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SolverVariableSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"bool">;
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"int">;
+    name: z.ZodString;
+    min: z.ZodNumber;
+    max: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"interval">;
+    name: z.ZodString;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    size: z.ZodNumber;
+    presenceVar: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export declare const LinearConstraintSchema: z.ZodObject<{
+    type: z.ZodLiteral<"linear">;
+    terms: z.ZodArray<z.ZodObject<{
+        var: z.ZodString;
+        coeff: z.ZodNumber;
+    }, z.core.$strip>>;
+    op: z.ZodUnion<readonly [z.ZodLiteral<"<=">, z.ZodLiteral<">=">, z.ZodLiteral<"==">]>;
+    rhs: z.ZodNumber;
+}, z.core.$strip>;
+export declare const SoftLinearConstraintSchema: z.ZodObject<{
+    type: z.ZodLiteral<"soft_linear">;
+    terms: z.ZodArray<z.ZodObject<{
+        var: z.ZodString;
+        coeff: z.ZodNumber;
+    }, z.core.$strip>>;
+    op: z.ZodUnion<readonly [z.ZodLiteral<"<=">, z.ZodLiteral<">=">]>;
+    rhs: z.ZodNumber;
+    penalty: z.ZodNumber;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ExactlyOneConstraintSchema: z.ZodObject<{
+    type: z.ZodLiteral<"exactly_one">;
+    vars: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const AtMostOneConstraintSchema: z.ZodObject<{
+    type: z.ZodLiteral<"at_most_one">;
+    vars: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const ImplicationConstraintSchema: z.ZodObject<{
+    type: z.ZodLiteral<"implication">;
+    if: z.ZodString;
+    then: z.ZodString;
+}, z.core.$strip>;
+export declare const BoolOrConstraintSchema: z.ZodObject<{
+    type: z.ZodLiteral<"bool_or">;
+    vars: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const BoolAndConstraintSchema: z.ZodObject<{
+    type: z.ZodLiteral<"bool_and">;
+    vars: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const NoOverlapConstraintSchema: z.ZodObject<{
+    type: z.ZodLiteral<"no_overlap">;
+    intervals: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const SolverConstraintSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"linear">;
+    terms: z.ZodArray<z.ZodObject<{
+        var: z.ZodString;
+        coeff: z.ZodNumber;
+    }, z.core.$strip>>;
+    op: z.ZodUnion<readonly [z.ZodLiteral<"<=">, z.ZodLiteral<">=">, z.ZodLiteral<"==">]>;
+    rhs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"soft_linear">;
+    terms: z.ZodArray<z.ZodObject<{
+        var: z.ZodString;
+        coeff: z.ZodNumber;
+    }, z.core.$strip>>;
+    op: z.ZodUnion<readonly [z.ZodLiteral<"<=">, z.ZodLiteral<">=">]>;
+    rhs: z.ZodNumber;
+    penalty: z.ZodNumber;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"exactly_one">;
+    vars: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"at_most_one">;
+    vars: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"implication">;
+    if: z.ZodString;
+    then: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"bool_or">;
+    vars: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"bool_and">;
+    vars: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"no_overlap">;
+    intervals: z.ZodArray<z.ZodString>;
+}, z.core.$strip>]>;
+export declare const SolverObjectiveSchema: z.ZodObject<{
+    sense: z.ZodUnion<readonly [z.ZodLiteral<"minimize">, z.ZodLiteral<"maximize">]>;
+    terms: z.ZodArray<z.ZodObject<{
+        var: z.ZodString;
+        coeff: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SolverOptionsSchema: z.ZodObject<{
+    timeLimitSeconds: z.ZodOptional<z.ZodNumber>;
+    solutionLimit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const SolverRequestSchema: z.ZodObject<{
+    variables: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"bool">;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"int">;
+        name: z.ZodString;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        name: z.ZodString;
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+        size: z.ZodNumber;
+        presenceVar: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    constraints: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"linear">;
+        terms: z.ZodArray<z.ZodObject<{
+            var: z.ZodString;
+            coeff: z.ZodNumber;
+        }, z.core.$strip>>;
+        op: z.ZodUnion<readonly [z.ZodLiteral<"<=">, z.ZodLiteral<">=">, z.ZodLiteral<"==">]>;
+        rhs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"soft_linear">;
+        terms: z.ZodArray<z.ZodObject<{
+            var: z.ZodString;
+            coeff: z.ZodNumber;
+        }, z.core.$strip>>;
+        op: z.ZodUnion<readonly [z.ZodLiteral<"<=">, z.ZodLiteral<">=">]>;
+        rhs: z.ZodNumber;
+        penalty: z.ZodNumber;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"exactly_one">;
+        vars: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"at_most_one">;
+        vars: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"implication">;
+        if: z.ZodString;
+        then: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"bool_or">;
+        vars: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"bool_and">;
+        vars: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"no_overlap">;
+        intervals: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>]>>;
+    objective: z.ZodOptional<z.ZodObject<{
+        sense: z.ZodUnion<readonly [z.ZodLiteral<"minimize">, z.ZodLiteral<"maximize">]>;
+        terms: z.ZodArray<z.ZodObject<{
+            var: z.ZodString;
+            coeff: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    options: z.ZodOptional<z.ZodObject<{
+        timeLimitSeconds: z.ZodOptional<z.ZodNumber>;
+        solutionLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SolverStatusSchema: z.ZodEnum<{
+    OPTIMAL: "OPTIMAL";
+    FEASIBLE: "FEASIBLE";
+    INFEASIBLE: "INFEASIBLE";
+    TIMEOUT: "TIMEOUT";
+    ERROR: "ERROR";
+}>;
+export declare const SolverStatisticsSchema: z.ZodObject<{
+    solveTimeMs: z.ZodOptional<z.ZodNumber>;
+    conflicts: z.ZodOptional<z.ZodNumber>;
+    branches: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const SoftConstraintViolationSchema: z.ZodObject<{
+    constraintId: z.ZodString;
+    violationAmount: z.ZodNumber;
+    targetValue: z.ZodNumber;
+    actualValue: z.ZodNumber;
+}, z.core.$strip>;
+export declare const SolverResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        OPTIMAL: "OPTIMAL";
+        FEASIBLE: "FEASIBLE";
+        INFEASIBLE: "INFEASIBLE";
+        TIMEOUT: "TIMEOUT";
+        ERROR: "ERROR";
+    }>;
+    values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    statistics: z.ZodOptional<z.ZodObject<{
+        solveTimeMs: z.ZodOptional<z.ZodNumber>;
+        conflicts: z.ZodOptional<z.ZodNumber>;
+        branches: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+    solutionInfo: z.ZodOptional<z.ZodString>;
+    softViolations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        constraintId: z.ZodString;
+        violationAmount: z.ZodNumber;
+        targetValue: z.ZodNumber;
+        actualValue: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+//# sourceMappingURL=client.schemas.d.ts.map

package/dist/client.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.schemas.d.ts","sourceRoot":"","sources":["../src/client.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;iBAQjC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;mBAI/B,CAAC;AAMH,eAAO,MAAM,sBAAsB;;;;;;;;iBAKjC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;iBAOrC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;iBAKtC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBASjC,CAAC;AAMH,eAAO,MAAM,qBAAqB;;;;;;iBAGhC,CAAC;AAMH,eAAO,MAAM,mBAAmB;;;iBAG9B,CAAC;AAMH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK9B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;EAAoE,CAAC;AAEpG,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;iBAKxC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAO/B,CAAC"}