@morscherlab/mint-sdk 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/templates/adapters.d.ts

@@ -0,0 +1,43 @@
+import { PlateMapEditorState, Well } from '../types';
+import { AssayMatrixColumnsAdapterResult, AssayMatrixDataFrameAdapterResult, AssayMatrixRowsAdapterResult, AssayMatrixTemplate, AssayMatrixTemplateData, BioTemplateEnvelope, CalibrationCurveColumnsAdapterResult, CalibrationCurveDataFrameAdapterResult, CalibrationCurveRowsAdapterResult, CalibrationCurveTemplate, CalibrationCurveTemplateData, DataFrameTemplate, DoseConditionsAdapterResult, DoseResponseTemplate, DoseResponseTemplateData, FlowCytometryPanelTemplate, FlowCytometryPanelTemplateData, FlowPanelColumnsAdapterResult, FlowPanelDataFrameAdapterResult, FlowPanelRowsAdapterResult, InstrumentRunColumnsAdapterResult, InstrumentRunDataFrameAdapterResult, InstrumentRunRowsAdapterResult, InstrumentRunTemplate, InstrumentRunTemplateData, PlateMapEditorAdapterResult, PlateMapTemplate, PlateMapTemplateData, ProtocolColumnsAdapterResult, ProtocolDataFrameAdapterResult, ProtocolRowsAdapterResult, ProtocolStepsAdapterResult, ProtocolStepsTemplate, ProtocolStepsTemplateData, QpcrColumnsAdapterResult, QpcrDataFrameAdapterResult, QpcrPlateTemplate, QpcrPlateTemplateData, QpcrRowsAdapterResult, QpcrWellMapAdapterResult, ReagentColumnsAdapterResult, ReagentDataFrameAdapterResult, ReagentListItemsAdapterResult, ReagentListTemplate, ReagentListTemplateData, ReagentRowsAdapterResult, SampleColumnsAdapterResult, SampleDataFrameAdapterResult, SampleOptionsAdapterResult, SamplePrepColumnsAdapterResult, SamplePrepDataFrameAdapterResult, SamplePrepRowsAdapterResult, SamplePrepTemplate, SamplePrepTemplateData, SampleRowsAdapterResult, SampleSheetTemplate, SampleSheetTemplateData, TimeCourseColumnsAdapterResult, TimeCourseDataFrameAdapterResult, TimeCourseRowsAdapterResult, TimeCourseStepsAdapterResult, TimeCourseTemplate, TimeCourseTemplateData, TemplateDataFrameAdapterResult, WellMapAdapterResult } from './types';
+export declare function toPlateMapEditorState(template: PlateMapTemplate | PlateMapTemplateData): PlateMapEditorAdapterResult;
+export declare function toWellPlateWells(template: PlateMapTemplate | PlateMapTemplateData, plateId?: string): WellMapAdapterResult;
+export declare function toSampleRows(template: SampleSheetTemplate | SampleSheetTemplateData): SampleRowsAdapterResult;
+export declare function toSampleColumns(template: SampleSheetTemplate | SampleSheetTemplateData): SampleColumnsAdapterResult;
+export declare function toSampleDataFrame(template: SampleSheetTemplate | SampleSheetTemplateData): SampleDataFrameAdapterResult;
+export declare function toSampleOptions(template: SampleSheetTemplate | SampleSheetTemplateData): SampleOptionsAdapterResult;
+export declare function toSamplePrepRows(template: SamplePrepTemplate | SamplePrepTemplateData): SamplePrepRowsAdapterResult;
+export declare function toSamplePrepColumns(): SamplePrepColumnsAdapterResult;
+export declare function toSamplePrepDataFrame(template: SamplePrepTemplate | SamplePrepTemplateData): SamplePrepDataFrameAdapterResult;
+export declare function toDoseConditions(template: DoseResponseTemplate | DoseResponseTemplateData): DoseConditionsAdapterResult;
+export declare function toDoseLayoutState(template: DoseResponseTemplate | DoseResponseTemplateData): PlateMapEditorState | undefined;
+export declare function toCalibrationCurveRows(template: CalibrationCurveTemplate | CalibrationCurveTemplateData): CalibrationCurveRowsAdapterResult;
+export declare function toCalibrationCurveColumns(): CalibrationCurveColumnsAdapterResult;
+export declare function toCalibrationCurveDataFrame(template: CalibrationCurveTemplate | CalibrationCurveTemplateData): CalibrationCurveDataFrameAdapterResult;
+export declare function toTimeCourseRows(template: TimeCourseTemplate | TimeCourseTemplateData): TimeCourseRowsAdapterResult;
+export declare function toTimeCourseColumns(): TimeCourseColumnsAdapterResult;
+export declare function toTimeCourseDataFrame(template: TimeCourseTemplate | TimeCourseTemplateData): TimeCourseDataFrameAdapterResult;
+export declare function toTimeCourseSteps(template: TimeCourseTemplate | TimeCourseTemplateData): TimeCourseStepsAdapterResult;
+export declare function toProtocolSteps(template: ProtocolStepsTemplate | ProtocolStepsTemplateData): ProtocolStepsAdapterResult;
+export declare function toProtocolRows(template: ProtocolStepsTemplate | ProtocolStepsTemplateData): ProtocolRowsAdapterResult;
+export declare function toProtocolColumns(): ProtocolColumnsAdapterResult;
+export declare function toProtocolDataFrame(template: ProtocolStepsTemplate | ProtocolStepsTemplateData): ProtocolDataFrameAdapterResult;
+export declare function toAssayMatrixRows(template: AssayMatrixTemplate | AssayMatrixTemplateData): AssayMatrixRowsAdapterResult;
+export declare function toAssayMatrixColumns(template: AssayMatrixTemplate | AssayMatrixTemplateData): AssayMatrixColumnsAdapterResult;
+export declare function toAssayMatrixDataFrame(template: AssayMatrixTemplate | AssayMatrixTemplateData): AssayMatrixDataFrameAdapterResult;
+export declare function toReagentListItems(template: ReagentListTemplate | ReagentListTemplateData): ReagentListItemsAdapterResult;
+export declare function toReagentRows(template: ReagentListTemplate | ReagentListTemplateData): ReagentRowsAdapterResult;
+export declare function toReagentColumns(): ReagentColumnsAdapterResult;
+export declare function toReagentDataFrame(template: ReagentListTemplate | ReagentListTemplateData): ReagentDataFrameAdapterResult;
+export declare function toFlowPanelRows(template: FlowCytometryPanelTemplate | FlowCytometryPanelTemplateData): FlowPanelRowsAdapterResult;
+export declare function toFlowPanelColumns(): FlowPanelColumnsAdapterResult;
+export declare function toFlowPanelDataFrame(template: FlowCytometryPanelTemplate | FlowCytometryPanelTemplateData): FlowPanelDataFrameAdapterResult;
+export declare function toInstrumentRunRows(template: InstrumentRunTemplate | InstrumentRunTemplateData): InstrumentRunRowsAdapterResult;
+export declare function toInstrumentRunColumns(): InstrumentRunColumnsAdapterResult;
+export declare function toInstrumentRunDataFrame(template: InstrumentRunTemplate | InstrumentRunTemplateData): InstrumentRunDataFrameAdapterResult;
+export declare function toQpcrRows(template: QpcrPlateTemplate | QpcrPlateTemplateData): QpcrRowsAdapterResult;
+export declare function toQpcrColumns(): QpcrColumnsAdapterResult;
+export declare function toQpcrDataFrame(template: QpcrPlateTemplate | QpcrPlateTemplateData): QpcrDataFrameAdapterResult;
+export declare function toQpcrWellPlateWells(template: QpcrPlateTemplate | QpcrPlateTemplateData): QpcrWellMapAdapterResult;
+export declare function toTemplateDataFrame(template: DataFrameTemplate | BioTemplateEnvelope<unknown>): TemplateDataFrameAdapterResult;
+export declare function toWellMapArray(wells: Record<string, Well>): Well[];

package/dist/templates/builders.d.ts

@@ -0,0 +1,63 @@
+import { AssayMatrixTemplate, AssayMatrixTemplateData, BioTemplateEnvelope, CalibrationCurveTemplate, CalibrationCurveTemplateData, CreateBioTemplatePackCollectionOptions, CreateElisaAssayCollectionOptions, CreateLcmsBatchCollectionOptions, CreateAssayMatrixTemplateOptions, CreateCalibrationCurveTemplateOptions, CreateDoseResponseTemplateOptions, CreateFlowCytometryAssayCollectionOptions, CreateWesternBlotAssayCollectionOptions, CreateFlowCytometryPanelTemplateOptions, CreateInstrumentRunTemplateOptions, CreatePlateMapTemplateOptions, CreateProtocolStepsTemplateOptions, CreateQpcrExpressionCollectionOptions, CreateQpcrPlateTemplateOptions, CreateReagentListTemplateOptions, CreateSampleSheetTemplateOptions, CreateSamplePrepTemplateOptions, CreateTimeCourseTemplateOptions, CreateWellPlateScreenCollectionOptions, DoseResponseTemplate, DoseResponseTemplateData, FlowCytometryPanelTemplate, FlowCytometryPanelTemplateData, InstrumentRunTemplate, InstrumentRunTemplateData, PlateMapTemplate, PlateMapTemplateData, ProtocolStepsTemplate, ProtocolStepsTemplateData, QpcrPlateTemplate, QpcrPlateTemplateData, ReagentListTemplate, ReagentListTemplateData, TimeCourseTemplate, TimeCourseTemplateData, SampleSheetTemplate, SampleSheetTemplateData, SamplePrepTemplate, SamplePrepTemplateData, TemplateCollection, TemplateCollectionEnvelope, TemplateId, TemplatePackId, TemplatePresetId } from './types';
+export declare const TEMPLATE_COLLECTION_KEY = "templates";
+export declare function createTemplateEnvelope<TData>(templateId: TemplateId, data: TData, metadata?: Record<string, unknown>, templateVersion?: string): BioTemplateEnvelope<TData>;
+export declare function createPlateMapTemplate(options?: CreatePlateMapTemplateOptions): PlateMapTemplate;
+export declare function createSampleSheetTemplate(options: CreateSampleSheetTemplateOptions): SampleSheetTemplate;
+export declare function createSamplePrepTemplate(options: CreateSamplePrepTemplateOptions): SamplePrepTemplate;
+export declare function createDoseResponseTemplate(options: CreateDoseResponseTemplateOptions): DoseResponseTemplate;
+export declare function createCalibrationCurveTemplate(options: CreateCalibrationCurveTemplateOptions): CalibrationCurveTemplate;
+export declare function createTimeCourseTemplate(options: CreateTimeCourseTemplateOptions): TimeCourseTemplate;
+export declare function createProtocolStepsTemplate(options: CreateProtocolStepsTemplateOptions): ProtocolStepsTemplate;
+export declare function createAssayMatrixTemplate(options: CreateAssayMatrixTemplateOptions): AssayMatrixTemplate;
+export declare function createReagentListTemplate(options: CreateReagentListTemplateOptions): ReagentListTemplate;
+export declare function createFlowCytometryPanelTemplate(options: CreateFlowCytometryPanelTemplateOptions): FlowCytometryPanelTemplate;
+export declare function createInstrumentRunTemplate(options: CreateInstrumentRunTemplateOptions): InstrumentRunTemplate;
+export declare function createQpcrPlateTemplate(options: CreateQpcrPlateTemplateOptions): QpcrPlateTemplate;
+export declare function createDefaultBioTemplate(templateId: TemplateId | string): BioTemplateEnvelope<unknown>;
+export declare function createBioTemplatePackCollection(name: TemplatePackId | string, options?: CreateBioTemplatePackCollectionOptions): TemplateCollectionEnvelope;
+export declare function createWellPlateScreenCollection(options?: CreateWellPlateScreenCollectionOptions): TemplateCollectionEnvelope;
+export declare function createQpcrExpressionCollection(options?: CreateQpcrExpressionCollectionOptions): TemplateCollectionEnvelope;
+export declare function createLcmsBatchCollection(options?: CreateLcmsBatchCollectionOptions): TemplateCollectionEnvelope;
+export declare function createElisaAssayCollection(options?: CreateElisaAssayCollectionOptions): TemplateCollectionEnvelope;
+export declare function createFlowCytometryAssayCollection(options?: CreateFlowCytometryAssayCollectionOptions): TemplateCollectionEnvelope;
+export declare function createWesternBlotAssayCollection(options?: CreateWesternBlotAssayCollectionOptions): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollection(name: 'wellplate-screen', options?: CreateWellPlateScreenCollectionOptions): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollection(name: 'qpcr-expression', options?: CreateQpcrExpressionCollectionOptions): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollection(name: 'lcms-batch', options?: CreateLcmsBatchCollectionOptions): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollection(name: 'elisa-assay', options?: CreateElisaAssayCollectionOptions): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollection(name: 'flow-cytometry-assay', options?: CreateFlowCytometryAssayCollectionOptions): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollection(name: 'western-blot-assay', options?: CreateWesternBlotAssayCollectionOptions): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollection(name: string, options?: CreateWellPlateScreenCollectionOptions | CreateQpcrExpressionCollectionOptions | CreateLcmsBatchCollectionOptions | CreateElisaAssayCollectionOptions | CreateFlowCytometryAssayCollectionOptions | CreateWesternBlotAssayCollectionOptions): TemplateCollectionEnvelope;
+export type BioTemplateControlValues = Record<string, unknown>;
+export declare function bioTemplatePresetControlValuesToOptions(name: 'wellplate-screen', values: BioTemplateControlValues): CreateWellPlateScreenCollectionOptions;
+export declare function bioTemplatePresetControlValuesToOptions(name: 'qpcr-expression', values: BioTemplateControlValues): CreateQpcrExpressionCollectionOptions;
+export declare function bioTemplatePresetControlValuesToOptions(name: 'lcms-batch', values: BioTemplateControlValues): CreateLcmsBatchCollectionOptions;
+export declare function bioTemplatePresetControlValuesToOptions(name: 'elisa-assay', values: BioTemplateControlValues): CreateElisaAssayCollectionOptions;
+export declare function bioTemplatePresetControlValuesToOptions(name: 'flow-cytometry-assay', values: BioTemplateControlValues): CreateFlowCytometryAssayCollectionOptions;
+export declare function bioTemplatePresetControlValuesToOptions(name: 'western-blot-assay', values: BioTemplateControlValues): CreateWesternBlotAssayCollectionOptions;
+export declare function bioTemplatePresetControlValuesToOptions(name: TemplatePresetId | string, values: BioTemplateControlValues): CreateWellPlateScreenCollectionOptions | CreateQpcrExpressionCollectionOptions | CreateLcmsBatchCollectionOptions | CreateElisaAssayCollectionOptions | CreateFlowCytometryAssayCollectionOptions | CreateWesternBlotAssayCollectionOptions;
+export declare function createBioTemplatePresetCollectionFromControls(name: 'wellplate-screen', values: BioTemplateControlValues): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollectionFromControls(name: 'qpcr-expression', values: BioTemplateControlValues): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollectionFromControls(name: 'lcms-batch', values: BioTemplateControlValues): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollectionFromControls(name: 'elisa-assay', values: BioTemplateControlValues): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollectionFromControls(name: 'flow-cytometry-assay', values: BioTemplateControlValues): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollectionFromControls(name: 'western-blot-assay', values: BioTemplateControlValues): TemplateCollectionEnvelope;
+export declare function createBioTemplatePresetCollectionFromControls(name: TemplatePresetId | string, values: BioTemplateControlValues): TemplateCollectionEnvelope;
+export declare function createTemplateCollection(templates: Array<BioTemplateEnvelope<unknown>>, metadata?: Record<string, unknown>): TemplateCollectionEnvelope;
+export declare function extractTemplateCollection(value: unknown): TemplateCollection;
+export declare function ensureTemplateFromCollection<TTemplate extends BioTemplateEnvelope<unknown>>(value: unknown, templateId: TemplateId | string): TTemplate;
+export declare function assertTemplateEnvelope<TData>(value: unknown, templateId: TemplateId | string): asserts value is BioTemplateEnvelope<TData>;
+export declare function ensureTemplateEnvelope<TTemplate extends BioTemplateEnvelope<unknown>>(value: unknown, templateId: TemplateId | string): TTemplate;
+export declare function getTemplateData<TData>(template: BioTemplateEnvelope<TData> | TData, templateId?: TemplateId | string): TData;
+export declare function validatePlateMapData(data: PlateMapTemplateData): void;
+export declare function validateSampleSheetData(data: SampleSheetTemplateData): void;
+export declare function validateSamplePrepData(data: SamplePrepTemplateData): void;
+export declare function validateDoseResponseData(data: DoseResponseTemplateData): void;
+export declare function validateCalibrationCurveData(data: CalibrationCurveTemplateData): void;
+export declare function validateTimeCourseData(data: TimeCourseTemplateData): void;
+export declare function validateProtocolStepsData(data: ProtocolStepsTemplateData): void;
+export declare function validateAssayMatrixData(data: AssayMatrixTemplateData): void;
+export declare function validateReagentListData(data: ReagentListTemplateData): void;
+export declare function validateFlowCytometryPanelData(data: FlowCytometryPanelTemplateData): void;
+export declare function validateInstrumentRunData(data: InstrumentRunTemplateData): void;
+export declare function validateQpcrPlateData(data: QpcrPlateTemplateData): void;

package/dist/templates/catalog.d.ts

@@ -0,0 +1,188 @@
+import { TemplateId } from './types';
+export interface BioTemplateCatalogEntry {
+    name: TemplateId;
+    template_id: TemplateId;
+    template_version: string;
+    label: string;
+    category: 'bio-data';
+    purpose: string;
+    aliases: readonly string[];
+    python_import: string;
+    python_example: string;
+    frontend_import: string;
+    frontend_adapters: readonly string[];
+    components: readonly string[];
+    add_command: string;
+}
+export declare const bioTemplateCatalog: readonly [{
+    readonly name: "plate-map";
+    readonly template_id: "plate-map";
+    readonly template_version: "1.0";
+    readonly label: "Plate map";
+    readonly category: "bio-data";
+    readonly purpose: "Plate layout, wells, sample assignments, and sample legend data.";
+    readonly aliases: readonly ["wellplate", "well-plate", "plate layout", "plate-map editor"];
+    readonly python_import: "from mint_sdk.templates import PlateMapTemplate, save_template";
+    readonly python_example: "PlateMapTemplate.create_96_well(name=\"Plate 1\", samples=[\"Control\", \"Treatment\"])";
+    readonly frontend_import: "import { toPlateMapEditorState, toWellPlateWells } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toPlateMapEditorState", "toWellPlateWells"];
+    readonly components: readonly ["PlateMapEditor", "WellPlate", "SampleLegend"];
+    readonly add_command: "mint add data-template plate-map --page";
+}, {
+    readonly name: "sample-sheet";
+    readonly template_id: "sample-sheet";
+    readonly template_version: "1.0";
+    readonly label: "Sample sheet";
+    readonly category: "bio-data";
+    readonly purpose: "Tabular sample metadata, display columns, and group definitions.";
+    readonly aliases: readonly ["sample metadata", "sample table", "metadata sheet", "csv samples"];
+    readonly python_import: "from mint_sdk.templates import SampleSheetTemplate, save_template";
+    readonly python_example: "SampleSheetTemplate.from_rows([{\"sample_id\": \"S001\", \"name\": \"Control 1\", \"group\": \"Control\"}])";
+    readonly frontend_import: "import { toTemplateDataFrame, toSampleOptions } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toSampleDataFrame", "toSampleRows", "toSampleColumns", "toSampleOptions"];
+    readonly components: readonly ["DataFrame", "SampleSelector", "AutoGroupModal", "GroupAssigner"];
+    readonly add_command: "mint add data-template sample-sheet --page";
+}, {
+    readonly name: "sample-prep";
+    readonly template_id: "sample-prep";
+    readonly template_version: "1.0";
+    readonly label: "Sample prep";
+    readonly category: "bio-data";
+    readonly purpose: "Extraction, dilution, normalization, transfer, source/destination, volume, reagent, and status steps.";
+    readonly aliases: readonly ["sample preparation", "extraction", "dilution", "normalization", "prep steps"];
+    readonly python_import: "from mint_sdk.templates import SamplePrepTemplate, save_template";
+    readonly python_example: "SamplePrepTemplate.create([\"S001\", \"S002\"], prep_type=\"extraction\", output_volume=50)";
+    readonly frontend_import: "import { toSamplePrepDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toSamplePrepDataFrame", "toSamplePrepRows", "toSamplePrepColumns"];
+    readonly components: readonly ["DataFrame", "ProtocolStepEditor", "SampleSelector", "WellPlate"];
+    readonly add_command: "mint add data-template sample-prep --page";
+}, {
+    readonly name: "dose-response";
+    readonly template_id: "dose-response";
+    readonly template_version: "1.0";
+    readonly label: "Dose response";
+    readonly category: "bio-data";
+    readonly purpose: "Compounds, concentration series, controls, replicates, and optional plate layout.";
+    readonly aliases: readonly ["drug response", "concentration series", "dose curve", "dose design", "dose planner", "dose calculator", "drp"];
+    readonly python_import: "from mint_sdk.templates import ControlDefinition, DoseResponseTemplate, save_template";
+    readonly python_example: "DoseResponseTemplate.create({\"Compound A\": [10, 1, 0.1]}, unit=\"uM\", replicates=3)";
+    readonly frontend_import: "import { toDoseConditions, toDoseLayoutState } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toDoseConditions", "toDoseLayoutState"];
+    readonly components: readonly ["DoseCalculator", "ReagentEditor", "WellPlate"];
+    readonly add_command: "mint add data-template dose-response --page";
+}, {
+    readonly name: "calibration-curve";
+    readonly template_id: "calibration-curve";
+    readonly template_version: "1.0";
+    readonly label: "Calibration curve";
+    readonly category: "bio-data";
+    readonly purpose: "Standard curves, blank/QC points, fitted model settings, and acceptance thresholds.";
+    readonly aliases: readonly ["standard curve", "calibration", "quantitation", "qc acceptance", "calibrator"];
+    readonly python_import: "from mint_sdk.templates import CalibrationCurveTemplate, save_template";
+    readonly python_example: "CalibrationCurveTemplate.create([0.1, 1, 10, 100], analyte=\"Glucose\", unit=\"uM\")";
+    readonly frontend_import: "import { toCalibrationCurveDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toCalibrationCurveDataFrame", "toCalibrationCurveRows", "toCalibrationCurveColumns"];
+    readonly components: readonly ["DataFrame", "FitPanel", "ChartContainer"];
+    readonly add_command: "mint add data-template calibration-curve --page";
+}, {
+    readonly name: "time-course";
+    readonly template_id: "time-course";
+    readonly template_version: "1.0";
+    readonly label: "Time course";
+    readonly category: "bio-data";
+    readonly purpose: "Longitudinal time points, conditions, replicates, and scheduled samples.";
+    readonly aliases: readonly ["longitudinal", "time series", "sampling schedule", "kinetics"];
+    readonly python_import: "from mint_sdk.templates import TimeCourseTemplate, save_template";
+    readonly python_example: "TimeCourseTemplate.create([0, 6, 24], unit=\"hour\", conditions=[\"Control\", \"Treatment\"], replicates=3)";
+    readonly frontend_import: "import { toTemplateDataFrame, toTimeCourseSteps } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toTimeCourseDataFrame", "toTimeCourseRows", "toTimeCourseSteps", "toTimeCourseColumns"];
+    readonly components: readonly ["ExperimentTimeline", "DataFrame", "ScheduleCalendar"];
+    readonly add_command: "mint add data-template time-course --page";
+}, {
+    readonly name: "protocol-steps";
+    readonly template_id: "protocol-steps";
+    readonly template_version: "1.0";
+    readonly label: "Protocol steps";
+    readonly category: "bio-data";
+    readonly purpose: "Ordered experiment protocol steps, durations, statuses, and run-sheet parameters.";
+    readonly aliases: readonly ["protocol", "run sheet", "workflow", "method steps", "sop"];
+    readonly python_import: "from mint_sdk.templates import ProtocolStepsTemplate, save_template";
+    readonly python_example: "ProtocolStepsTemplate.create([\"Seed cells\", \"Add treatment\", \"Measure viability\"])";
+    readonly frontend_import: "import { toProtocolSteps, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toProtocolSteps", "toProtocolDataFrame"];
+    readonly components: readonly ["ExperimentTimeline", "ProtocolStepEditor", "DataFrame"];
+    readonly add_command: "mint add data-template protocol-steps --page";
+}, {
+    readonly name: "assay-matrix";
+    readonly template_id: "assay-matrix";
+    readonly template_version: "1.0";
+    readonly label: "Assay matrix";
+    readonly category: "bio-data";
+    readonly purpose: "Sample-by-feature measurement matrices for omics, plate-reader, and marker assays.";
+    readonly aliases: readonly ["omics matrix", "measurement matrix", "readout matrix", "feature table"];
+    readonly python_import: "from mint_sdk.templates import AssayMatrixTemplate, save_template";
+    readonly python_example: "AssayMatrixTemplate.create(samples=[\"S001\", \"S002\"], features=[\"Lactate\", \"Glucose\"])";
+    readonly frontend_import: "import { toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toAssayMatrixDataFrame", "toAssayMatrixRows", "toAssayMatrixColumns"];
+    readonly components: readonly ["DataFrame", "ChartContainer", "SampleSelector"];
+    readonly add_command: "mint add data-template assay-matrix --page";
+}, {
+    readonly name: "reagent-list";
+    readonly template_id: "reagent-list";
+    readonly template_version: "1.0";
+    readonly label: "Reagent list";
+    readonly category: "bio-data";
+    readonly purpose: "Experiment reagents, catalog numbers, lots, storage, locations, and stock status.";
+    readonly aliases: readonly ["reagents", "inventory", "antibodies", "primers", "compound stocks"];
+    readonly python_import: "from mint_sdk.templates import ReagentListTemplate, save_template";
+    readonly python_example: "ReagentListTemplate.create([\"DMSO\", \"Compound A\", \"Anti-HA antibody\"])";
+    readonly frontend_import: "import { toReagentListItems, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toReagentDataFrame", "toReagentListItems"];
+    readonly components: readonly ["ReagentList", "DataFrame", "ReagentEditor"];
+    readonly add_command: "mint add data-template reagent-list --page";
+}, {
+    readonly name: "flow-cytometry-panel";
+    readonly template_id: "flow-cytometry-panel";
+    readonly template_version: "1.0";
+    readonly label: "Flow cytometry panel";
+    readonly category: "bio-data";
+    readonly purpose: "Flow-cytometry markers, fluorophores, detectors, compensation controls, and panel metadata.";
+    readonly aliases: readonly ["flow panel", "facs panel", "cytometry panel", "antibody panel"];
+    readonly python_import: "from mint_sdk.templates import FlowCytometryPanelTemplate, save_template";
+    readonly python_example: "FlowCytometryPanelTemplate.create([\"CD3\", \"CD4\", \"CD8\"], instrument=\"BD LSRFortessa\")";
+    readonly frontend_import: "import { toFlowPanelDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toFlowPanelDataFrame", "toFlowPanelRows", "toFlowPanelColumns"];
+    readonly components: readonly ["DataFrame", "ReagentList", "SampleSelector"];
+    readonly add_command: "mint add data-template flow-cytometry-panel --page";
+}, {
+    readonly name: "instrument-run";
+    readonly template_id: "instrument-run";
+    readonly template_version: "1.0";
+    readonly label: "Instrument run";
+    readonly category: "bio-data";
+    readonly purpose: "Instrument sequence tables, sample queues, methods, QC, blanks, and acquisition status.";
+    readonly aliases: readonly ["run queue", "sequence table", "sample queue", "lcms run", "instrument sequence", "batch run"];
+    readonly python_import: "from mint_sdk.templates import InstrumentRunTemplate, save_template";
+    readonly python_example: "InstrumentRunTemplate.create([\"S001\", \"S002\"], instrument=\"LC-MS\")";
+    readonly frontend_import: "import { toInstrumentRunDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toInstrumentRunDataFrame", "toInstrumentRunRows", "toInstrumentRunColumns"];
+    readonly components: readonly ["DataFrame", "ScheduleCalendar", "SampleSelector"];
+    readonly add_command: "mint add data-template instrument-run --page";
+}, {
+    readonly name: "qpcr-plate";
+    readonly template_id: "qpcr-plate";
+    readonly template_version: "1.0";
+    readonly label: "qPCR plate";
+    readonly category: "bio-data";
+    readonly purpose: "qPCR/ddPCR plate layouts, samples, targets, replicate reactions, controls, and Cq fields.";
+    readonly aliases: readonly ["qpcr", "qPCR", "ddpcr", "rt-qpcr", "gene expression", "primer plate"];
+    readonly python_import: "from mint_sdk.templates import QpcrPlateTemplate, save_template";
+    readonly python_example: "QpcrPlateTemplate.create(samples=[\"Control\", \"Treatment\"], targets=[\"ACTB\", \"GAPDH\"], replicates=3)";
+    readonly frontend_import: "import { toQpcrDataFrame, toQpcrWellPlateWells, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toQpcrDataFrame", "toQpcrRows", "toQpcrColumns", "toQpcrWellPlateWells"];
+    readonly components: readonly ["DataFrame", "WellPlate", "SampleSelector"];
+    readonly add_command: "mint add data-template qpcr-plate --page";
+}];
+export declare function listBioTemplateCatalog(): readonly BioTemplateCatalogEntry[];
+export declare function getBioTemplateInfo(name: string): BioTemplateCatalogEntry | undefined;
+export declare function searchBioTemplateCatalog(query: string): readonly BioTemplateCatalogEntry[];

package/dist/templates/componentBindings.d.ts

@@ -0,0 +1,71 @@
+import { BioTemplateEnvelope, TemplateCollectionEnvelope, TemplateId, TemplatePackId, TemplatePresetId } from './types';
+export type BioTemplateComponentTarget = TemplateId | TemplatePackId | TemplatePresetId | string | BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope;
+export interface BioTemplateComponentBinding {
+    id: string;
+    template_id: TemplateId;
+    component: string;
+    adapters: readonly string[];
+    props: readonly string[];
+    description: string;
+    importPath: '@morscherlab/mint-sdk';
+}
+export interface BioTemplateComponentPropsBinding extends BioTemplateComponentBinding {
+    propsObject: Record<string, unknown>;
+}
+export interface BioTemplateResolvedComponentBinding extends Omit<BioTemplateComponentBinding, 'props'> {
+    /** Prop names advertised by the static template/component compatibility catalog. */
+    propNames: readonly string[];
+    /** Concrete props ready for direct `v-bind="componentBindingsById[id].props"` use. */
+    props: Record<string, unknown>;
+    /** Backward-compatible alias for callers that already consume componentProps entries. */
+    propsObject: Record<string, unknown>;
+}
+export type BioTemplateComponentBindingsById = Record<string, BioTemplateResolvedComponentBinding>;
+export type BioTemplateComponentPropsById = Record<string, Record<string, unknown>>;
+export type BioTemplateComponentPropsByComponent = Record<string, Record<string, unknown>[]>;
+export interface BioTemplateComponentPropsLookupOptions {
+    templateId?: TemplateId;
+    id?: string;
+}
+export interface BioTemplateComponentImport {
+    importPath: BioTemplateComponentBinding['importPath'];
+    components: string[];
+    statement: string;
+}
+export interface BioTemplateComponentSnippet extends BioTemplateComponentBinding {
+    propsName: string;
+    propsExpression: string;
+    template: string;
+}
+export interface BioTemplateComponentSnippetOptions {
+    propsVariable?: string;
+}
+export interface BioTemplateComponentUsageOptions extends BioTemplateComponentSnippetOptions {
+    targetExpression?: string;
+    targetPropName?: string;
+}
+export interface BioTemplateComponentUsage {
+    imports: BioTemplateComponentImport[];
+    componentProps: BioTemplateComponentPropsBinding[];
+    snippets: BioTemplateComponentSnippet[];
+    propsDeclarations: string[];
+    scriptSetup: string;
+    template: string;
+    sfc: string;
+}
+export declare function listBioTemplateComponentBindings(): Record<TemplateId, BioTemplateComponentBinding[]>;
+export declare function getBioTemplateComponentBindings(target: BioTemplateComponentTarget): BioTemplateComponentBinding[];
+export declare function toBioTemplateComponentProps(target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope): BioTemplateComponentPropsBinding[];
+/** Return resolved component bindings with concrete props for direct slot rendering. */
+export declare function toBioTemplateComponentBindings(target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope): BioTemplateResolvedComponentBinding[];
+/** Return resolved component bindings keyed by stable template component id. */
+export declare function toBioTemplateComponentBindingsById(target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope): BioTemplateComponentBindingsById;
+/** Return component props keyed by stable binding id for direct `v-bind="componentPropsById[id]"` use. */
+export declare function toBioTemplateComponentPropsById(target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope): BioTemplateComponentPropsById;
+/** Return component props grouped by SDK component name for direct WellPlate/DoseCalculator binding. */
+export declare function toBioTemplateComponentPropsByComponent(target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope): BioTemplateComponentPropsByComponent;
+/** Return the first props object for an SDK component, optionally restricted by template id or binding id. */
+export declare function getBioTemplateComponentProps(target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope, component: string, options?: BioTemplateComponentPropsLookupOptions): Record<string, unknown> | undefined;
+export declare function toBioTemplateComponentImports(target: BioTemplateComponentTarget): BioTemplateComponentImport[];
+export declare function toBioTemplateComponentSnippets(target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope, options?: BioTemplateComponentSnippetOptions): BioTemplateComponentSnippet[];
+export declare function toBioTemplateComponentUsage(target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope, options?: BioTemplateComponentUsageOptions): BioTemplateComponentUsage;

package/dist/templates/controlSchemas.d.ts

@@ -0,0 +1,25 @@
+import { ControlDefinition, ControlSchemaOptions, UseControlSchemaReturn } from '../composables/useControlSchema';
+import { BioTemplateEnvelope, TemplateCollectionEnvelope, TemplateId, TemplatePackId, TemplatePresetId } from './types';
+export type BioTemplateControlSchema = Record<string, ControlDefinition>;
+export type BioTemplateControlTarget = TemplateId | TemplatePackId | TemplatePresetId | string | BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope;
+export declare function listBioTemplateControlSchemas(): Record<TemplateId, BioTemplateControlSchema>;
+export declare function listBioTemplatePresetControlSchemas(): Record<TemplatePresetId, BioTemplateControlSchema>;
+export declare function getBioTemplateControlSchema(target: BioTemplateControlTarget): BioTemplateControlSchema | undefined;
+export declare function requireBioTemplateControlSchema(target: BioTemplateControlTarget): BioTemplateControlSchema;
+export declare function createBioTemplateControlToolkit(target: BioTemplateControlTarget, options?: ControlSchemaOptions): UseControlSchemaReturn<BioTemplateControlSchema>;
+export declare function bioTemplateControlsToFormSchema(target: BioTemplateControlTarget, options?: ControlSchemaOptions): {
+    sections: import('..').FormSectionSchema[];
+    steps?: never;
+    submitLabel?: string;
+    cancelLabel?: string;
+    showCancel?: boolean;
+};
+export declare function bioTemplateControlsToSidebarPanels(target: BioTemplateControlTarget, options?: ControlSchemaOptions): Record<string, import('..').SidebarToolSection[]>;
+export declare function bioTemplateControlsToSectionFormSchemas(target: BioTemplateControlTarget, options?: ControlSchemaOptions): Record<string, {
+    sections: import('..').FormSectionSchema[];
+    steps?: never;
+    submitLabel?: string;
+    cancelLabel?: string;
+    showCancel?: boolean;
+}>;
+export declare function getBioTemplateControlDefaults(target: BioTemplateControlTarget): import('..').ControlValues<BioTemplateControlSchema>;

package/dist/templates/index.d.ts

@@ -0,0 +1,15 @@
+export { assertTemplateEnvelope, bioTemplatePresetControlValuesToOptions, createBioTemplatePackCollection, createBioTemplatePresetCollection, createBioTemplatePresetCollectionFromControls, createAssayMatrixTemplate, createCalibrationCurveTemplate, createDoseResponseTemplate, createElisaAssayCollection, createFlowCytometryAssayCollection, createWesternBlotAssayCollection, createFlowCytometryPanelTemplate, createInstrumentRunTemplate, createLcmsBatchCollection, createPlateMapTemplate, createProtocolStepsTemplate, createQpcrExpressionCollection, createQpcrPlateTemplate, createReagentListTemplate, createSampleSheetTemplate, createSamplePrepTemplate, createTemplateCollection, createDefaultBioTemplate, createTimeCourseTemplate, createTemplateEnvelope, createWellPlateScreenCollection, ensureTemplateFromCollection, ensureTemplateEnvelope, extractTemplateCollection, getTemplateData, TEMPLATE_COLLECTION_KEY, validateAssayMatrixData, validateCalibrationCurveData, validateDoseResponseData, validateFlowCytometryPanelData, validateInstrumentRunData, validatePlateMapData, validateProtocolStepsData, validateQpcrPlateData, validateReagentListData, validateSampleSheetData, validateSamplePrepData, validateTimeCourseData, } from './builders';
+export type { BioTemplateControlValues, } from './builders';
+export { bioTemplateCatalog, getBioTemplateInfo, listBioTemplateCatalog, searchBioTemplateCatalog, } from './catalog';
+export { bioTemplateControlsToFormSchema, bioTemplateControlsToSectionFormSchemas, bioTemplateControlsToSidebarPanels, createBioTemplateControlToolkit, getBioTemplateControlDefaults, getBioTemplateControlSchema, listBioTemplateControlSchemas, listBioTemplatePresetControlSchemas, requireBioTemplateControlSchema, } from './controlSchemas';
+export { getBioTemplateComponentProps, getBioTemplateComponentBindings, listBioTemplateComponentBindings, toBioTemplateComponentBindings, toBioTemplateComponentBindingsById, toBioTemplateComponentImports, toBioTemplateComponentProps, toBioTemplateComponentPropsByComponent, toBioTemplateComponentPropsById, toBioTemplateComponentSnippets, toBioTemplateComponentUsage, } from './componentBindings';
+export type { BioTemplateComponentBindingsById, BioTemplateComponentPropsByComponent, BioTemplateComponentPropsById, BioTemplateComponentPropsLookupOptions, } from './componentBindings';
+export { bioTemplatePresets, getBioTemplatePresetInfo, listBioTemplatePresets, searchBioTemplatePresets, } from './presets';
+export { bioTemplatePacks, getBioTemplatePackInfo, listBioTemplatePacks, searchBioTemplatePacks, } from './packs';
+export { toAssayMatrixColumns, toAssayMatrixDataFrame, toAssayMatrixRows, toCalibrationCurveColumns, toCalibrationCurveDataFrame, toCalibrationCurveRows, toDoseConditions, toDoseLayoutState, toFlowPanelColumns, toFlowPanelDataFrame, toFlowPanelRows, toInstrumentRunColumns, toInstrumentRunDataFrame, toInstrumentRunRows, toPlateMapEditorState, toProtocolColumns, toProtocolDataFrame, toProtocolRows, toProtocolSteps, toQpcrColumns, toQpcrDataFrame, toQpcrRows, toQpcrWellPlateWells, toReagentColumns, toReagentDataFrame, toReagentListItems, toReagentRows, toSampleColumns, toSampleDataFrame, toSampleOptions, toSamplePrepColumns, toSamplePrepDataFrame, toSamplePrepRows, toSampleRows, toTemplateDataFrame, toTimeCourseColumns, toTimeCourseDataFrame, toTimeCourseRows, toTimeCourseSteps, toWellMapArray, toWellPlateWells, } from './adapters';
+export type { AssayFeature, AssayFeatureType, AssayMatrixColumnsAdapterResult, AssayMatrixDataFrameAdapterResult, AssayMatrixRowsAdapterResult, AssayMatrixTemplate, AssayMatrixTemplateData, AssayMeasurement, AssaySample, BioTemplateEnvelope, CalibrationAcceptance, CalibrationAcceptanceInput, CalibrationCurveColumnsAdapterResult, CalibrationCurveDataFrameAdapterResult, CalibrationCurveRowsAdapterResult, CalibrationCurveTemplate, CalibrationCurveTemplateData, CalibrationModel, CalibrationPoint, CalibrationPointInput, CalibrationPointRole, CalibrationPointStatus, CompoundDoseSeries, ControlDefinition, ControlRole, CreateBioTemplatePackCollectionOptions, CreateAssayMatrixTemplateOptions, CreateCalibrationCurveTemplateOptions, CreateDoseResponseTemplateOptions, CreateElisaAssayCollectionOptions, CreateFlowCytometryAssayCollectionOptions, CreateWesternBlotAssayCollectionOptions, CreateFlowCytometryPanelTemplateOptions, CreateInstrumentRunTemplateOptions, CreateLcmsBatchCollectionOptions, CreatePlateMapTemplateOptions, CreateProtocolStepsTemplateOptions, CreateQpcrExpressionCollectionOptions, CreateQpcrPlateTemplateOptions, CreateReagentListTemplateOptions, CreateSampleSheetTemplateOptions, CreateSamplePrepTemplateOptions, CreateTimeCourseTemplateOptions, CreateWellPlateScreenCollectionOptions, DoseConditionsAdapterResult, DoseResponseTemplate, DoseResponseTemplateData, FlowControlKind, FlowCytometryPanelTemplate, FlowCytometryPanelTemplateData, FlowMarkerPurpose, FlowPanelColumnsAdapterResult, FlowPanelControl, FlowPanelDataFrameAdapterResult, FlowPanelMarker, FlowPanelRowsAdapterResult, InstrumentMethod, InstrumentMethodInput, InstrumentRunColumnsAdapterResult, InstrumentRunDataFrameAdapterResult, InstrumentRunItem, InstrumentRunItemInput, InstrumentRunItemKind, InstrumentRunRowsAdapterResult, InstrumentRunStatus, InstrumentRunTemplate, InstrumentRunTemplateData, DataFrameAdapterResult, DataFrameTemplate, PlateMapEditorAdapterResult, PlateMapTemplate, PlateMapTemplateData, ProtocolColumnsAdapterResult, ProtocolDataFrameAdapterResult, ProtocolRowsAdapterResult, ProtocolStepRecord, ProtocolStepsAdapterResult, ProtocolStepsTemplate, ProtocolStepsTemplateData, QpcrChemistry, QpcrColumnsAdapterResult, QpcrControlKind, QpcrDataFrameAdapterResult, QpcrPlateTemplate, QpcrPlateTemplateData, QpcrReaction, QpcrRowsAdapterResult, QpcrSample, QpcrTarget, QpcrWellMapAdapterResult, ReagentColumnsAdapterResult, ReagentDataFrameAdapterResult, ReagentKind, ReagentListItemsAdapterResult, ReagentListTemplate, ReagentListTemplateData, ReagentRecord, ReagentTemplateInput, ReagentRowsAdapterResult, SampleColumn, SampleColumnType, SampleColumnsAdapterResult, SampleDataFrameAdapterResult, SampleGroupDefinition, SampleOptionsAdapterResult, SamplePrepColumnsAdapterResult, SamplePrepDataFrameAdapterResult, SamplePrepRowsAdapterResult, SamplePrepStatus, SamplePrepStep, SamplePrepStepInput, SamplePrepStepType, SamplePrepTemplate, SamplePrepTemplateData, SampleRecord, SampleRowsAdapterResult, SampleSheetTemplate, SampleSheetTemplateData, TimeCourseColumnsAdapterResult, TimeCourseCondition, TimeCourseDataFrameAdapterResult, TimeCourseRowsAdapterResult, TimeCourseSample, TimeCourseStepsAdapterResult, TimeCourseTemplate, TimeCourseTemplateData, TimePoint, TimeUnit, TemplateId, TemplatePackId, TemplatePresetId, TemplateCollection, TemplateCollectionEnvelope, TemplateDataFrameAdapterResult, TemplateKind, TemplatePlateMap, TemplateSample, TemplateWell, WellMapAdapterResult, } from './types';
+export type { BioTemplateCatalogEntry, } from './catalog';
+export type { BioTemplateComponentBinding, BioTemplateComponentImport, BioTemplateComponentPropsBinding, BioTemplateResolvedComponentBinding, BioTemplateComponentSnippet, BioTemplateComponentSnippetOptions, BioTemplateComponentTarget, BioTemplateComponentUsage, BioTemplateComponentUsageOptions, } from './componentBindings';
+export type { BioTemplateControlSchema, BioTemplateControlTarget, } from './controlSchemas';
+export type { BioTemplatePresetEntry, } from './presets';
+export type { BioTemplatePackEntry, } from './packs';

package/dist/templates/index.js

@@ -0,0 +1,2 @@
+import { $ as toSamplePrepRows, $t as listBioTemplatePresets, A as toFlowPanelDataFrame, At as createTemplateCollection, B as toQpcrColumns, Bt as validateCalibrationCurveData, C as toAssayMatrixRows, Ct as createPlateMapTemplate, D as toDoseConditions, Dt as createReagentListTemplate, E as toCalibrationCurveRows, Et as createQpcrPlateTemplate, F as toPlateMapEditorState, Ft as ensureTemplateEnvelope, G as toReagentDataFrame, Gt as validateProtocolStepsData, H as toQpcrRows, Ht as validateFlowCytometryPanelData, I as toProtocolColumns, It as ensureTemplateFromCollection, J as toSampleColumns, Jt as validateSamplePrepData, K as toReagentListItems, Kt as validateQpcrPlateData, L as toProtocolDataFrame, Lt as extractTemplateCollection, M as toInstrumentRunColumns, Mt as createTimeCourseTemplate, N as toInstrumentRunDataFrame, Nt as createWellPlateScreenCollection, O as toDoseLayoutState, Ot as createSamplePrepTemplate, P as toInstrumentRunRows, Pt as createWesternBlotAssayCollection, Q as toSamplePrepDataFrame, Qt as getBioTemplatePresetInfo, R as toProtocolRows, Rt as getTemplateData, S as toAssayMatrixDataFrame, St as createLcmsBatchCollection, T as toCalibrationCurveDataFrame, Tt as createQpcrExpressionCollection, U as toQpcrWellPlateWells, Ut as validateInstrumentRunData, V as toQpcrDataFrame, Vt as validateDoseResponseData, W as toReagentColumns, Wt as validatePlateMapData, X as toSampleOptions, Xt as validateTimeCourseData, Y as toSampleDataFrame, Yt as validateSampleSheetData, Z as toSamplePrepColumns, Zt as bioTemplatePresets, _ as toBioTemplateComponentPropsByComponent, _t as createDoseResponseTemplate, a as getBioTemplateControlDefaults, an as bioTemplateCatalog, at as toTimeCourseSteps, b as toBioTemplateComponentUsage, bt as createFlowCytometryPanelTemplate, c as listBioTemplatePresetControlSchemas, cn as searchBioTemplateCatalog, ct as TEMPLATE_COLLECTION_KEY, d as getBioTemplateComponentProps, dt as createAssayMatrixTemplate, en as searchBioTemplatePresets, et as toSampleRows, f as listBioTemplateComponentBindings, ft as createBioTemplatePackCollection, g as toBioTemplateComponentProps, gt as createDefaultBioTemplate, h as toBioTemplateComponentImports, ht as createCalibrationCurveTemplate, i as createBioTemplateControlToolkit, in as searchBioTemplatePacks, it as toTimeCourseRows, j as toFlowPanelRows, jt as createTemplateEnvelope, k as toFlowPanelColumns, kt as createSampleSheetTemplate, l as requireBioTemplateControlSchema, lt as assertTemplateEnvelope, m as toBioTemplateComponentBindingsById, mt as createBioTemplatePresetCollectionFromControls, n as bioTemplateControlsToSectionFormSchemas, nn as getBioTemplatePackInfo, nt as toTimeCourseColumns, o as getBioTemplateControlSchema, on as getBioTemplateInfo, ot as toWellMapArray, p as toBioTemplateComponentBindings, pt as createBioTemplatePresetCollection, q as toReagentRows, qt as validateReagentListData, r as bioTemplateControlsToSidebarPanels, rn as listBioTemplatePacks, rt as toTimeCourseDataFrame, s as listBioTemplateControlSchemas, sn as listBioTemplateCatalog, st as toWellPlateWells, t as bioTemplateControlsToFormSchema, tn as bioTemplatePacks, tt as toTemplateDataFrame, u as getBioTemplateComponentBindings, ut as bioTemplatePresetControlValuesToOptions, v as toBioTemplateComponentPropsById, vt as createElisaAssayCollection, w as toCalibrationCurveColumns, wt as createProtocolStepsTemplate, x as toAssayMatrixColumns, xt as createInstrumentRunTemplate, y as toBioTemplateComponentSnippets, yt as createFlowCytometryAssayCollection, z as toProtocolSteps, zt as validateAssayMatrixData } from "../templates-B5jmTWuk.js";
+export { TEMPLATE_COLLECTION_KEY, assertTemplateEnvelope, bioTemplateCatalog, bioTemplateControlsToFormSchema, bioTemplateControlsToSectionFormSchemas, bioTemplateControlsToSidebarPanels, bioTemplatePacks, bioTemplatePresetControlValuesToOptions, bioTemplatePresets, createAssayMatrixTemplate, createBioTemplateControlToolkit, createBioTemplatePackCollection, createBioTemplatePresetCollection, createBioTemplatePresetCollectionFromControls, createCalibrationCurveTemplate, createDefaultBioTemplate, createDoseResponseTemplate, createElisaAssayCollection, createFlowCytometryAssayCollection, createFlowCytometryPanelTemplate, createInstrumentRunTemplate, createLcmsBatchCollection, createPlateMapTemplate, createProtocolStepsTemplate, createQpcrExpressionCollection, createQpcrPlateTemplate, createReagentListTemplate, createSamplePrepTemplate, createSampleSheetTemplate, createTemplateCollection, createTemplateEnvelope, createTimeCourseTemplate, createWellPlateScreenCollection, createWesternBlotAssayCollection, ensureTemplateEnvelope, ensureTemplateFromCollection, extractTemplateCollection, getBioTemplateComponentBindings, getBioTemplateComponentProps, getBioTemplateControlDefaults, getBioTemplateControlSchema, getBioTemplateInfo, getBioTemplatePackInfo, getBioTemplatePresetInfo, getTemplateData, listBioTemplateCatalog, listBioTemplateComponentBindings, listBioTemplateControlSchemas, listBioTemplatePacks, listBioTemplatePresetControlSchemas, listBioTemplatePresets, requireBioTemplateControlSchema, searchBioTemplateCatalog, searchBioTemplatePacks, searchBioTemplatePresets, toAssayMatrixColumns, toAssayMatrixDataFrame, toAssayMatrixRows, toBioTemplateComponentBindings, toBioTemplateComponentBindingsById, toBioTemplateComponentImports, toBioTemplateComponentProps, toBioTemplateComponentPropsByComponent, toBioTemplateComponentPropsById, toBioTemplateComponentSnippets, toBioTemplateComponentUsage, toCalibrationCurveColumns, toCalibrationCurveDataFrame, toCalibrationCurveRows, toDoseConditions, toDoseLayoutState, toFlowPanelColumns, toFlowPanelDataFrame, toFlowPanelRows, toInstrumentRunColumns, toInstrumentRunDataFrame, toInstrumentRunRows, toPlateMapEditorState, toProtocolColumns, toProtocolDataFrame, toProtocolRows, toProtocolSteps, toQpcrColumns, toQpcrDataFrame, toQpcrRows, toQpcrWellPlateWells, toReagentColumns, toReagentDataFrame, toReagentListItems, toReagentRows, toSampleColumns, toSampleDataFrame, toSampleOptions, toSamplePrepColumns, toSamplePrepDataFrame, toSamplePrepRows, toSampleRows, toTemplateDataFrame, toTimeCourseColumns, toTimeCourseDataFrame, toTimeCourseRows, toTimeCourseSteps, toWellMapArray, toWellPlateWells, validateAssayMatrixData, validateCalibrationCurveData, validateDoseResponseData, validateFlowCytometryPanelData, validateInstrumentRunData, validatePlateMapData, validateProtocolStepsData, validateQpcrPlateData, validateReagentListData, validateSamplePrepData, validateSampleSheetData, validateTimeCourseData };

package/dist/templates/lookup.d.ts

@@ -0,0 +1,4 @@
+/** Normalize human-facing template lookup terms so spaces, hyphens, and underscores behave the same. */
+export declare function normalizeTemplateLookupKey(value: string): string;
+export declare function templateIdentifierMatches(query: string, identifiers: readonly string[]): boolean;
+export declare function templateSearchMatches(query: string, values: readonly string[]): boolean;

package/dist/templates/packs.d.ts

@@ -0,0 +1,18 @@
+import { TemplateId, TemplatePackId } from './types';
+export interface BioTemplatePackEntry {
+    name: TemplatePackId;
+    label: string;
+    category: 'bio-template-pack';
+    purpose: string;
+    templates: readonly TemplateId[];
+    aliases: readonly string[];
+    frontend_adapters: readonly string[];
+    components: readonly string[];
+    add_command: string;
+    init_command: string;
+    docs_command: string;
+}
+export declare const bioTemplatePacks: readonly BioTemplatePackEntry[];
+export declare function listBioTemplatePacks(): readonly BioTemplatePackEntry[];
+export declare function getBioTemplatePackInfo(name: string): BioTemplatePackEntry | undefined;
+export declare function searchBioTemplatePacks(query: string): readonly BioTemplatePackEntry[];

package/dist/templates/presets.d.ts

@@ -0,0 +1,90 @@
+import { TemplateId, TemplatePresetId } from './types';
+export interface BioTemplatePresetEntry {
+    name: TemplatePresetId;
+    label: string;
+    category: 'bio-template-preset';
+    purpose: string;
+    templates: readonly TemplateId[];
+    aliases: readonly string[];
+    python_import: string;
+    python_example: string;
+    frontend_import: string;
+    frontend_adapters: readonly string[];
+    components: readonly string[];
+}
+export declare const bioTemplatePresets: readonly [{
+    readonly name: "wellplate-screen";
+    readonly label: "Well-plate screen";
+    readonly category: "bio-template-preset";
+    readonly purpose: "Plate map, sample sheet, and dose-response payloads for plate-based screening assays.";
+    readonly templates: readonly ["plate-map", "sample-sheet", "dose-response"];
+    readonly aliases: readonly ["wellplate", "well-plate screen", "drug screen", "plate screen", "dose response plate", "dose design", "dose planner"];
+    readonly python_import: "from mint_sdk.templates import create_wellplate_screen_collection, save_template_collection";
+    readonly python_example: "create_wellplate_screen_collection(samples=[\"Control\", \"Treatment\"], compounds={\"Drug A\": [10, 1, 0.1]}, unit=\"uM\")";
+    readonly frontend_import: "import { createWellPlateScreenCollection, toPlateMapEditorState, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toPlateMapEditorState", "toTemplateDataFrame", "toDoseConditions"];
+    readonly components: readonly ["PlateMapEditor", "WellPlate", "DataFrame", "DoseCalculator"];
+}, {
+    readonly name: "qpcr-expression";
+    readonly label: "qPCR expression";
+    readonly category: "bio-template-preset";
+    readonly purpose: "Sample metadata and qPCR/ddPCR plate layout for target-expression assays.";
+    readonly templates: readonly ["sample-sheet", "qpcr-plate"];
+    readonly aliases: readonly ["qpcr", "qPCR", "rt-qpcr", "ddpcr", "gene expression", "primer plate"];
+    readonly python_import: "from mint_sdk.templates import create_qpcr_expression_collection, save_template_collection";
+    readonly python_example: "create_qpcr_expression_collection(samples=[\"Control\", \"Treatment\"], targets=[\"ACTB\", \"GAPDH\"], replicates=3)";
+    readonly frontend_import: "import { createQpcrExpressionCollection, toQpcrWellPlateWells, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toQpcrDataFrame", "toQpcrWellPlateWells"];
+    readonly components: readonly ["DataFrame", "WellPlate", "SampleSelector"];
+}, {
+    readonly name: "lcms-batch";
+    readonly label: "LC-MS batch";
+    readonly category: "bio-template-preset";
+    readonly purpose: "Sample metadata, instrument queue, and assay matrix payloads for omics acquisition batches.";
+    readonly templates: readonly ["sample-sheet", "instrument-run", "assay-matrix"];
+    readonly aliases: readonly ["lcms", "lc-ms", "mass spec batch", "omics batch", "run queue", "sequence table"];
+    readonly python_import: "from mint_sdk.templates import create_lcms_batch_collection, save_template_collection";
+    readonly python_example: "create_lcms_batch_collection(samples=[\"S001\", \"S002\"], features=[\"Glucose\", \"Lactate\"], instrument=\"LC-MS\")";
+    readonly frontend_import: "import { createLcmsBatchCollection, toInstrumentRunDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toInstrumentRunDataFrame", "toAssayMatrixDataFrame"];
+    readonly components: readonly ["DataFrame", "ScheduleCalendar", "ChartContainer", "SampleSelector"];
+}, {
+    readonly name: "elisa-assay";
+    readonly label: "ELISA assay";
+    readonly category: "bio-template-preset";
+    readonly purpose: "Plate layout, sample metadata, standard curve, and readout matrix for ELISA and plate-reader assays.";
+    readonly templates: readonly ["plate-map", "sample-sheet", "calibration-curve", "assay-matrix"];
+    readonly aliases: readonly ["elisa", "plate reader assay", "standard curve plate", "absorbance assay", "immunoassay"];
+    readonly python_import: "from mint_sdk.templates import create_elisa_assay_collection, save_template_collection";
+    readonly python_example: "create_elisa_assay_collection(samples=[\"Control\", \"Treatment\"], analyte=\"IL-6\", standard_concentrations=[1000, 100, 10, 1], unit=\"pg/mL\")";
+    readonly frontend_import: "import { createElisaAssayCollection, toPlateMapEditorState, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toPlateMapEditorState", "toTemplateDataFrame", "toCalibrationCurveDataFrame"];
+    readonly components: readonly ["PlateMapEditor", "WellPlate", "DataFrame", "FitPanel", "ChartContainer"];
+}, {
+    readonly name: "flow-cytometry-assay";
+    readonly label: "Flow cytometry assay";
+    readonly category: "bio-template-preset";
+    readonly purpose: "Sample metadata, antibody marker panel, compensation controls, and readout matrix for flow-cytometry assays.";
+    readonly templates: readonly ["sample-sheet", "flow-cytometry-panel", "assay-matrix"];
+    readonly aliases: readonly ["flow cytometry", "facs", "facs panel", "flow panel", "immune phenotyping", "immunophenotyping"];
+    readonly python_import: "from mint_sdk.templates import create_flow_cytometry_assay_collection, save_template_collection";
+    readonly python_example: "create_flow_cytometry_assay_collection(samples=[\"Control\", \"Treatment\"], markers=[\"CD3\", \"CD4\", \"CD8\"], instrument=\"BD LSRFortessa\")";
+    readonly frontend_import: "import { createFlowCytometryAssayCollection, toFlowPanelDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toFlowPanelDataFrame", "toAssayMatrixDataFrame"];
+    readonly components: readonly ["DataFrame", "SampleSelector", "ChartContainer"];
+}, {
+    readonly name: "western-blot-assay";
+    readonly label: "Western blot assay";
+    readonly category: "bio-template-preset";
+    readonly purpose: "Sample metadata, antibody/reagent list, protocol steps, and normalized protein readout matrix for Western blot assays.";
+    readonly templates: readonly ["sample-sheet", "reagent-list", "protocol-steps", "assay-matrix"];
+    readonly aliases: readonly ["western blot", "western-blot", "immunoblot", "protein blot", "protein expression"];
+    readonly python_import: "from mint_sdk.templates import create_western_blot_assay_collection, save_template_collection";
+    readonly python_example: "create_western_blot_assay_collection(samples=[\"Control\", \"Treatment\"], targets=[\"pERK\", \"ERK\"], loading_control=\"ACTB\")";
+    readonly frontend_import: "import { createWesternBlotAssayCollection, toReagentDataFrame, toProtocolDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'";
+    readonly frontend_adapters: readonly ["toTemplateDataFrame", "toReagentDataFrame", "toProtocolDataFrame"];
+    readonly components: readonly ["DataFrame", "ReagentList", "ExperimentTimeline", "SampleSelector"];
+}];
+export declare function listBioTemplatePresets(): readonly BioTemplatePresetEntry[];
+export declare function getBioTemplatePresetInfo(name: string): BioTemplatePresetEntry | undefined;
+export declare function searchBioTemplatePresets(query: string): readonly BioTemplatePresetEntry[];