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

package/dist/templates/types.d.ts

@@ -0,0 +1,531 @@
+import { DataFrameColumn, PlateCondition, PlateMap, PlateMapEditorState, ProtocolStep, Reagent, SampleType, SelectOption, Well, WellPlateFormat } from '../types';
+export type TemplateKind = 'experiment-design';
+export type TemplateId = 'plate-map' | 'sample-sheet' | 'sample-prep' | 'dose-response' | 'calibration-curve' | 'time-course' | 'protocol-steps' | 'assay-matrix' | 'reagent-list' | 'flow-cytometry-panel' | 'instrument-run' | 'qpcr-plate';
+export type TemplatePresetId = 'wellplate-screen' | 'qpcr-expression' | 'lcms-batch' | 'elisa-assay' | 'flow-cytometry-assay' | 'western-blot-assay';
+export type TemplatePackId = 'cell-culture-screen' | 'omics-assay' | 'longitudinal-study' | 'molecular-assay';
+export interface CreateBioTemplatePackCollectionOptions {
+    metadata?: Record<string, unknown>;
+}
+export interface BioTemplateEnvelope<TData = Record<string, unknown>> {
+    template_id: TemplateId | string;
+    template_version: string;
+    kind: TemplateKind | string;
+    data: TData;
+    metadata: Record<string, unknown>;
+}
+export type TemplateCollection = Record<string, BioTemplateEnvelope<unknown>>;
+export interface TemplateCollectionEnvelope {
+    templates: TemplateCollection;
+    metadata?: Record<string, unknown>;
+}
+export type TemplateWell = Well;
+export type TemplatePlateMap = PlateMap;
+export type TemplateSample = SampleType;
+export interface PlateMapTemplateData {
+    plates: TemplatePlateMap[];
+    samples: TemplateSample[];
+    activePlateId?: string;
+    selectedWells?: string[];
+    activeSampleId?: string;
+}
+export type PlateMapTemplate = BioTemplateEnvelope<PlateMapTemplateData>;
+export type SampleColumnType = 'string' | 'number' | 'integer' | 'boolean' | 'date' | 'category' | 'unknown';
+export interface SampleColumn {
+    id: string;
+    label: string;
+    type: SampleColumnType;
+    required: boolean;
+    groupable: boolean;
+}
+export interface SampleRecord {
+    sampleId: string;
+    name?: string;
+    group?: string;
+    batch?: string;
+    replicate?: number | string;
+    plateId?: string;
+    wellId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface SampleGroupDefinition {
+    name: string;
+    color: string;
+    samples: string[];
+}
+export interface SampleSheetTemplateData {
+    samples: SampleRecord[];
+    columns: SampleColumn[];
+    groups: SampleGroupDefinition[];
+}
+export type SampleSheetTemplate = BioTemplateEnvelope<SampleSheetTemplateData>;
+export type SamplePrepStepType = 'extraction' | 'dilution' | 'normalization' | 'transfer' | 'incubation' | 'centrifugation' | 'cleanup' | 'digestion' | 'labeling' | 'other';
+export type SamplePrepStatus = 'planned' | 'in-progress' | 'completed' | 'failed' | 'skipped';
+export interface SamplePrepStep {
+    id: string;
+    order: number;
+    type: SamplePrepStepType;
+    name: string;
+    sourceSampleId?: string;
+    sourcePlateId?: string;
+    sourceWellId?: string;
+    destinationSampleId?: string;
+    destinationPlateId?: string;
+    destinationWellId?: string;
+    reagentId?: string;
+    inputVolume?: number;
+    outputVolume?: number;
+    volumeUnit: string;
+    durationMin?: number;
+    status: SamplePrepStatus;
+    metadata?: Record<string, unknown>;
+}
+export interface SamplePrepTemplateData {
+    protocolName: string;
+    steps: SamplePrepStep[];
+    metadata: Record<string, unknown>;
+}
+export type SamplePrepTemplate = BioTemplateEnvelope<SamplePrepTemplateData>;
+export type SamplePrepStepInput = Partial<SamplePrepStep> & {
+    name?: string;
+    sourceSampleId?: string;
+};
+export interface CompoundDoseSeries {
+    id: string;
+    name: string;
+    concentrations: number[];
+    metadata?: Record<string, unknown>;
+}
+export type ControlRole = 'vehicle' | 'positive' | 'negative' | 'blank' | 'baseline' | 'other';
+export interface ControlDefinition {
+    id: string;
+    name: string;
+    role: ControlRole;
+    vehicle?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface DoseResponseTemplateData {
+    compounds: CompoundDoseSeries[];
+    unit: string;
+    replicates: number;
+    controls: ControlDefinition[];
+    layout?: PlateMapTemplateData;
+    metadata: Record<string, unknown>;
+}
+export type DoseResponseTemplate = BioTemplateEnvelope<DoseResponseTemplateData>;
+export type CalibrationModel = 'linear' | 'linear-weighted-1-x' | 'linear-weighted-1-x2' | 'quadratic' | 'four-parameter-logistic';
+export type CalibrationPointRole = 'blank' | 'standard' | 'qc' | 'unknown';
+export type CalibrationPointStatus = 'planned' | 'accepted' | 'rejected' | 'warning';
+export interface CalibrationAcceptance {
+    minRSquared: number;
+    standardTolerancePercent: number;
+    qcTolerancePercent: number;
+    requireBlank: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface CalibrationPoint {
+    id: string;
+    order: number;
+    role: CalibrationPointRole;
+    level: string;
+    concentration: number;
+    unit: string;
+    expectedResponse?: number;
+    response?: number;
+    replicate: number;
+    include: boolean;
+    status: CalibrationPointStatus;
+    metadata?: Record<string, unknown>;
+}
+export interface CalibrationCurveTemplateData {
+    analyte: string;
+    model: CalibrationModel;
+    xUnit: string;
+    responseUnit: string;
+    points: CalibrationPoint[];
+    acceptance: CalibrationAcceptance;
+    metadata: Record<string, unknown>;
+}
+export type CalibrationCurveTemplate = BioTemplateEnvelope<CalibrationCurveTemplateData>;
+export type CalibrationAcceptanceInput = Partial<CalibrationAcceptance>;
+export type CalibrationPointInput = Partial<CalibrationPoint> & {
+    concentration?: number;
+    level?: string;
+};
+export type TimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'week';
+export interface TimePoint {
+    id: string;
+    label: string;
+    value: number;
+    unit: TimeUnit;
+    metadata?: Record<string, unknown>;
+}
+export interface TimeCourseCondition {
+    id: string;
+    name: string;
+    color?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TimeCourseSample {
+    sampleId: string;
+    conditionId: string;
+    timepointId: string;
+    replicate: number;
+    metadata?: Record<string, unknown>;
+}
+export interface TimeCourseTemplateData {
+    timepoints: TimePoint[];
+    conditions: TimeCourseCondition[];
+    samples: TimeCourseSample[];
+    metadata: Record<string, unknown>;
+}
+export type TimeCourseTemplate = BioTemplateEnvelope<TimeCourseTemplateData>;
+export type AssayFeatureType = 'metabolite' | 'protein' | 'gene' | 'cell' | 'compound' | 'readout' | 'other';
+export interface AssaySample {
+    sampleId: string;
+    name?: string;
+    group?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AssayFeature {
+    id: string;
+    name: string;
+    type: AssayFeatureType;
+    unit?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AssayMeasurement {
+    sampleId: string;
+    featureId: string;
+    value?: number | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AssayMatrixTemplateData {
+    samples: AssaySample[];
+    features: AssayFeature[];
+    measurements: AssayMeasurement[];
+    metadata: Record<string, unknown>;
+}
+export type AssayMatrixTemplate = BioTemplateEnvelope<AssayMatrixTemplateData>;
+export type ProtocolStepRecord = ProtocolStep & {
+    metadata?: Record<string, unknown>;
+};
+export interface ProtocolStepsTemplateData {
+    steps: ProtocolStepRecord[];
+    metadata: Record<string, unknown>;
+}
+export type ProtocolStepsTemplate = BioTemplateEnvelope<ProtocolStepsTemplateData>;
+export type ReagentKind = 'compound' | 'antibody' | 'primer' | 'enzyme' | 'buffer' | 'media' | 'kit' | 'reagent' | 'other';
+export type ReagentTemplateInput = Omit<Reagent, 'expiryDate'> & {
+    expiryDate?: Date | string | null;
+    kind?: ReagentKind;
+    concentration?: string;
+    metadata?: Record<string, unknown>;
+};
+export interface ReagentRecord extends Omit<Reagent, 'expiryDate'> {
+    expiryDate?: string;
+    kind?: ReagentKind;
+    concentration?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ReagentListTemplateData {
+    reagents: ReagentRecord[];
+    metadata: Record<string, unknown>;
+}
+export type ReagentListTemplate = BioTemplateEnvelope<ReagentListTemplateData>;
+export type FlowMarkerPurpose = 'phenotype' | 'viability' | 'activation' | 'sorting' | 'control' | 'other';
+export type FlowControlKind = 'unstained' | 'single-stain' | 'fmo' | 'isotype' | 'viability' | 'beads' | 'other';
+export interface FlowPanelMarker {
+    id: string;
+    marker: string;
+    fluorophore: string;
+    detector?: string;
+    clone?: string;
+    reagentId?: string;
+    purpose: FlowMarkerPurpose;
+    compensationRequired: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface FlowPanelControl {
+    id: string;
+    name: string;
+    kind: FlowControlKind;
+    markerId?: string;
+    required: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface FlowCytometryPanelTemplateData {
+    markers: FlowPanelMarker[];
+    controls: FlowPanelControl[];
+    instrument?: string;
+    metadata: Record<string, unknown>;
+}
+export type FlowCytometryPanelTemplate = BioTemplateEnvelope<FlowCytometryPanelTemplateData>;
+export type InstrumentRunItemKind = 'sample' | 'blank' | 'qc' | 'standard' | 'calibration' | 'wash' | 'other';
+export type InstrumentRunStatus = 'planned' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+export interface InstrumentMethod {
+    id: string;
+    name: string;
+    instrument?: string;
+    acquisitionMode?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface InstrumentRunItem {
+    id: string;
+    order: number;
+    kind: InstrumentRunItemKind;
+    sampleId?: string;
+    name?: string;
+    methodId: string;
+    vial?: string;
+    plateId?: string;
+    wellId?: string;
+    injectionVolume?: number;
+    expectedDurationMin?: number;
+    status: InstrumentRunStatus;
+    metadata?: Record<string, unknown>;
+}
+export interface InstrumentRunTemplateData {
+    runId: string;
+    instrument?: string;
+    methods: InstrumentMethod[];
+    items: InstrumentRunItem[];
+    metadata: Record<string, unknown>;
+}
+export type InstrumentRunTemplate = BioTemplateEnvelope<InstrumentRunTemplateData>;
+export type InstrumentMethodInput = Partial<InstrumentMethod> & {
+    name?: string;
+};
+export type InstrumentRunItemInput = Partial<InstrumentRunItem> & {
+    name?: string;
+    sampleId?: string;
+};
+export type QpcrChemistry = 'sybr' | 'taqman' | 'probe' | 'evagreen' | 'other';
+export type QpcrControlKind = 'sample' | 'no-template' | 'no-rt' | 'positive' | 'standard' | 'calibrator';
+export interface QpcrSample {
+    sampleId: string;
+    name?: string;
+    group?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface QpcrTarget {
+    id: string;
+    name: string;
+    assayId?: string;
+    reporter?: string;
+    quencher?: string;
+    ampliconBp?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface QpcrReaction {
+    id: string;
+    wellId: string;
+    sampleId?: string;
+    targetId: string;
+    replicate: number;
+    controlKind: QpcrControlKind;
+    cq?: number | null;
+    quantity?: number | null;
+    flags: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface QpcrPlateTemplateData {
+    plateId: string;
+    format: WellPlateFormat;
+    samples: QpcrSample[];
+    targets: QpcrTarget[];
+    reactions: QpcrReaction[];
+    instrument?: string;
+    chemistry: QpcrChemistry;
+    metadata: Record<string, unknown>;
+}
+export type QpcrPlateTemplate = BioTemplateEnvelope<QpcrPlateTemplateData>;
+export type DataFrameTemplate = SampleSheetTemplate | SamplePrepTemplate | CalibrationCurveTemplate | TimeCourseTemplate | ProtocolStepsTemplate | AssayMatrixTemplate | ReagentListTemplate | FlowCytometryPanelTemplate | InstrumentRunTemplate | QpcrPlateTemplate;
+export interface CreatePlateMapTemplateOptions {
+    name?: string;
+    id?: string;
+    format?: WellPlateFormat;
+    samples?: Array<string | TemplateSample>;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateSampleSheetTemplateOptions {
+    samples: SampleRecord[];
+    columns?: SampleColumn[];
+    groups?: SampleGroupDefinition[];
+    metadata?: Record<string, unknown>;
+}
+export interface CreateSamplePrepTemplateOptions {
+    samples: Array<string | SamplePrepStepInput>;
+    prepType?: SamplePrepStepType;
+    protocolName?: string;
+    volumeUnit?: string;
+    inputVolume?: number;
+    outputVolume?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateDoseResponseTemplateOptions {
+    compounds: Record<string, number[]> | CompoundDoseSeries[];
+    unit: string;
+    replicates?: number;
+    controls?: ControlDefinition[];
+    layout?: PlateMapTemplate | PlateMapTemplateData;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateCalibrationCurveTemplateOptions {
+    concentrations: Array<number | CalibrationPointInput>;
+    analyte?: string;
+    unit?: string;
+    responseUnit?: string;
+    model?: CalibrationModel;
+    includeBlank?: boolean;
+    includeQc?: boolean;
+    acceptance?: CalibrationAcceptanceInput;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateTimeCourseTemplateOptions {
+    timepoints: Array<number | TimePoint>;
+    unit: TimeUnit;
+    conditions: Array<string | TimeCourseCondition>;
+    replicates?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateAssayMatrixTemplateOptions {
+    samples: Array<string | AssaySample>;
+    features: Array<string | AssayFeature>;
+    values?: Record<string, Record<string, number | null | undefined>>;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateProtocolStepsTemplateOptions {
+    steps: Array<string | (Partial<ProtocolStepRecord> & {
+        name: string;
+    })>;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateReagentListTemplateOptions {
+    reagents: Array<string | ReagentTemplateInput>;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateFlowCytometryPanelTemplateOptions {
+    markers: Array<string | (Partial<FlowPanelMarker> & {
+        marker: string;
+    })>;
+    controls?: Array<string | (Partial<FlowPanelControl> & {
+        name: string;
+    })>;
+    instrument?: string;
+    includeDefaultControls?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateInstrumentRunTemplateOptions {
+    items: Array<string | InstrumentRunItemInput>;
+    method?: string | InstrumentMethodInput;
+    instrument?: string;
+    includeBlanks?: boolean;
+    includeQc?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateQpcrPlateTemplateOptions {
+    samples: Array<string | QpcrSample>;
+    targets: Array<string | QpcrTarget>;
+    format?: WellPlateFormat;
+    replicates?: number;
+    includeNoTemplateControls?: boolean;
+    instrument?: string;
+    chemistry?: QpcrChemistry;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateWellPlateScreenCollectionOptions {
+    samples?: Array<string | SampleRecord>;
+    compounds?: Record<string, number[]> | CompoundDoseSeries[];
+    unit?: string;
+    replicates?: number;
+    plateName?: string;
+    plateFormat?: WellPlateFormat;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateQpcrExpressionCollectionOptions {
+    samples?: Array<string | SampleRecord>;
+    targets?: Array<string | QpcrTarget>;
+    chemistry?: QpcrChemistry;
+    includeNoTemplateControls?: boolean;
+    format?: WellPlateFormat;
+    replicates?: number;
+    instrument?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateLcmsBatchCollectionOptions {
+    samples?: Array<string | SampleRecord>;
+    features?: Array<string | AssayFeature>;
+    instrument?: string;
+    method?: string | InstrumentMethodInput;
+    includeQc?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateElisaAssayCollectionOptions {
+    samples?: Array<string | SampleRecord>;
+    analyte?: string;
+    standardConcentrations?: number[];
+    unit?: string;
+    responseUnit?: string;
+    plateName?: string;
+    plateFormat?: WellPlateFormat;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateFlowCytometryAssayCollectionOptions {
+    samples?: Array<string | SampleRecord>;
+    markers?: CreateFlowCytometryPanelTemplateOptions['markers'];
+    features?: Array<string | AssayFeature>;
+    instrument?: string;
+    includeDefaultControls?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateWesternBlotAssayCollectionOptions {
+    samples?: Array<string | SampleRecord>;
+    targets?: Array<string | AssayFeature>;
+    loadingControl?: string;
+    metadata?: Record<string, unknown>;
+}
+export type PlateMapEditorAdapterResult = PlateMapEditorState;
+export type WellMapAdapterResult = Record<string, Well>;
+export type SampleRowsAdapterResult = Array<Record<string, unknown>>;
+export type SampleColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[];
+export interface DataFrameAdapterResult {
+    data: Array<Record<string, unknown>>;
+    columns: DataFrameColumn<Record<string, unknown>>[];
+    rowKey?: string;
+}
+export type SampleDataFrameAdapterResult = DataFrameAdapterResult;
+export type SampleOptionsAdapterResult = SelectOption<string>[];
+export type SamplePrepRowsAdapterResult = Array<Record<string, unknown>>;
+export type SamplePrepColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[];
+export type SamplePrepDataFrameAdapterResult = DataFrameAdapterResult;
+export type DoseConditionsAdapterResult = PlateCondition[];
+export type CalibrationCurveRowsAdapterResult = Array<Record<string, unknown>>;
+export type CalibrationCurveColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[];
+export type CalibrationCurveDataFrameAdapterResult = DataFrameAdapterResult;
+export type TimeCourseRowsAdapterResult = Array<Record<string, unknown>>;
+export type TimeCourseColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[];
+export type TimeCourseDataFrameAdapterResult = DataFrameAdapterResult;
+export type TimeCourseStepsAdapterResult = ProtocolStep[];
+export type ProtocolStepsAdapterResult = ProtocolStep[];
+export type ProtocolRowsAdapterResult = Array<Record<string, unknown>>;
+export type ProtocolColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[];
+export type ProtocolDataFrameAdapterResult = DataFrameAdapterResult;
+export type AssayMatrixRowsAdapterResult = Array<Record<string, unknown>>;
+export type AssayMatrixColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[];
+export type AssayMatrixDataFrameAdapterResult = DataFrameAdapterResult;
+export type ReagentListItemsAdapterResult = Reagent[];
+export type ReagentRowsAdapterResult = Array<Record<string, unknown>>;
+export type ReagentColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[];
+export type ReagentDataFrameAdapterResult = DataFrameAdapterResult;
+export type FlowPanelRowsAdapterResult = Array<Record<string, unknown>>;
+export type FlowPanelColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[];
+export type FlowPanelDataFrameAdapterResult = DataFrameAdapterResult;
+export type InstrumentRunRowsAdapterResult = Array<Record<string, unknown>>;
+export type InstrumentRunColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[];
+export type InstrumentRunDataFrameAdapterResult = DataFrameAdapterResult;
+export type QpcrRowsAdapterResult = Array<Record<string, unknown>>;
+export type QpcrColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[];
+export type QpcrDataFrameAdapterResult = DataFrameAdapterResult;
+export type QpcrWellMapAdapterResult = Record<string, Well>;
+export type TemplateDataFrameAdapterResult = DataFrameAdapterResult;