import { d as SDCPN } from "../sdcpn-CayOVwJM.js";

//#region src/examples/production-with-machine-failure.d.ts
/**
 * Manufacturing line where machines produce goods, accumulate damage, break
 * down, and are repaired by travelling technicians.
 *
 * Demonstrates three typed places (Machine, Machine-Producing-Product, and
 * Technician) with continuous dynamics: production progress advances, damage
 * is repaired, and technicians travel toward the site. Production is a race
 * between a predicate "Production Success" (fires once `transformation_progress
 * >= 1`) and a stochastic "Machine Fail" whose rate is `machine_damage_ratio **
 * 100`, so failure becomes overwhelmingly likely only as damage approaches 1.
 * The "Default Production" scenario seeds configurable raw material, machine
 * count, and initial machine damage.
 *
 * See `docs/examples.md` (Production with Machine Failure) for the walkthrough.
 */
declare const productionMachines: {
  title: string;
  petriNetDefinition: SDCPN;
};
//#endregion
//#region src/examples/deployment-pipeline.d.ts
/**
 * Software release pipeline with a single-deployment safety gate and an
 * incident feedback loop.
 *
 * Deployments and incidents arrive from source transitions at stochastic rates.
 * "Start Deployment" uses inhibitor arcs from IncidentBeingInvestigated and
 * DeploymentInProgress so a release can only begin when no incident is open and
 * no other deployment is running. In-progress deployments either finish
 * successfully or trigger "Deployment Causes Incident", which records a failure
 * and opens a new incident that re-closes the gate. Deployment `size` is sampled
 * lognormally and `risk`/`severity` are sampled with Gaussian noise (clamped via
 * `.map()`); larger/riskier releases finish more slowly and fail more often.
 *
 * Ships with per-place SVG visualizers, metrics (success/failure counts, queue
 * length, gate-blocked flag, failure share), and four scenarios. See
 * `docs/examples.md` (Deployment Pipeline).
 */
declare const deploymentPipelineSDCPN: {
  title: string;
  petriNetDefinition: SDCPN;
};
//#endregion
//#region src/examples/satellites-launcher.d.ts
/**
 * Orbital mechanics simulation: satellites are continuously launched into orbit
 * around a central body and may collide with each other or crash into the
 * planet, becoming debris.
 *
 * A gravitational ODE integrates each satellite's position and velocity every
 * step. "LaunchSatellite" is a stochastic source transition that samples a
 * launch angle once with `Distribution.Uniform` and uses `.map()` to derive a
 * coherent `(x, y)` position on the orbit, with a Gaussian initial velocity.
 * "Collision" (input arc weight 2) consumes two satellites and checks pairwise
 * distance; "Crash" checks distance from the planet surface. A custom SVG
 * visualizer renders the planet, satellites, and velocity vectors. The Moon
 * Orbit and Earth Orbit scenarios preset gravity, planet radius, and launch
 * parameters.
 *
 * See `docs/examples.md` (Probabilistic Satellite Launcher).
 */
declare const probabilisticSatellitesSDCPN: {
  title: string;
  petriNetDefinition: SDCPN;
};
//#endregion
//#region src/examples/sir-model.d.ts
/**
 * Susceptible-Infected-Recovered (SIR) compartmental epidemic model, expressed
 * as a stochastic Petri net.
 *
 * The Infection transition consumes one Susceptible and one Infected and
 * produces two Infected tokens (arc weight 2), reproducing the mass-action
 * `S + I -> 2I` dynamics; Recovery moves Infected to Recovered. Firing rates are
 * driven by the `infection_rate` and `recovery_rate` global parameters, so the
 * basic reproduction number can be explored by changing parameters alone.
 *
 * This is the simplest built-in example and a good introduction to stochastic
 * firing and global parameters. See `docs/examples.md` for suggested initial
 * state and walkthrough.
 */
declare const sirModel: {
  title: string;
  petriNetDefinition: SDCPN;
};
//#endregion
//#region src/examples/supply-chain-with-disruption.d.ts
/**
 * End-to-end supply chain spanning dual-sourced procurement, factory
 * production, and customer order fulfilment, with disruption and recovery
 * throughout. This is the most complex built-in example.
 *
 * Raw materials are ordered from a reliable/expensive Supplier A and a
 * low-cost/riskier Supplier B, each of which stochastically toggles between
 * Available and Down states. Inbound shipments (typed with `eta`, `risk_score`,
 * `source`, `cost`) count down via dynamics and are received or damaged. A
 * factory machine with `health`/`wear` converts materials into production
 * batches whose `quality` decays with wear; batches pass or fail QA. On the
 * demand side, customer orders age, convert to backorders, and are fulfilled
 * from stock or cancelled, with outbound shipments delivered or lost. Lead
 * times, processing times, and quality use `Distribution.Gaussian`; risk and
 * priority draws use `Distribution.Uniform`.
 *
 * Ships with five per-place SVG visualizers, nine metrics, and five scenarios
 * (balanced dual source, demand surge, supplier outage, low-cost sourcing,
 * resilience investment). Best explored via scenarios — see
 * `docs/examples.md` (Supply Chain with Disruption).
 */
declare const supplyChainWithDisruption: {
  title: string;
  petriNetDefinition: SDCPN;
};
//#endregion
export { deploymentPipelineSDCPN, probabilisticSatellitesSDCPN, productionMachines, sirModel, supplyChainWithDisruption };
//# sourceMappingURL=index.d.d.ts.map