@elaraai/east-py-datascience 0.0.2-beta.8 → 0.0.2-beta.80

package/dist/src/google_or/google_or.d.ts

@@ -0,0 +1,2422 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Google OR-Tools optimization platform functions.
+ *
+ * Provides constraint programming (CP-SAT), vehicle routing, linear programming,
+ * and graph algorithms using Google OR-Tools.
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, ArrayType, DictType, IntegerType, BooleanType, FloatType, NullType, StringType } from "@elaraai/east";
+/**
+ * Solver status — shared across all OR-Tools solvers.
+ */
+export declare const GoogleOrStatusType: VariantType<{
+    readonly optimal: NullType;
+    readonly feasible: NullType;
+    readonly infeasible: NullType;
+    readonly not_solved: NullType;
+    readonly model_invalid: NullType;
+}>;
+/** Integer variable definition. */
+export declare const CpSatIntVarType: StructType<{
+    readonly name: StringType;
+    readonly lower_bound: IntegerType;
+    readonly upper_bound: IntegerType;
+}>;
+/** Boolean variable definition. */
+export declare const CpSatBoolVarType: StructType<{
+    readonly name: StringType;
+}>;
+/** Interval variable definition. */
+export declare const CpSatIntervalVarType: StructType<{
+    readonly name: StringType;
+    readonly start: StringType;
+    readonly size: StringType;
+    readonly end: StringType;
+    readonly is_present: OptionType<StringType>;
+}>;
+/** A term in a linear expression: coeff * var. */
+export declare const CpSatLinearTermType: StructType<{
+    readonly var: StringType;
+    readonly coeff: IntegerType;
+}>;
+/** A linear expression: sum(coeff_i * var_i) + constant. */
+export declare const CpSatLinearExprType: StructType<{
+    readonly terms: ArrayType<StructType<{
+        readonly var: StringType;
+        readonly coeff: IntegerType;
+    }>>;
+    readonly constant: IntegerType;
+}>;
+/** A boolean literal (possibly negated). */
+export declare const CpSatLiteralType: StructType<{
+    readonly var: StringType;
+    readonly negated: BooleanType;
+}>;
+/** Comparison operator for linear constraints. */
+export declare const CpSatComparisonType: VariantType<{
+    readonly equal: NullType;
+    readonly not_equal: NullType;
+    readonly less_equal: NullType;
+    readonly greater_equal: NullType;
+}>;
+/**
+ * CP-SAT constraint variant.
+ *
+ * Supports: linear, boolean logic, cardinality, combinatorial, scheduling, sequencing.
+ */
+export declare const CpSatConstraintType: VariantType<{
+    readonly linear: StructType<{
+        readonly expr: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: IntegerType;
+            }>>;
+            readonly constant: IntegerType;
+        }>;
+        readonly op: VariantType<{
+            readonly equal: NullType;
+            readonly not_equal: NullType;
+            readonly less_equal: NullType;
+            readonly greater_equal: NullType;
+        }>;
+        readonly rhs: IntegerType;
+    }>;
+    readonly bool_or: StructType<{
+        readonly literals: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly negated: BooleanType;
+        }>>;
+    }>;
+    readonly bool_and: StructType<{
+        readonly literals: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly negated: BooleanType;
+        }>>;
+    }>;
+    readonly implication: StructType<{
+        readonly if_literal: StructType<{
+            readonly var: StringType;
+            readonly negated: BooleanType;
+        }>;
+        readonly then_literal: StructType<{
+            readonly var: StringType;
+            readonly negated: BooleanType;
+        }>;
+    }>;
+    readonly exactly_k: StructType<{
+        readonly vars: ArrayType<StringType>;
+        readonly k: IntegerType;
+    }>;
+    readonly at_most_k: StructType<{
+        readonly vars: ArrayType<StringType>;
+        readonly k: IntegerType;
+    }>;
+    readonly at_least_k: StructType<{
+        readonly vars: ArrayType<StringType>;
+        readonly k: IntegerType;
+    }>;
+    readonly all_different: StructType<{
+        readonly vars: ArrayType<StringType>;
+    }>;
+    readonly element: StructType<{
+        readonly index_var: StringType;
+        readonly values: ArrayType<IntegerType>;
+        readonly target_var: StringType;
+    }>;
+    readonly no_overlap: StructType<{
+        readonly intervals: ArrayType<StringType>;
+    }>;
+    readonly cumulative: StructType<{
+        readonly intervals: ArrayType<StringType>;
+        readonly demands: ArrayType<IntegerType>;
+        readonly capacity: IntegerType;
+    }>;
+    readonly circuit: StructType<{
+        readonly arcs: ArrayType<StructType<{
+            readonly tail: IntegerType;
+            readonly head: IntegerType;
+            readonly literal: StringType;
+        }>>;
+    }>;
+}>;
+/** CP-SAT objective: minimize or maximize a linear expression. */
+export declare const CpSatObjectiveType: VariantType<{
+    readonly minimize: StructType<{
+        readonly terms: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly coeff: IntegerType;
+        }>>;
+        readonly constant: IntegerType;
+    }>;
+    readonly maximize: StructType<{
+        readonly terms: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly coeff: IntegerType;
+        }>>;
+        readonly constant: IntegerType;
+    }>;
+}>;
+/** Declarative CP-SAT model. */
+export declare const CpSatModelType: StructType<{
+    readonly int_vars: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly lower_bound: IntegerType;
+        readonly upper_bound: IntegerType;
+    }>>;
+    readonly bool_vars: ArrayType<StructType<{
+        readonly name: StringType;
+    }>>;
+    readonly interval_vars: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly start: StringType;
+        readonly size: StringType;
+        readonly end: StringType;
+        readonly is_present: OptionType<StringType>;
+    }>>;
+    readonly constraints: ArrayType<VariantType<{
+        readonly linear: StructType<{
+            readonly expr: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+            readonly op: VariantType<{
+                readonly equal: NullType;
+                readonly not_equal: NullType;
+                readonly less_equal: NullType;
+                readonly greater_equal: NullType;
+            }>;
+            readonly rhs: IntegerType;
+        }>;
+        readonly bool_or: StructType<{
+            readonly literals: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>>;
+        }>;
+        readonly bool_and: StructType<{
+            readonly literals: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>>;
+        }>;
+        readonly implication: StructType<{
+            readonly if_literal: StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>;
+            readonly then_literal: StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>;
+        }>;
+        readonly exactly_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly at_most_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly at_least_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly all_different: StructType<{
+            readonly vars: ArrayType<StringType>;
+        }>;
+        readonly element: StructType<{
+            readonly index_var: StringType;
+            readonly values: ArrayType<IntegerType>;
+            readonly target_var: StringType;
+        }>;
+        readonly no_overlap: StructType<{
+            readonly intervals: ArrayType<StringType>;
+        }>;
+        readonly cumulative: StructType<{
+            readonly intervals: ArrayType<StringType>;
+            readonly demands: ArrayType<IntegerType>;
+            readonly capacity: IntegerType;
+        }>;
+        readonly circuit: StructType<{
+            readonly arcs: ArrayType<StructType<{
+                readonly tail: IntegerType;
+                readonly head: IntegerType;
+                readonly literal: StringType;
+            }>>;
+        }>;
+    }>>;
+    readonly objective: OptionType<VariantType<{
+        readonly minimize: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: IntegerType;
+            }>>;
+            readonly constant: IntegerType;
+        }>;
+        readonly maximize: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: IntegerType;
+            }>>;
+            readonly constant: IntegerType;
+        }>;
+    }>>;
+}>;
+/** CP-SAT solver configuration. */
+export declare const CpSatConfigType: StructType<{
+    readonly max_time_seconds: OptionType<FloatType>;
+    readonly num_workers: OptionType<IntegerType>;
+    readonly log_search_progress: OptionType<BooleanType>;
+    readonly seed: OptionType<IntegerType>;
+    readonly max_solutions: OptionType<IntegerType>;
+}>;
+/** CP-SAT solution result. */
+export declare const CpSatResultType: StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly objective_value: OptionType<FloatType>;
+    readonly assignments: DictType<StringType, IntegerType>;
+    readonly wall_time: FloatType;
+}>;
+/** First solution strategy for routing. */
+export declare const RoutingFirstSolutionType: VariantType<{
+    readonly path_cheapest_arc: NullType;
+    readonly savings: NullType;
+    readonly christofides: NullType;
+    readonly parallel_cheapest_insertion: NullType;
+    readonly local_cheapest_insertion: NullType;
+    readonly first_unbound_min_value: NullType;
+}>;
+/** Local search metaheuristic for routing. */
+export declare const RoutingMetaheuristicType: VariantType<{
+    readonly greedy_descent: NullType;
+    readonly guided_local_search: NullType;
+    readonly simulated_annealing: NullType;
+    readonly tabu_search: NullType;
+}>;
+/** Time window constraint for a node. */
+export declare const RoutingTimeWindowType: StructType<{
+    readonly start: IntegerType;
+    readonly end: IntegerType;
+}>;
+/** Pickup-delivery pair. */
+export declare const RoutingPickupDeliveryType: StructType<{
+    readonly pickup: IntegerType;
+    readonly delivery: IntegerType;
+}>;
+/** Vehicle routing model. */
+export declare const RoutingModelType: StructType<{
+    readonly distance_matrix: ArrayType<ArrayType<IntegerType>>;
+    readonly num_vehicles: IntegerType;
+    readonly depot: IntegerType;
+    readonly demands: OptionType<ArrayType<IntegerType>>;
+    readonly vehicle_capacities: OptionType<ArrayType<IntegerType>>;
+    readonly time_matrix: OptionType<ArrayType<ArrayType<IntegerType>>>;
+    readonly time_windows: OptionType<ArrayType<StructType<{
+        readonly start: IntegerType;
+        readonly end: IntegerType;
+    }>>>;
+    readonly pickup_deliveries: OptionType<ArrayType<StructType<{
+        readonly pickup: IntegerType;
+        readonly delivery: IntegerType;
+    }>>>;
+}>;
+/** Routing solver configuration. */
+export declare const RoutingConfigType: StructType<{
+    readonly first_solution: OptionType<VariantType<{
+        readonly path_cheapest_arc: NullType;
+        readonly savings: NullType;
+        readonly christofides: NullType;
+        readonly parallel_cheapest_insertion: NullType;
+        readonly local_cheapest_insertion: NullType;
+        readonly first_unbound_min_value: NullType;
+    }>>;
+    readonly metaheuristic: OptionType<VariantType<{
+        readonly greedy_descent: NullType;
+        readonly guided_local_search: NullType;
+        readonly simulated_annealing: NullType;
+        readonly tabu_search: NullType;
+    }>>;
+    readonly max_time_seconds: OptionType<FloatType>;
+}>;
+/** A single vehicle route in the solution. */
+export declare const RoutingRouteType: StructType<{
+    readonly vehicle: IntegerType;
+    readonly nodes: ArrayType<IntegerType>;
+    readonly distance: IntegerType;
+}>;
+/** Vehicle routing result. */
+export declare const RoutingResultType: StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly total_distance: IntegerType;
+    readonly routes: ArrayType<StructType<{
+        readonly vehicle: IntegerType;
+        readonly nodes: ArrayType<IntegerType>;
+        readonly distance: IntegerType;
+    }>>;
+    readonly wall_time: FloatType;
+}>;
+/** LP/MIP variable definition. */
+export declare const LinearVarType: StructType<{
+    readonly name: StringType;
+    readonly lower_bound: FloatType;
+    readonly upper_bound: FloatType;
+    readonly is_integer: BooleanType;
+}>;
+/** A term in a linear expression: coeff * var. */
+export declare const LinearTermType: StructType<{
+    readonly var: StringType;
+    readonly coeff: FloatType;
+}>;
+/** Linear constraint: lower_bound <= sum(terms) <= upper_bound. */
+export declare const LinearConstraintDefType: StructType<{
+    readonly terms: ArrayType<StructType<{
+        readonly var: StringType;
+        readonly coeff: FloatType;
+    }>>;
+    readonly lower_bound: FloatType;
+    readonly upper_bound: FloatType;
+}>;
+/** Linear objective function. */
+export declare const LinearObjectiveType: StructType<{
+    readonly terms: ArrayType<StructType<{
+        readonly var: StringType;
+        readonly coeff: FloatType;
+    }>>;
+    readonly maximize: BooleanType;
+}>;
+/** Linear programming model. */
+export declare const LinearModelType: StructType<{
+    readonly variables: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly lower_bound: FloatType;
+        readonly upper_bound: FloatType;
+        readonly is_integer: BooleanType;
+    }>>;
+    readonly constraints: ArrayType<StructType<{
+        readonly terms: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly coeff: FloatType;
+        }>>;
+        readonly lower_bound: FloatType;
+        readonly upper_bound: FloatType;
+    }>>;
+    readonly objective: StructType<{
+        readonly terms: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly coeff: FloatType;
+        }>>;
+        readonly maximize: BooleanType;
+    }>;
+}>;
+/** LP solver backend. */
+export declare const LinearSolverType: VariantType<{
+    readonly glop: NullType;
+    readonly scip: NullType;
+    readonly highs: NullType;
+}>;
+/** LP solver configuration. */
+export declare const LinearConfigType: StructType<{
+    readonly solver: OptionType<VariantType<{
+        readonly glop: NullType;
+        readonly scip: NullType;
+        readonly highs: NullType;
+    }>>;
+    readonly max_time_seconds: OptionType<FloatType>;
+}>;
+/** LP/MIP result. */
+export declare const LinearResultType: StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly objective_value: OptionType<FloatType>;
+    readonly assignments: DictType<StringType, FloatType>;
+    readonly wall_time: FloatType;
+}>;
+/** Min-cost flow network input. */
+export declare const MinCostFlowInputType: StructType<{
+    readonly start_nodes: ArrayType<IntegerType>;
+    readonly end_nodes: ArrayType<IntegerType>;
+    readonly capacities: ArrayType<IntegerType>;
+    readonly unit_costs: ArrayType<IntegerType>;
+    readonly supplies: ArrayType<IntegerType>;
+}>;
+/** Min-cost flow result. */
+export declare const MinCostFlowResultType: StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly total_cost: IntegerType;
+    readonly flows: ArrayType<IntegerType>;
+    readonly wall_time: FloatType;
+}>;
+/** Max-flow network input. */
+export declare const MaxFlowInputType: StructType<{
+    readonly start_nodes: ArrayType<IntegerType>;
+    readonly end_nodes: ArrayType<IntegerType>;
+    readonly capacities: ArrayType<IntegerType>;
+    readonly source: IntegerType;
+    readonly sink: IntegerType;
+}>;
+/** Max-flow result. */
+export declare const MaxFlowResultType: StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly total_flow: IntegerType;
+    readonly flows: ArrayType<IntegerType>;
+    readonly wall_time: FloatType;
+}>;
+/** Linear sum assignment cost matrix. */
+export declare const AssignmentInputType: StructType<{
+    readonly costs: ArrayType<ArrayType<IntegerType>>;
+}>;
+/** A single worker-task assignment. */
+export declare const AssignmentMatchType: StructType<{
+    readonly worker: IntegerType;
+    readonly task: IntegerType;
+    readonly cost: IntegerType;
+}>;
+/** Assignment result. */
+export declare const AssignmentResultType: StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly total_cost: IntegerType;
+    readonly assignments: ArrayType<StructType<{
+        readonly worker: IntegerType;
+        readonly task: IntegerType;
+        readonly cost: IntegerType;
+    }>>;
+    readonly wall_time: FloatType;
+}>;
+/** Solve a CP-SAT model and return the best solution. */
+export declare const google_or_cpsat_solve: import("@elaraai/east").PlatformDefinition<[StructType<{
+    readonly int_vars: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly lower_bound: IntegerType;
+        readonly upper_bound: IntegerType;
+    }>>;
+    readonly bool_vars: ArrayType<StructType<{
+        readonly name: StringType;
+    }>>;
+    readonly interval_vars: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly start: StringType;
+        readonly size: StringType;
+        readonly end: StringType;
+        readonly is_present: OptionType<StringType>;
+    }>>;
+    readonly constraints: ArrayType<VariantType<{
+        readonly linear: StructType<{
+            readonly expr: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+            readonly op: VariantType<{
+                readonly equal: NullType;
+                readonly not_equal: NullType;
+                readonly less_equal: NullType;
+                readonly greater_equal: NullType;
+            }>;
+            readonly rhs: IntegerType;
+        }>;
+        readonly bool_or: StructType<{
+            readonly literals: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>>;
+        }>;
+        readonly bool_and: StructType<{
+            readonly literals: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>>;
+        }>;
+        readonly implication: StructType<{
+            readonly if_literal: StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>;
+            readonly then_literal: StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>;
+        }>;
+        readonly exactly_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly at_most_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly at_least_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly all_different: StructType<{
+            readonly vars: ArrayType<StringType>;
+        }>;
+        readonly element: StructType<{
+            readonly index_var: StringType;
+            readonly values: ArrayType<IntegerType>;
+            readonly target_var: StringType;
+        }>;
+        readonly no_overlap: StructType<{
+            readonly intervals: ArrayType<StringType>;
+        }>;
+        readonly cumulative: StructType<{
+            readonly intervals: ArrayType<StringType>;
+            readonly demands: ArrayType<IntegerType>;
+            readonly capacity: IntegerType;
+        }>;
+        readonly circuit: StructType<{
+            readonly arcs: ArrayType<StructType<{
+                readonly tail: IntegerType;
+                readonly head: IntegerType;
+                readonly literal: StringType;
+            }>>;
+        }>;
+    }>>;
+    readonly objective: OptionType<VariantType<{
+        readonly minimize: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: IntegerType;
+            }>>;
+            readonly constant: IntegerType;
+        }>;
+        readonly maximize: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: IntegerType;
+            }>>;
+            readonly constant: IntegerType;
+        }>;
+    }>>;
+}>, StructType<{
+    readonly max_time_seconds: OptionType<FloatType>;
+    readonly num_workers: OptionType<IntegerType>;
+    readonly log_search_progress: OptionType<BooleanType>;
+    readonly seed: OptionType<IntegerType>;
+    readonly max_solutions: OptionType<IntegerType>;
+}>], StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly objective_value: OptionType<FloatType>;
+    readonly assignments: DictType<StringType, IntegerType>;
+    readonly wall_time: FloatType;
+}>>;
+/** Solve a CP-SAT model and return all feasible solutions found. */
+export declare const google_or_cpsat_solve_all: import("@elaraai/east").PlatformDefinition<[StructType<{
+    readonly int_vars: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly lower_bound: IntegerType;
+        readonly upper_bound: IntegerType;
+    }>>;
+    readonly bool_vars: ArrayType<StructType<{
+        readonly name: StringType;
+    }>>;
+    readonly interval_vars: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly start: StringType;
+        readonly size: StringType;
+        readonly end: StringType;
+        readonly is_present: OptionType<StringType>;
+    }>>;
+    readonly constraints: ArrayType<VariantType<{
+        readonly linear: StructType<{
+            readonly expr: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+            readonly op: VariantType<{
+                readonly equal: NullType;
+                readonly not_equal: NullType;
+                readonly less_equal: NullType;
+                readonly greater_equal: NullType;
+            }>;
+            readonly rhs: IntegerType;
+        }>;
+        readonly bool_or: StructType<{
+            readonly literals: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>>;
+        }>;
+        readonly bool_and: StructType<{
+            readonly literals: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>>;
+        }>;
+        readonly implication: StructType<{
+            readonly if_literal: StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>;
+            readonly then_literal: StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>;
+        }>;
+        readonly exactly_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly at_most_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly at_least_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly all_different: StructType<{
+            readonly vars: ArrayType<StringType>;
+        }>;
+        readonly element: StructType<{
+            readonly index_var: StringType;
+            readonly values: ArrayType<IntegerType>;
+            readonly target_var: StringType;
+        }>;
+        readonly no_overlap: StructType<{
+            readonly intervals: ArrayType<StringType>;
+        }>;
+        readonly cumulative: StructType<{
+            readonly intervals: ArrayType<StringType>;
+            readonly demands: ArrayType<IntegerType>;
+            readonly capacity: IntegerType;
+        }>;
+        readonly circuit: StructType<{
+            readonly arcs: ArrayType<StructType<{
+                readonly tail: IntegerType;
+                readonly head: IntegerType;
+                readonly literal: StringType;
+            }>>;
+        }>;
+    }>>;
+    readonly objective: OptionType<VariantType<{
+        readonly minimize: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: IntegerType;
+            }>>;
+            readonly constant: IntegerType;
+        }>;
+        readonly maximize: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: IntegerType;
+            }>>;
+            readonly constant: IntegerType;
+        }>;
+    }>>;
+}>, StructType<{
+    readonly max_time_seconds: OptionType<FloatType>;
+    readonly num_workers: OptionType<IntegerType>;
+    readonly log_search_progress: OptionType<BooleanType>;
+    readonly seed: OptionType<IntegerType>;
+    readonly max_solutions: OptionType<IntegerType>;
+}>], ArrayType<StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly objective_value: OptionType<FloatType>;
+    readonly assignments: DictType<StringType, IntegerType>;
+    readonly wall_time: FloatType;
+}>>>;
+/** Solve a vehicle routing problem. */
+export declare const google_or_routing_solve: import("@elaraai/east").PlatformDefinition<[StructType<{
+    readonly distance_matrix: ArrayType<ArrayType<IntegerType>>;
+    readonly num_vehicles: IntegerType;
+    readonly depot: IntegerType;
+    readonly demands: OptionType<ArrayType<IntegerType>>;
+    readonly vehicle_capacities: OptionType<ArrayType<IntegerType>>;
+    readonly time_matrix: OptionType<ArrayType<ArrayType<IntegerType>>>;
+    readonly time_windows: OptionType<ArrayType<StructType<{
+        readonly start: IntegerType;
+        readonly end: IntegerType;
+    }>>>;
+    readonly pickup_deliveries: OptionType<ArrayType<StructType<{
+        readonly pickup: IntegerType;
+        readonly delivery: IntegerType;
+    }>>>;
+}>, StructType<{
+    readonly first_solution: OptionType<VariantType<{
+        readonly path_cheapest_arc: NullType;
+        readonly savings: NullType;
+        readonly christofides: NullType;
+        readonly parallel_cheapest_insertion: NullType;
+        readonly local_cheapest_insertion: NullType;
+        readonly first_unbound_min_value: NullType;
+    }>>;
+    readonly metaheuristic: OptionType<VariantType<{
+        readonly greedy_descent: NullType;
+        readonly guided_local_search: NullType;
+        readonly simulated_annealing: NullType;
+        readonly tabu_search: NullType;
+    }>>;
+    readonly max_time_seconds: OptionType<FloatType>;
+}>], StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly total_distance: IntegerType;
+    readonly routes: ArrayType<StructType<{
+        readonly vehicle: IntegerType;
+        readonly nodes: ArrayType<IntegerType>;
+        readonly distance: IntegerType;
+    }>>;
+    readonly wall_time: FloatType;
+}>>;
+/** Solve a linear programming / MIP problem. */
+export declare const google_or_linear_solve: import("@elaraai/east").PlatformDefinition<[StructType<{
+    readonly variables: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly lower_bound: FloatType;
+        readonly upper_bound: FloatType;
+        readonly is_integer: BooleanType;
+    }>>;
+    readonly constraints: ArrayType<StructType<{
+        readonly terms: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly coeff: FloatType;
+        }>>;
+        readonly lower_bound: FloatType;
+        readonly upper_bound: FloatType;
+    }>>;
+    readonly objective: StructType<{
+        readonly terms: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly coeff: FloatType;
+        }>>;
+        readonly maximize: BooleanType;
+    }>;
+}>, StructType<{
+    readonly solver: OptionType<VariantType<{
+        readonly glop: NullType;
+        readonly scip: NullType;
+        readonly highs: NullType;
+    }>>;
+    readonly max_time_seconds: OptionType<FloatType>;
+}>], StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly objective_value: OptionType<FloatType>;
+    readonly assignments: DictType<StringType, FloatType>;
+    readonly wall_time: FloatType;
+}>>;
+/** Solve a min-cost flow problem. */
+export declare const google_or_min_cost_flow: import("@elaraai/east").PlatformDefinition<[StructType<{
+    readonly start_nodes: ArrayType<IntegerType>;
+    readonly end_nodes: ArrayType<IntegerType>;
+    readonly capacities: ArrayType<IntegerType>;
+    readonly unit_costs: ArrayType<IntegerType>;
+    readonly supplies: ArrayType<IntegerType>;
+}>], StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly total_cost: IntegerType;
+    readonly flows: ArrayType<IntegerType>;
+    readonly wall_time: FloatType;
+}>>;
+/** Solve a max-flow problem. */
+export declare const google_or_max_flow: import("@elaraai/east").PlatformDefinition<[StructType<{
+    readonly start_nodes: ArrayType<IntegerType>;
+    readonly end_nodes: ArrayType<IntegerType>;
+    readonly capacities: ArrayType<IntegerType>;
+    readonly source: IntegerType;
+    readonly sink: IntegerType;
+}>], StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly total_flow: IntegerType;
+    readonly flows: ArrayType<IntegerType>;
+    readonly wall_time: FloatType;
+}>>;
+/** Solve a linear sum assignment problem. */
+export declare const google_or_assignment: import("@elaraai/east").PlatformDefinition<[StructType<{
+    readonly costs: ArrayType<ArrayType<IntegerType>>;
+}>], StructType<{
+    readonly status: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly total_cost: IntegerType;
+    readonly assignments: ArrayType<StructType<{
+        readonly worker: IntegerType;
+        readonly task: IntegerType;
+        readonly cost: IntegerType;
+    }>>;
+    readonly wall_time: FloatType;
+}>>;
+/** Type definitions for Google OR-Tools. */
+export declare const GoogleOrTypes: {
+    readonly StatusType: VariantType<{
+        readonly optimal: NullType;
+        readonly feasible: NullType;
+        readonly infeasible: NullType;
+        readonly not_solved: NullType;
+        readonly model_invalid: NullType;
+    }>;
+    readonly CpSatIntVarType: StructType<{
+        readonly name: StringType;
+        readonly lower_bound: IntegerType;
+        readonly upper_bound: IntegerType;
+    }>;
+    readonly CpSatBoolVarType: StructType<{
+        readonly name: StringType;
+    }>;
+    readonly CpSatIntervalVarType: StructType<{
+        readonly name: StringType;
+        readonly start: StringType;
+        readonly size: StringType;
+        readonly end: StringType;
+        readonly is_present: OptionType<StringType>;
+    }>;
+    readonly CpSatLinearTermType: StructType<{
+        readonly var: StringType;
+        readonly coeff: IntegerType;
+    }>;
+    readonly CpSatLinearExprType: StructType<{
+        readonly terms: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly coeff: IntegerType;
+        }>>;
+        readonly constant: IntegerType;
+    }>;
+    readonly CpSatLiteralType: StructType<{
+        readonly var: StringType;
+        readonly negated: BooleanType;
+    }>;
+    readonly CpSatComparisonType: VariantType<{
+        readonly equal: NullType;
+        readonly not_equal: NullType;
+        readonly less_equal: NullType;
+        readonly greater_equal: NullType;
+    }>;
+    readonly CpSatConstraintType: VariantType<{
+        readonly linear: StructType<{
+            readonly expr: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+            readonly op: VariantType<{
+                readonly equal: NullType;
+                readonly not_equal: NullType;
+                readonly less_equal: NullType;
+                readonly greater_equal: NullType;
+            }>;
+            readonly rhs: IntegerType;
+        }>;
+        readonly bool_or: StructType<{
+            readonly literals: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>>;
+        }>;
+        readonly bool_and: StructType<{
+            readonly literals: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>>;
+        }>;
+        readonly implication: StructType<{
+            readonly if_literal: StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>;
+            readonly then_literal: StructType<{
+                readonly var: StringType;
+                readonly negated: BooleanType;
+            }>;
+        }>;
+        readonly exactly_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly at_most_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly at_least_k: StructType<{
+            readonly vars: ArrayType<StringType>;
+            readonly k: IntegerType;
+        }>;
+        readonly all_different: StructType<{
+            readonly vars: ArrayType<StringType>;
+        }>;
+        readonly element: StructType<{
+            readonly index_var: StringType;
+            readonly values: ArrayType<IntegerType>;
+            readonly target_var: StringType;
+        }>;
+        readonly no_overlap: StructType<{
+            readonly intervals: ArrayType<StringType>;
+        }>;
+        readonly cumulative: StructType<{
+            readonly intervals: ArrayType<StringType>;
+            readonly demands: ArrayType<IntegerType>;
+            readonly capacity: IntegerType;
+        }>;
+        readonly circuit: StructType<{
+            readonly arcs: ArrayType<StructType<{
+                readonly tail: IntegerType;
+                readonly head: IntegerType;
+                readonly literal: StringType;
+            }>>;
+        }>;
+    }>;
+    readonly CpSatObjectiveType: VariantType<{
+        readonly minimize: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: IntegerType;
+            }>>;
+            readonly constant: IntegerType;
+        }>;
+        readonly maximize: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: IntegerType;
+            }>>;
+            readonly constant: IntegerType;
+        }>;
+    }>;
+    readonly CpSatModelType: StructType<{
+        readonly int_vars: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly lower_bound: IntegerType;
+            readonly upper_bound: IntegerType;
+        }>>;
+        readonly bool_vars: ArrayType<StructType<{
+            readonly name: StringType;
+        }>>;
+        readonly interval_vars: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly start: StringType;
+            readonly size: StringType;
+            readonly end: StringType;
+            readonly is_present: OptionType<StringType>;
+        }>>;
+        readonly constraints: ArrayType<VariantType<{
+            readonly linear: StructType<{
+                readonly expr: StructType<{
+                    readonly terms: ArrayType<StructType<{
+                        readonly var: StringType;
+                        readonly coeff: IntegerType;
+                    }>>;
+                    readonly constant: IntegerType;
+                }>;
+                readonly op: VariantType<{
+                    readonly equal: NullType;
+                    readonly not_equal: NullType;
+                    readonly less_equal: NullType;
+                    readonly greater_equal: NullType;
+                }>;
+                readonly rhs: IntegerType;
+            }>;
+            readonly bool_or: StructType<{
+                readonly literals: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>>;
+            }>;
+            readonly bool_and: StructType<{
+                readonly literals: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>>;
+            }>;
+            readonly implication: StructType<{
+                readonly if_literal: StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>;
+                readonly then_literal: StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>;
+            }>;
+            readonly exactly_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly at_most_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly at_least_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly all_different: StructType<{
+                readonly vars: ArrayType<StringType>;
+            }>;
+            readonly element: StructType<{
+                readonly index_var: StringType;
+                readonly values: ArrayType<IntegerType>;
+                readonly target_var: StringType;
+            }>;
+            readonly no_overlap: StructType<{
+                readonly intervals: ArrayType<StringType>;
+            }>;
+            readonly cumulative: StructType<{
+                readonly intervals: ArrayType<StringType>;
+                readonly demands: ArrayType<IntegerType>;
+                readonly capacity: IntegerType;
+            }>;
+            readonly circuit: StructType<{
+                readonly arcs: ArrayType<StructType<{
+                    readonly tail: IntegerType;
+                    readonly head: IntegerType;
+                    readonly literal: StringType;
+                }>>;
+            }>;
+        }>>;
+        readonly objective: OptionType<VariantType<{
+            readonly minimize: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+            readonly maximize: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+        }>>;
+    }>;
+    readonly CpSatConfigType: StructType<{
+        readonly max_time_seconds: OptionType<FloatType>;
+        readonly num_workers: OptionType<IntegerType>;
+        readonly log_search_progress: OptionType<BooleanType>;
+        readonly seed: OptionType<IntegerType>;
+        readonly max_solutions: OptionType<IntegerType>;
+    }>;
+    readonly CpSatResultType: StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly objective_value: OptionType<FloatType>;
+        readonly assignments: DictType<StringType, IntegerType>;
+        readonly wall_time: FloatType;
+    }>;
+    readonly RoutingFirstSolutionType: VariantType<{
+        readonly path_cheapest_arc: NullType;
+        readonly savings: NullType;
+        readonly christofides: NullType;
+        readonly parallel_cheapest_insertion: NullType;
+        readonly local_cheapest_insertion: NullType;
+        readonly first_unbound_min_value: NullType;
+    }>;
+    readonly RoutingMetaheuristicType: VariantType<{
+        readonly greedy_descent: NullType;
+        readonly guided_local_search: NullType;
+        readonly simulated_annealing: NullType;
+        readonly tabu_search: NullType;
+    }>;
+    readonly RoutingTimeWindowType: StructType<{
+        readonly start: IntegerType;
+        readonly end: IntegerType;
+    }>;
+    readonly RoutingPickupDeliveryType: StructType<{
+        readonly pickup: IntegerType;
+        readonly delivery: IntegerType;
+    }>;
+    readonly RoutingModelType: StructType<{
+        readonly distance_matrix: ArrayType<ArrayType<IntegerType>>;
+        readonly num_vehicles: IntegerType;
+        readonly depot: IntegerType;
+        readonly demands: OptionType<ArrayType<IntegerType>>;
+        readonly vehicle_capacities: OptionType<ArrayType<IntegerType>>;
+        readonly time_matrix: OptionType<ArrayType<ArrayType<IntegerType>>>;
+        readonly time_windows: OptionType<ArrayType<StructType<{
+            readonly start: IntegerType;
+            readonly end: IntegerType;
+        }>>>;
+        readonly pickup_deliveries: OptionType<ArrayType<StructType<{
+            readonly pickup: IntegerType;
+            readonly delivery: IntegerType;
+        }>>>;
+    }>;
+    readonly RoutingConfigType: StructType<{
+        readonly first_solution: OptionType<VariantType<{
+            readonly path_cheapest_arc: NullType;
+            readonly savings: NullType;
+            readonly christofides: NullType;
+            readonly parallel_cheapest_insertion: NullType;
+            readonly local_cheapest_insertion: NullType;
+            readonly first_unbound_min_value: NullType;
+        }>>;
+        readonly metaheuristic: OptionType<VariantType<{
+            readonly greedy_descent: NullType;
+            readonly guided_local_search: NullType;
+            readonly simulated_annealing: NullType;
+            readonly tabu_search: NullType;
+        }>>;
+        readonly max_time_seconds: OptionType<FloatType>;
+    }>;
+    readonly RoutingRouteType: StructType<{
+        readonly vehicle: IntegerType;
+        readonly nodes: ArrayType<IntegerType>;
+        readonly distance: IntegerType;
+    }>;
+    readonly RoutingResultType: StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly total_distance: IntegerType;
+        readonly routes: ArrayType<StructType<{
+            readonly vehicle: IntegerType;
+            readonly nodes: ArrayType<IntegerType>;
+            readonly distance: IntegerType;
+        }>>;
+        readonly wall_time: FloatType;
+    }>;
+    readonly LinearVarType: StructType<{
+        readonly name: StringType;
+        readonly lower_bound: FloatType;
+        readonly upper_bound: FloatType;
+        readonly is_integer: BooleanType;
+    }>;
+    readonly LinearTermType: StructType<{
+        readonly var: StringType;
+        readonly coeff: FloatType;
+    }>;
+    readonly LinearConstraintDefType: StructType<{
+        readonly terms: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly coeff: FloatType;
+        }>>;
+        readonly lower_bound: FloatType;
+        readonly upper_bound: FloatType;
+    }>;
+    readonly LinearObjectiveType: StructType<{
+        readonly terms: ArrayType<StructType<{
+            readonly var: StringType;
+            readonly coeff: FloatType;
+        }>>;
+        readonly maximize: BooleanType;
+    }>;
+    readonly LinearModelType: StructType<{
+        readonly variables: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly lower_bound: FloatType;
+            readonly upper_bound: FloatType;
+            readonly is_integer: BooleanType;
+        }>>;
+        readonly constraints: ArrayType<StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: FloatType;
+            }>>;
+            readonly lower_bound: FloatType;
+            readonly upper_bound: FloatType;
+        }>>;
+        readonly objective: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: FloatType;
+            }>>;
+            readonly maximize: BooleanType;
+        }>;
+    }>;
+    readonly LinearSolverType: VariantType<{
+        readonly glop: NullType;
+        readonly scip: NullType;
+        readonly highs: NullType;
+    }>;
+    readonly LinearConfigType: StructType<{
+        readonly solver: OptionType<VariantType<{
+            readonly glop: NullType;
+            readonly scip: NullType;
+            readonly highs: NullType;
+        }>>;
+        readonly max_time_seconds: OptionType<FloatType>;
+    }>;
+    readonly LinearResultType: StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly objective_value: OptionType<FloatType>;
+        readonly assignments: DictType<StringType, FloatType>;
+        readonly wall_time: FloatType;
+    }>;
+    readonly MinCostFlowInputType: StructType<{
+        readonly start_nodes: ArrayType<IntegerType>;
+        readonly end_nodes: ArrayType<IntegerType>;
+        readonly capacities: ArrayType<IntegerType>;
+        readonly unit_costs: ArrayType<IntegerType>;
+        readonly supplies: ArrayType<IntegerType>;
+    }>;
+    readonly MinCostFlowResultType: StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly total_cost: IntegerType;
+        readonly flows: ArrayType<IntegerType>;
+        readonly wall_time: FloatType;
+    }>;
+    readonly MaxFlowInputType: StructType<{
+        readonly start_nodes: ArrayType<IntegerType>;
+        readonly end_nodes: ArrayType<IntegerType>;
+        readonly capacities: ArrayType<IntegerType>;
+        readonly source: IntegerType;
+        readonly sink: IntegerType;
+    }>;
+    readonly MaxFlowResultType: StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly total_flow: IntegerType;
+        readonly flows: ArrayType<IntegerType>;
+        readonly wall_time: FloatType;
+    }>;
+    readonly AssignmentInputType: StructType<{
+        readonly costs: ArrayType<ArrayType<IntegerType>>;
+    }>;
+    readonly AssignmentMatchType: StructType<{
+        readonly worker: IntegerType;
+        readonly task: IntegerType;
+        readonly cost: IntegerType;
+    }>;
+    readonly AssignmentResultType: StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly total_cost: IntegerType;
+        readonly assignments: ArrayType<StructType<{
+            readonly worker: IntegerType;
+            readonly task: IntegerType;
+            readonly cost: IntegerType;
+        }>>;
+        readonly wall_time: FloatType;
+    }>;
+};
+/**
+ * Google OR-Tools optimization.
+ *
+ * Provides:
+ * - CP-SAT: Constraint programming with SAT-based solving
+ * - Routing: Vehicle routing (TSP, CVRP, VRPTW, VRPPD)
+ * - Linear: Linear programming and mixed-integer programming
+ * - Graph: Min-cost flow, max flow, linear sum assignment
+ */
+export declare const GoogleOr: {
+    /**
+     * Solve a CP-SAT model and return the best solution.
+     *
+     * @example
+     * ```ts
+     * import { East, variant } from "@elaraai/east";
+     * import { GoogleOr, CpSatModelType, CpSatConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const solve = East.function(
+     *     [CpSatModelType],
+     *     GoogleOr.Types.CpSatResultType,
+     *     ($, model) => {
+     *         const config = $.let({
+     *             max_time_seconds: variant("some", 10.0),
+     *             num_workers: variant("none", null),
+     *             log_search_progress: variant("none", null),
+     *             seed: variant("none", null),
+     *             max_solutions: variant("none", null),
+     *         }, CpSatConfigType);
+     *         return $.return(GoogleOr.cpsatSolve(model, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly cpsatSolve: import("@elaraai/east").PlatformDefinition<[StructType<{
+        readonly int_vars: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly lower_bound: IntegerType;
+            readonly upper_bound: IntegerType;
+        }>>;
+        readonly bool_vars: ArrayType<StructType<{
+            readonly name: StringType;
+        }>>;
+        readonly interval_vars: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly start: StringType;
+            readonly size: StringType;
+            readonly end: StringType;
+            readonly is_present: OptionType<StringType>;
+        }>>;
+        readonly constraints: ArrayType<VariantType<{
+            readonly linear: StructType<{
+                readonly expr: StructType<{
+                    readonly terms: ArrayType<StructType<{
+                        readonly var: StringType;
+                        readonly coeff: IntegerType;
+                    }>>;
+                    readonly constant: IntegerType;
+                }>;
+                readonly op: VariantType<{
+                    readonly equal: NullType;
+                    readonly not_equal: NullType;
+                    readonly less_equal: NullType;
+                    readonly greater_equal: NullType;
+                }>;
+                readonly rhs: IntegerType;
+            }>;
+            readonly bool_or: StructType<{
+                readonly literals: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>>;
+            }>;
+            readonly bool_and: StructType<{
+                readonly literals: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>>;
+            }>;
+            readonly implication: StructType<{
+                readonly if_literal: StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>;
+                readonly then_literal: StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>;
+            }>;
+            readonly exactly_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly at_most_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly at_least_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly all_different: StructType<{
+                readonly vars: ArrayType<StringType>;
+            }>;
+            readonly element: StructType<{
+                readonly index_var: StringType;
+                readonly values: ArrayType<IntegerType>;
+                readonly target_var: StringType;
+            }>;
+            readonly no_overlap: StructType<{
+                readonly intervals: ArrayType<StringType>;
+            }>;
+            readonly cumulative: StructType<{
+                readonly intervals: ArrayType<StringType>;
+                readonly demands: ArrayType<IntegerType>;
+                readonly capacity: IntegerType;
+            }>;
+            readonly circuit: StructType<{
+                readonly arcs: ArrayType<StructType<{
+                    readonly tail: IntegerType;
+                    readonly head: IntegerType;
+                    readonly literal: StringType;
+                }>>;
+            }>;
+        }>>;
+        readonly objective: OptionType<VariantType<{
+            readonly minimize: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+            readonly maximize: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+        }>>;
+    }>, StructType<{
+        readonly max_time_seconds: OptionType<FloatType>;
+        readonly num_workers: OptionType<IntegerType>;
+        readonly log_search_progress: OptionType<BooleanType>;
+        readonly seed: OptionType<IntegerType>;
+        readonly max_solutions: OptionType<IntegerType>;
+    }>], StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly objective_value: OptionType<FloatType>;
+        readonly assignments: DictType<StringType, IntegerType>;
+        readonly wall_time: FloatType;
+    }>>;
+    /**
+     * Solve a CP-SAT model and return all feasible solutions found.
+     *
+     * @example
+     * ```ts
+     * import { East, ArrayType, variant } from "@elaraai/east";
+     * import { GoogleOr, CpSatModelType, CpSatConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const solveAll = East.function(
+     *     [CpSatModelType],
+     *     ArrayType(GoogleOr.Types.CpSatResultType),
+     *     ($, model) => {
+     *         const config = $.let({
+     *             max_time_seconds: variant("some", 10.0),
+     *             num_workers: variant("none", null),
+     *             log_search_progress: variant("none", null),
+     *             seed: variant("none", null),
+     *             max_solutions: variant("some", 100n),
+     *         }, CpSatConfigType);
+     *         return $.return(GoogleOr.cpsatSolveAll(model, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly cpsatSolveAll: import("@elaraai/east").PlatformDefinition<[StructType<{
+        readonly int_vars: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly lower_bound: IntegerType;
+            readonly upper_bound: IntegerType;
+        }>>;
+        readonly bool_vars: ArrayType<StructType<{
+            readonly name: StringType;
+        }>>;
+        readonly interval_vars: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly start: StringType;
+            readonly size: StringType;
+            readonly end: StringType;
+            readonly is_present: OptionType<StringType>;
+        }>>;
+        readonly constraints: ArrayType<VariantType<{
+            readonly linear: StructType<{
+                readonly expr: StructType<{
+                    readonly terms: ArrayType<StructType<{
+                        readonly var: StringType;
+                        readonly coeff: IntegerType;
+                    }>>;
+                    readonly constant: IntegerType;
+                }>;
+                readonly op: VariantType<{
+                    readonly equal: NullType;
+                    readonly not_equal: NullType;
+                    readonly less_equal: NullType;
+                    readonly greater_equal: NullType;
+                }>;
+                readonly rhs: IntegerType;
+            }>;
+            readonly bool_or: StructType<{
+                readonly literals: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>>;
+            }>;
+            readonly bool_and: StructType<{
+                readonly literals: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>>;
+            }>;
+            readonly implication: StructType<{
+                readonly if_literal: StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>;
+                readonly then_literal: StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>;
+            }>;
+            readonly exactly_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly at_most_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly at_least_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly all_different: StructType<{
+                readonly vars: ArrayType<StringType>;
+            }>;
+            readonly element: StructType<{
+                readonly index_var: StringType;
+                readonly values: ArrayType<IntegerType>;
+                readonly target_var: StringType;
+            }>;
+            readonly no_overlap: StructType<{
+                readonly intervals: ArrayType<StringType>;
+            }>;
+            readonly cumulative: StructType<{
+                readonly intervals: ArrayType<StringType>;
+                readonly demands: ArrayType<IntegerType>;
+                readonly capacity: IntegerType;
+            }>;
+            readonly circuit: StructType<{
+                readonly arcs: ArrayType<StructType<{
+                    readonly tail: IntegerType;
+                    readonly head: IntegerType;
+                    readonly literal: StringType;
+                }>>;
+            }>;
+        }>>;
+        readonly objective: OptionType<VariantType<{
+            readonly minimize: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+            readonly maximize: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+        }>>;
+    }>, StructType<{
+        readonly max_time_seconds: OptionType<FloatType>;
+        readonly num_workers: OptionType<IntegerType>;
+        readonly log_search_progress: OptionType<BooleanType>;
+        readonly seed: OptionType<IntegerType>;
+        readonly max_solutions: OptionType<IntegerType>;
+    }>], ArrayType<StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly objective_value: OptionType<FloatType>;
+        readonly assignments: DictType<StringType, IntegerType>;
+        readonly wall_time: FloatType;
+    }>>>;
+    /**
+     * Solve a vehicle routing problem.
+     *
+     * @example
+     * ```ts
+     * import { East, variant } from "@elaraai/east";
+     * import { GoogleOr, RoutingModelType, RoutingConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const solve = East.function(
+     *     [RoutingModelType],
+     *     GoogleOr.Types.RoutingResultType,
+     *     ($, model) => {
+     *         const config = $.let({
+     *             first_solution: variant("some", variant("path_cheapest_arc", null)),
+     *             metaheuristic: variant("some", variant("guided_local_search", null)),
+     *             max_time_seconds: variant("some", 30.0),
+     *         }, RoutingConfigType);
+     *         return $.return(GoogleOr.routingSolve(model, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly routingSolve: import("@elaraai/east").PlatformDefinition<[StructType<{
+        readonly distance_matrix: ArrayType<ArrayType<IntegerType>>;
+        readonly num_vehicles: IntegerType;
+        readonly depot: IntegerType;
+        readonly demands: OptionType<ArrayType<IntegerType>>;
+        readonly vehicle_capacities: OptionType<ArrayType<IntegerType>>;
+        readonly time_matrix: OptionType<ArrayType<ArrayType<IntegerType>>>;
+        readonly time_windows: OptionType<ArrayType<StructType<{
+            readonly start: IntegerType;
+            readonly end: IntegerType;
+        }>>>;
+        readonly pickup_deliveries: OptionType<ArrayType<StructType<{
+            readonly pickup: IntegerType;
+            readonly delivery: IntegerType;
+        }>>>;
+    }>, StructType<{
+        readonly first_solution: OptionType<VariantType<{
+            readonly path_cheapest_arc: NullType;
+            readonly savings: NullType;
+            readonly christofides: NullType;
+            readonly parallel_cheapest_insertion: NullType;
+            readonly local_cheapest_insertion: NullType;
+            readonly first_unbound_min_value: NullType;
+        }>>;
+        readonly metaheuristic: OptionType<VariantType<{
+            readonly greedy_descent: NullType;
+            readonly guided_local_search: NullType;
+            readonly simulated_annealing: NullType;
+            readonly tabu_search: NullType;
+        }>>;
+        readonly max_time_seconds: OptionType<FloatType>;
+    }>], StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly total_distance: IntegerType;
+        readonly routes: ArrayType<StructType<{
+            readonly vehicle: IntegerType;
+            readonly nodes: ArrayType<IntegerType>;
+            readonly distance: IntegerType;
+        }>>;
+        readonly wall_time: FloatType;
+    }>>;
+    /**
+     * Solve a linear programming / MIP problem.
+     *
+     * @example
+     * ```ts
+     * import { East, variant } from "@elaraai/east";
+     * import { GoogleOr, LinearModelType, LinearConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const solve = East.function(
+     *     [LinearModelType],
+     *     GoogleOr.Types.LinearResultType,
+     *     ($, model) => {
+     *         const config = $.let({
+     *             solver: variant("some", variant("highs", null)),
+     *             max_time_seconds: variant("some", 60.0),
+     *         }, LinearConfigType);
+     *         return $.return(GoogleOr.linearSolve(model, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly linearSolve: import("@elaraai/east").PlatformDefinition<[StructType<{
+        readonly variables: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly lower_bound: FloatType;
+            readonly upper_bound: FloatType;
+            readonly is_integer: BooleanType;
+        }>>;
+        readonly constraints: ArrayType<StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: FloatType;
+            }>>;
+            readonly lower_bound: FloatType;
+            readonly upper_bound: FloatType;
+        }>>;
+        readonly objective: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: FloatType;
+            }>>;
+            readonly maximize: BooleanType;
+        }>;
+    }>, StructType<{
+        readonly solver: OptionType<VariantType<{
+            readonly glop: NullType;
+            readonly scip: NullType;
+            readonly highs: NullType;
+        }>>;
+        readonly max_time_seconds: OptionType<FloatType>;
+    }>], StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly objective_value: OptionType<FloatType>;
+        readonly assignments: DictType<StringType, FloatType>;
+        readonly wall_time: FloatType;
+    }>>;
+    /**
+     * Solve a min-cost flow problem.
+     *
+     * @example
+     * ```ts
+     * import { East } from "@elaraai/east";
+     * import { GoogleOr, MinCostFlowInputType } from "@elaraai/east-py-datascience";
+     *
+     * const solve = East.function(
+     *     [MinCostFlowInputType],
+     *     GoogleOr.Types.MinCostFlowResultType,
+     *     ($, input) => {
+     *         return $.return(GoogleOr.minCostFlow(input));
+     *     }
+     * );
+     * ```
+     */
+    readonly minCostFlow: import("@elaraai/east").PlatformDefinition<[StructType<{
+        readonly start_nodes: ArrayType<IntegerType>;
+        readonly end_nodes: ArrayType<IntegerType>;
+        readonly capacities: ArrayType<IntegerType>;
+        readonly unit_costs: ArrayType<IntegerType>;
+        readonly supplies: ArrayType<IntegerType>;
+    }>], StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly total_cost: IntegerType;
+        readonly flows: ArrayType<IntegerType>;
+        readonly wall_time: FloatType;
+    }>>;
+    /**
+     * Solve a max-flow problem.
+     *
+     * @example
+     * ```ts
+     * import { East } from "@elaraai/east";
+     * import { GoogleOr, MaxFlowInputType } from "@elaraai/east-py-datascience";
+     *
+     * const solve = East.function(
+     *     [MaxFlowInputType],
+     *     GoogleOr.Types.MaxFlowResultType,
+     *     ($, input) => {
+     *         return $.return(GoogleOr.maxFlow(input));
+     *     }
+     * );
+     * ```
+     */
+    readonly maxFlow: import("@elaraai/east").PlatformDefinition<[StructType<{
+        readonly start_nodes: ArrayType<IntegerType>;
+        readonly end_nodes: ArrayType<IntegerType>;
+        readonly capacities: ArrayType<IntegerType>;
+        readonly source: IntegerType;
+        readonly sink: IntegerType;
+    }>], StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly total_flow: IntegerType;
+        readonly flows: ArrayType<IntegerType>;
+        readonly wall_time: FloatType;
+    }>>;
+    /**
+     * Solve a linear sum assignment problem.
+     *
+     * @example
+     * ```ts
+     * import { East } from "@elaraai/east";
+     * import { GoogleOr, AssignmentInputType } from "@elaraai/east-py-datascience";
+     *
+     * const solve = East.function(
+     *     [AssignmentInputType],
+     *     GoogleOr.Types.AssignmentResultType,
+     *     ($, input) => {
+     *         return $.return(GoogleOr.assignment(input));
+     *     }
+     * );
+     * ```
+     */
+    readonly assignment: import("@elaraai/east").PlatformDefinition<[StructType<{
+        readonly costs: ArrayType<ArrayType<IntegerType>>;
+    }>], StructType<{
+        readonly status: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly total_cost: IntegerType;
+        readonly assignments: ArrayType<StructType<{
+            readonly worker: IntegerType;
+            readonly task: IntegerType;
+            readonly cost: IntegerType;
+        }>>;
+        readonly wall_time: FloatType;
+    }>>;
+    /** Type definitions. */
+    readonly Types: {
+        readonly StatusType: VariantType<{
+            readonly optimal: NullType;
+            readonly feasible: NullType;
+            readonly infeasible: NullType;
+            readonly not_solved: NullType;
+            readonly model_invalid: NullType;
+        }>;
+        readonly CpSatIntVarType: StructType<{
+            readonly name: StringType;
+            readonly lower_bound: IntegerType;
+            readonly upper_bound: IntegerType;
+        }>;
+        readonly CpSatBoolVarType: StructType<{
+            readonly name: StringType;
+        }>;
+        readonly CpSatIntervalVarType: StructType<{
+            readonly name: StringType;
+            readonly start: StringType;
+            readonly size: StringType;
+            readonly end: StringType;
+            readonly is_present: OptionType<StringType>;
+        }>;
+        readonly CpSatLinearTermType: StructType<{
+            readonly var: StringType;
+            readonly coeff: IntegerType;
+        }>;
+        readonly CpSatLinearExprType: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: IntegerType;
+            }>>;
+            readonly constant: IntegerType;
+        }>;
+        readonly CpSatLiteralType: StructType<{
+            readonly var: StringType;
+            readonly negated: BooleanType;
+        }>;
+        readonly CpSatComparisonType: VariantType<{
+            readonly equal: NullType;
+            readonly not_equal: NullType;
+            readonly less_equal: NullType;
+            readonly greater_equal: NullType;
+        }>;
+        readonly CpSatConstraintType: VariantType<{
+            readonly linear: StructType<{
+                readonly expr: StructType<{
+                    readonly terms: ArrayType<StructType<{
+                        readonly var: StringType;
+                        readonly coeff: IntegerType;
+                    }>>;
+                    readonly constant: IntegerType;
+                }>;
+                readonly op: VariantType<{
+                    readonly equal: NullType;
+                    readonly not_equal: NullType;
+                    readonly less_equal: NullType;
+                    readonly greater_equal: NullType;
+                }>;
+                readonly rhs: IntegerType;
+            }>;
+            readonly bool_or: StructType<{
+                readonly literals: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>>;
+            }>;
+            readonly bool_and: StructType<{
+                readonly literals: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>>;
+            }>;
+            readonly implication: StructType<{
+                readonly if_literal: StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>;
+                readonly then_literal: StructType<{
+                    readonly var: StringType;
+                    readonly negated: BooleanType;
+                }>;
+            }>;
+            readonly exactly_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly at_most_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly at_least_k: StructType<{
+                readonly vars: ArrayType<StringType>;
+                readonly k: IntegerType;
+            }>;
+            readonly all_different: StructType<{
+                readonly vars: ArrayType<StringType>;
+            }>;
+            readonly element: StructType<{
+                readonly index_var: StringType;
+                readonly values: ArrayType<IntegerType>;
+                readonly target_var: StringType;
+            }>;
+            readonly no_overlap: StructType<{
+                readonly intervals: ArrayType<StringType>;
+            }>;
+            readonly cumulative: StructType<{
+                readonly intervals: ArrayType<StringType>;
+                readonly demands: ArrayType<IntegerType>;
+                readonly capacity: IntegerType;
+            }>;
+            readonly circuit: StructType<{
+                readonly arcs: ArrayType<StructType<{
+                    readonly tail: IntegerType;
+                    readonly head: IntegerType;
+                    readonly literal: StringType;
+                }>>;
+            }>;
+        }>;
+        readonly CpSatObjectiveType: VariantType<{
+            readonly minimize: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+            readonly maximize: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: IntegerType;
+                }>>;
+                readonly constant: IntegerType;
+            }>;
+        }>;
+        readonly CpSatModelType: StructType<{
+            readonly int_vars: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly lower_bound: IntegerType;
+                readonly upper_bound: IntegerType;
+            }>>;
+            readonly bool_vars: ArrayType<StructType<{
+                readonly name: StringType;
+            }>>;
+            readonly interval_vars: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly start: StringType;
+                readonly size: StringType;
+                readonly end: StringType;
+                readonly is_present: OptionType<StringType>;
+            }>>;
+            readonly constraints: ArrayType<VariantType<{
+                readonly linear: StructType<{
+                    readonly expr: StructType<{
+                        readonly terms: ArrayType<StructType<{
+                            readonly var: StringType;
+                            readonly coeff: IntegerType;
+                        }>>;
+                        readonly constant: IntegerType;
+                    }>;
+                    readonly op: VariantType<{
+                        readonly equal: NullType;
+                        readonly not_equal: NullType;
+                        readonly less_equal: NullType;
+                        readonly greater_equal: NullType;
+                    }>;
+                    readonly rhs: IntegerType;
+                }>;
+                readonly bool_or: StructType<{
+                    readonly literals: ArrayType<StructType<{
+                        readonly var: StringType;
+                        readonly negated: BooleanType;
+                    }>>;
+                }>;
+                readonly bool_and: StructType<{
+                    readonly literals: ArrayType<StructType<{
+                        readonly var: StringType;
+                        readonly negated: BooleanType;
+                    }>>;
+                }>;
+                readonly implication: StructType<{
+                    readonly if_literal: StructType<{
+                        readonly var: StringType;
+                        readonly negated: BooleanType;
+                    }>;
+                    readonly then_literal: StructType<{
+                        readonly var: StringType;
+                        readonly negated: BooleanType;
+                    }>;
+                }>;
+                readonly exactly_k: StructType<{
+                    readonly vars: ArrayType<StringType>;
+                    readonly k: IntegerType;
+                }>;
+                readonly at_most_k: StructType<{
+                    readonly vars: ArrayType<StringType>;
+                    readonly k: IntegerType;
+                }>;
+                readonly at_least_k: StructType<{
+                    readonly vars: ArrayType<StringType>;
+                    readonly k: IntegerType;
+                }>;
+                readonly all_different: StructType<{
+                    readonly vars: ArrayType<StringType>;
+                }>;
+                readonly element: StructType<{
+                    readonly index_var: StringType;
+                    readonly values: ArrayType<IntegerType>;
+                    readonly target_var: StringType;
+                }>;
+                readonly no_overlap: StructType<{
+                    readonly intervals: ArrayType<StringType>;
+                }>;
+                readonly cumulative: StructType<{
+                    readonly intervals: ArrayType<StringType>;
+                    readonly demands: ArrayType<IntegerType>;
+                    readonly capacity: IntegerType;
+                }>;
+                readonly circuit: StructType<{
+                    readonly arcs: ArrayType<StructType<{
+                        readonly tail: IntegerType;
+                        readonly head: IntegerType;
+                        readonly literal: StringType;
+                    }>>;
+                }>;
+            }>>;
+            readonly objective: OptionType<VariantType<{
+                readonly minimize: StructType<{
+                    readonly terms: ArrayType<StructType<{
+                        readonly var: StringType;
+                        readonly coeff: IntegerType;
+                    }>>;
+                    readonly constant: IntegerType;
+                }>;
+                readonly maximize: StructType<{
+                    readonly terms: ArrayType<StructType<{
+                        readonly var: StringType;
+                        readonly coeff: IntegerType;
+                    }>>;
+                    readonly constant: IntegerType;
+                }>;
+            }>>;
+        }>;
+        readonly CpSatConfigType: StructType<{
+            readonly max_time_seconds: OptionType<FloatType>;
+            readonly num_workers: OptionType<IntegerType>;
+            readonly log_search_progress: OptionType<BooleanType>;
+            readonly seed: OptionType<IntegerType>;
+            readonly max_solutions: OptionType<IntegerType>;
+        }>;
+        readonly CpSatResultType: StructType<{
+            readonly status: VariantType<{
+                readonly optimal: NullType;
+                readonly feasible: NullType;
+                readonly infeasible: NullType;
+                readonly not_solved: NullType;
+                readonly model_invalid: NullType;
+            }>;
+            readonly objective_value: OptionType<FloatType>;
+            readonly assignments: DictType<StringType, IntegerType>;
+            readonly wall_time: FloatType;
+        }>;
+        readonly RoutingFirstSolutionType: VariantType<{
+            readonly path_cheapest_arc: NullType;
+            readonly savings: NullType;
+            readonly christofides: NullType;
+            readonly parallel_cheapest_insertion: NullType;
+            readonly local_cheapest_insertion: NullType;
+            readonly first_unbound_min_value: NullType;
+        }>;
+        readonly RoutingMetaheuristicType: VariantType<{
+            readonly greedy_descent: NullType;
+            readonly guided_local_search: NullType;
+            readonly simulated_annealing: NullType;
+            readonly tabu_search: NullType;
+        }>;
+        readonly RoutingTimeWindowType: StructType<{
+            readonly start: IntegerType;
+            readonly end: IntegerType;
+        }>;
+        readonly RoutingPickupDeliveryType: StructType<{
+            readonly pickup: IntegerType;
+            readonly delivery: IntegerType;
+        }>;
+        readonly RoutingModelType: StructType<{
+            readonly distance_matrix: ArrayType<ArrayType<IntegerType>>;
+            readonly num_vehicles: IntegerType;
+            readonly depot: IntegerType;
+            readonly demands: OptionType<ArrayType<IntegerType>>;
+            readonly vehicle_capacities: OptionType<ArrayType<IntegerType>>;
+            readonly time_matrix: OptionType<ArrayType<ArrayType<IntegerType>>>;
+            readonly time_windows: OptionType<ArrayType<StructType<{
+                readonly start: IntegerType;
+                readonly end: IntegerType;
+            }>>>;
+            readonly pickup_deliveries: OptionType<ArrayType<StructType<{
+                readonly pickup: IntegerType;
+                readonly delivery: IntegerType;
+            }>>>;
+        }>;
+        readonly RoutingConfigType: StructType<{
+            readonly first_solution: OptionType<VariantType<{
+                readonly path_cheapest_arc: NullType;
+                readonly savings: NullType;
+                readonly christofides: NullType;
+                readonly parallel_cheapest_insertion: NullType;
+                readonly local_cheapest_insertion: NullType;
+                readonly first_unbound_min_value: NullType;
+            }>>;
+            readonly metaheuristic: OptionType<VariantType<{
+                readonly greedy_descent: NullType;
+                readonly guided_local_search: NullType;
+                readonly simulated_annealing: NullType;
+                readonly tabu_search: NullType;
+            }>>;
+            readonly max_time_seconds: OptionType<FloatType>;
+        }>;
+        readonly RoutingRouteType: StructType<{
+            readonly vehicle: IntegerType;
+            readonly nodes: ArrayType<IntegerType>;
+            readonly distance: IntegerType;
+        }>;
+        readonly RoutingResultType: StructType<{
+            readonly status: VariantType<{
+                readonly optimal: NullType;
+                readonly feasible: NullType;
+                readonly infeasible: NullType;
+                readonly not_solved: NullType;
+                readonly model_invalid: NullType;
+            }>;
+            readonly total_distance: IntegerType;
+            readonly routes: ArrayType<StructType<{
+                readonly vehicle: IntegerType;
+                readonly nodes: ArrayType<IntegerType>;
+                readonly distance: IntegerType;
+            }>>;
+            readonly wall_time: FloatType;
+        }>;
+        readonly LinearVarType: StructType<{
+            readonly name: StringType;
+            readonly lower_bound: FloatType;
+            readonly upper_bound: FloatType;
+            readonly is_integer: BooleanType;
+        }>;
+        readonly LinearTermType: StructType<{
+            readonly var: StringType;
+            readonly coeff: FloatType;
+        }>;
+        readonly LinearConstraintDefType: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: FloatType;
+            }>>;
+            readonly lower_bound: FloatType;
+            readonly upper_bound: FloatType;
+        }>;
+        readonly LinearObjectiveType: StructType<{
+            readonly terms: ArrayType<StructType<{
+                readonly var: StringType;
+                readonly coeff: FloatType;
+            }>>;
+            readonly maximize: BooleanType;
+        }>;
+        readonly LinearModelType: StructType<{
+            readonly variables: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly lower_bound: FloatType;
+                readonly upper_bound: FloatType;
+                readonly is_integer: BooleanType;
+            }>>;
+            readonly constraints: ArrayType<StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: FloatType;
+                }>>;
+                readonly lower_bound: FloatType;
+                readonly upper_bound: FloatType;
+            }>>;
+            readonly objective: StructType<{
+                readonly terms: ArrayType<StructType<{
+                    readonly var: StringType;
+                    readonly coeff: FloatType;
+                }>>;
+                readonly maximize: BooleanType;
+            }>;
+        }>;
+        readonly LinearSolverType: VariantType<{
+            readonly glop: NullType;
+            readonly scip: NullType;
+            readonly highs: NullType;
+        }>;
+        readonly LinearConfigType: StructType<{
+            readonly solver: OptionType<VariantType<{
+                readonly glop: NullType;
+                readonly scip: NullType;
+                readonly highs: NullType;
+            }>>;
+            readonly max_time_seconds: OptionType<FloatType>;
+        }>;
+        readonly LinearResultType: StructType<{
+            readonly status: VariantType<{
+                readonly optimal: NullType;
+                readonly feasible: NullType;
+                readonly infeasible: NullType;
+                readonly not_solved: NullType;
+                readonly model_invalid: NullType;
+            }>;
+            readonly objective_value: OptionType<FloatType>;
+            readonly assignments: DictType<StringType, FloatType>;
+            readonly wall_time: FloatType;
+        }>;
+        readonly MinCostFlowInputType: StructType<{
+            readonly start_nodes: ArrayType<IntegerType>;
+            readonly end_nodes: ArrayType<IntegerType>;
+            readonly capacities: ArrayType<IntegerType>;
+            readonly unit_costs: ArrayType<IntegerType>;
+            readonly supplies: ArrayType<IntegerType>;
+        }>;
+        readonly MinCostFlowResultType: StructType<{
+            readonly status: VariantType<{
+                readonly optimal: NullType;
+                readonly feasible: NullType;
+                readonly infeasible: NullType;
+                readonly not_solved: NullType;
+                readonly model_invalid: NullType;
+            }>;
+            readonly total_cost: IntegerType;
+            readonly flows: ArrayType<IntegerType>;
+            readonly wall_time: FloatType;
+        }>;
+        readonly MaxFlowInputType: StructType<{
+            readonly start_nodes: ArrayType<IntegerType>;
+            readonly end_nodes: ArrayType<IntegerType>;
+            readonly capacities: ArrayType<IntegerType>;
+            readonly source: IntegerType;
+            readonly sink: IntegerType;
+        }>;
+        readonly MaxFlowResultType: StructType<{
+            readonly status: VariantType<{
+                readonly optimal: NullType;
+                readonly feasible: NullType;
+                readonly infeasible: NullType;
+                readonly not_solved: NullType;
+                readonly model_invalid: NullType;
+            }>;
+            readonly total_flow: IntegerType;
+            readonly flows: ArrayType<IntegerType>;
+            readonly wall_time: FloatType;
+        }>;
+        readonly AssignmentInputType: StructType<{
+            readonly costs: ArrayType<ArrayType<IntegerType>>;
+        }>;
+        readonly AssignmentMatchType: StructType<{
+            readonly worker: IntegerType;
+            readonly task: IntegerType;
+            readonly cost: IntegerType;
+        }>;
+        readonly AssignmentResultType: StructType<{
+            readonly status: VariantType<{
+                readonly optimal: NullType;
+                readonly feasible: NullType;
+                readonly infeasible: NullType;
+                readonly not_solved: NullType;
+                readonly model_invalid: NullType;
+            }>;
+            readonly total_cost: IntegerType;
+            readonly assignments: ArrayType<StructType<{
+                readonly worker: IntegerType;
+                readonly task: IntegerType;
+                readonly cost: IntegerType;
+            }>>;
+            readonly wall_time: FloatType;
+        }>;
+    };
+};
+//# sourceMappingURL=google_or.d.ts.map