@opentrons/shared-data 0.1.6-alpha.5 → 0.1.6-alpha.8

package/lib/js/helpers/index.d.ts

@@ -0,0 +1,56 @@
+import type { DeckDefinition, LabwareDefinition2, ModuleModel, RobotType, ThermalAdapterName } from '../types';
+export { getWellNamePerMultiTip } from './getWellNamePerMultiTip';
+export { getWellTotalVolume } from './getWellTotalVolume';
+export { wellIsRect } from './wellIsRect';
+export { orderWells } from './orderWells';
+export { get96Channel384WellPlateWells } from './get96Channel384WellPlateWells';
+export { getTipTypeFromTipRackDefinition } from './getTipTypeFromTipRackDefinition';
+export * from './__fixtures__';
+export * from './parseProtocolCommands';
+export * from './parseProtocolData';
+export * from './volume';
+export * from './wellSets';
+export * from './getAreFlexSlotsAdjacent';
+export * from './getModuleVizDims';
+export * from './getVectorDifference';
+export * from './getVectorSum';
+export * from './getLoadedLabwareDefinitionsByUri';
+export * from './getFixedTrashLabwareDefinition';
+export * from './getOccludedSlotCountForModule';
+export * from './labwareInference';
+export * from './getAddressableAreasInProtocol';
+export * from './getFlexSurroundingSlots';
+export * from './getSimplestFlexDeckConfig';
+export * from './formatRunTimeParameterDefaultValue';
+export * from './formatRunTimeParameterValue';
+export * from './formatRunTimeParameterMinMax';
+export * from './orderRuntimeParameterRangeOptions';
+export * from './sortRunTimeParameters';
+export declare const getLabwareDefIsStandard: (def: LabwareDefinition2) => boolean;
+export declare const getLabwareDefURI: (def: LabwareDefinition2) => string;
+export declare const constructLabwareDefURI: (namespace: string, loadName: string, version: string) => string;
+export declare const getLabwareDisplayName: (labwareDef: LabwareDefinition2) => string;
+export declare const getTiprackVolume: (labwareDef: LabwareDefinition2) => number;
+export declare function getLabwareHasQuirk(labwareDef: LabwareDefinition2, quirk: string): boolean;
+export declare const intToAlphabetLetter: (i: number, lowerCase?: boolean) => string;
+export declare const toWellName: ({ rowNum, colNum, }: {
+    rowNum: number;
+    colNum: number;
+}) => string;
+/** A compareFunction for sorting an array of well names
+ * Goes down the columns (A1 to H1 on 96 plate)
+ * Then L to R across rows (1 to 12 on 96 plate)
+ */
+export declare function sortWells(a: string, b: string): number;
+export declare function splitWellsOnColumn(sortedArray: string[]): string[][];
+export declare const getWellDepth: (labwareDef: LabwareDefinition2, well: string) => number;
+export declare const getWellsDepth: (labwareDef: LabwareDefinition2, wells: string[]) => number;
+export declare const getWellDimension: (labwareDef: LabwareDefinition2, wells: string[], position: 'x' | 'y') => number;
+export declare const getSlotHasMatingSurfaceUnitVector: (deckDef: DeckDefinition, addressableAreaName: string) => boolean;
+export declare const getAreSlotsHorizontallyAdjacent: (slotNameA?: string | null, slotNameB?: string | null) => boolean;
+export declare const getAreSlotsVerticallyAdjacent: (slotNameA?: string | null, slotNameB?: string | null) => boolean;
+export declare const getAreSlotsAdjacent: (slotNameA?: string | null, slotNameB?: string | null) => boolean;
+export declare const getIsLabwareAboveHeight: (labwareDef: LabwareDefinition2, height: number) => boolean;
+export declare const getAdapterName: (labwareLoadname: string) => ThermalAdapterName;
+export declare const getCalibrationAdapterLoadName: (moduleModel: ModuleModel) => string | null;
+export declare const getDeckDefFromRobotType: (robotType: RobotType) => DeckDefinition;

package/lib/js/helpers/labwareInference.d.ts

@@ -0,0 +1,16 @@
+import type { LabwareWell, LabwareWellShapeProperties, LabwareDefinition2, LabwareWellGroupMetadata, LabwareBrand } from '../types';
+export interface LabwareWellGroupProperties {
+    xOffsetFromLeft: number;
+    yOffsetFromTop: number;
+    xSpacing: number | null;
+    ySpacing: number | null;
+    wellCount: number;
+    shape: LabwareWellShapeProperties | null;
+    depth: number | null;
+    totalLiquidVolume: number | null;
+    metadata: LabwareWellGroupMetadata;
+    brand: LabwareBrand | null;
+}
+export declare function getUniqueWellProperties(definition: LabwareDefinition2): LabwareWellGroupProperties[];
+export declare function getIfConsistent<T>(items: T[]): T | null;
+export declare function getSpacingIfUniform(wells: LabwareWell[], axis: 'x' | 'y'): number | null;

package/lib/js/helpers/orderRuntimeParameterRangeOptions.d.ts

@@ -0,0 +1,17 @@
+import type { Choice } from '../types';
+export declare const isNumeric: (str: string) => boolean;
+/**
+ * This function sorts an array of strings in numerical and alphabetical order.
+ * @param {Choice[]} - The array of Choice
+ * Choice is an object like {displayName: 'Single channel 50µL', value: 'flex_1channel_50' }
+ * @returns {string} The ordered string with ","
+ *
+ * @example
+ * const numChoices = [
+ *    { displayName: '20', value: 20 },
+ *    { displayName: '16', value: 16 },
+ * ]
+ * console.log(orderRuntimeParameterRangeOptions(numChoices) // 16,20
+ *
+ */
+export declare const orderRuntimeParameterRangeOptions: (choices: Choice[]) => string;

package/lib/js/helpers/orderWells.d.ts

@@ -0,0 +1,2 @@
+export type WellOrderOption = 'l2r' | 'r2l' | 't2b' | 'b2t';
+export declare const orderWells: (defaultOrdering: string[][], first: WellOrderOption, second: WellOrderOption) => string[];

package/lib/js/helpers/parseProtocolCommands.d.ts

@@ -0,0 +1,61 @@
+import type { LoadLabwareRunTimeCommand, LoadModuleRunTimeCommand, RunTimeCommand, LabwareLocation } from '../../command/types';
+import type { PipetteName } from '../pipettes';
+import type { Liquid, LoadedLabware, LoadedModule, LoadedPipette, ModuleModel, LabwareDefinition2 } from '../types';
+interface PipetteNamesByMount {
+    left: PipetteName | null;
+    right: PipetteName | null;
+}
+export declare function parseInitialPipetteNamesByMount(commands: RunTimeCommand[]): PipetteNamesByMount;
+export declare function parsePipetteEntity(commands: RunTimeCommand[]): LoadedPipette[];
+export declare function parseAllRequiredModuleModels(commands: RunTimeCommand[]): ModuleModel[];
+export declare function parseRequiredModulesEntity(commands: RunTimeCommand[]): LoadedModule[];
+interface LoadedLabwareBySlot {
+    [slotName: string]: LoadLabwareRunTimeCommand;
+}
+export declare function parseInitialLoadedLabwareBySlot(commands: RunTimeCommand[]): LoadedLabwareBySlot;
+export declare function getTopLabwareInfo(labwareId: string, loadLabwareCommands: LoadLabwareRunTimeCommand[], currentStackHeight?: number): {
+    topLabwareId: string;
+    topLabwareDefinition?: LabwareDefinition2;
+    topLabwareDisplayName?: string;
+};
+export declare function getLabwareStackCountAndLocation(topLabwareId: string, commands: RunTimeCommand[], initialQuantity?: number): {
+    labwareQuantity: number;
+    labwareLocation: LabwareLocation;
+};
+export interface LoadedLabwareByAdapter {
+    [labwareId: string]: LoadLabwareRunTimeCommand;
+}
+export declare function parseInitialLoadedLabwareByAdapter(commands: RunTimeCommand[]): LoadedLabwareByAdapter;
+interface LoadedLabwareByModuleId {
+    [moduleId: string]: LoadLabwareRunTimeCommand;
+}
+export declare function parseInitialLoadedLabwareByModuleId(commands: RunTimeCommand[]): LoadedLabwareByModuleId;
+export declare function parseInitialLoadedLabwareEntity(commands: RunTimeCommand[]): LoadedLabware[];
+interface LoadedModulesBySlot {
+    [slotName: string]: LoadModuleRunTimeCommand;
+}
+export declare function parseInitialLoadedModulesBySlot(commands: RunTimeCommand[]): LoadedModulesBySlot;
+export interface LiquidsById {
+    [liquidId: string]: {
+        displayName: string;
+        description: string;
+        displayColor?: string;
+    };
+}
+export interface ParsedLiquid extends Omit<Liquid, 'displayColor'> {
+    displayColor: string;
+}
+export declare function parseLiquidsInLoadOrder(liquids: Liquid[], commands: RunTimeCommand[]): ParsedLiquid[];
+interface LabwareLiquidInfo {
+    labwareId: string;
+    volumeByWell: {
+        [well: string]: number;
+    };
+}
+/** @deprecated instead use LabwareByLiquidId from components/src/hardware-sim/ProtocolDeck/types */
+export interface LabwareByLiquidId {
+    [liquidId: string]: LabwareLiquidInfo[];
+}
+/** @deprecated instead use getLabwareInfoByLiquidId from components/src/hardware-sim/ProtocolDeck/utils */
+export declare function parseLabwareInfoByLiquidId(commands: RunTimeCommand[]): LabwareByLiquidId;
+export {};

package/lib/js/helpers/parseProtocolData.d.ts

@@ -0,0 +1,23 @@
+import type { ErrorObject } from 'ajv';
+import type { JsonProtocolFile } from '../../protocol';
+export type ProtocolParseErrorKey = 'INVALID_FILE_TYPE' | 'INVALID_JSON_FILE';
+interface ProtocolParseErrorDetails {
+    rawError?: unknown;
+    schemaErrors?: ErrorObject[] | null;
+}
+export type ProtocolParseErrorHandler = (errorKey: ProtocolParseErrorKey, errorDetails?: ProtocolParseErrorDetails) => unknown;
+export interface PythonProtocolMetadata {
+    source?: string;
+    [key: string]: unknown;
+}
+export type ProtocolData = JsonProtocolFile | {
+    metadata: PythonProtocolMetadata;
+};
+export declare function parseProtocolData(file: File, contents: string, handleError?: ProtocolParseErrorHandler, metadata?: PythonProtocolMetadata | null): ProtocolData | null;
+export declare function fileExtensionIsPython(filename: string): boolean;
+export declare function fileExtensionIsJson(filename: string): boolean;
+export declare function fileExtensionIsZip(filename: string): boolean;
+export declare function fileIsBinary(file: File): boolean;
+export declare function validateJsonProtocolFileContents(fileContents: string, handleError?: ProtocolParseErrorHandler): JsonProtocolFile | null;
+export declare function getProtocolDesignerApplicationName(protocol: JsonProtocolFile): string | null;
+export {};

package/lib/js/helpers/sortRunTimeParameters.d.ts

@@ -0,0 +1,9 @@
+import type { RunTimeParameter } from '..';
+/**
+ * This function sorts an array of runtime parameters. If a parameter of type 'csv_file' exists,
+ * it moves it to the beginning of the array.
+ *
+ * @param runTimeParameters - An array of runtime parameters.
+ * @returns A new array of runtime parameters with 'csv_file' type parameter at the beginning if it exists.
+ */
+export declare const sortRuntimeParameters: (runTimeParameters: RunTimeParameter[]) => RunTimeParameter[];

package/lib/js/helpers/volume.d.ts

@@ -0,0 +1,4 @@
+import type { LabwareVolumeUnits } from '../types';
+export declare function getDisplayVolume(volumeInMicroliters: number, displayUnits?: LabwareVolumeUnits, digits?: number): string;
+export declare function getAsciiVolumeUnits(displayUnits: LabwareVolumeUnits): string;
+export declare function ensureVolumeUnits(maybeUnits: string | null | undefined): LabwareVolumeUnits;

package/lib/js/helpers/wellIsRect.d.ts

@@ -0,0 +1,3 @@
+import type { WellDefinition } from '../types';
+/** Well is either rect or circle. Depends on whether `diameter` exists */
+export declare function wellIsRect(wellDef: WellDefinition): boolean;

package/lib/js/helpers/wellSets.d.ts

@@ -0,0 +1,27 @@
+import type { LabwareDefinition2, NozzleLayoutConfig, PipetteV2Specs } from '../types';
+type WellSetByPrimaryWell = string[][];
+export interface NozzleLayoutDetails {
+    nozzleConfig: NozzleLayoutConfig;
+    activeNozzleCount: number;
+}
+export interface WellSetForMultiChannelParams {
+    labwareDef: LabwareDefinition2;
+    wellName: string;
+    channels: 8 | 96;
+    pipetteNozzleDetails?: NozzleLayoutDetails;
+}
+export interface WellSetHelpers {
+    getAllWellSetsForLabware: (labwareDef: LabwareDefinition2) => WellSetByPrimaryWell;
+    /** Given a well for a labware, returns the well set it belongs to (or null)
+     * for 8-channel and 96-channel access.
+     * Ex: C2 for 96-flat => ['A2', 'B2', 'C2', ... 'H2']
+     * Or A1 for trough => ['A1', 'A1', 'A1', ...]
+     *
+     * @param {string[] | undefined} pipetteNozzleDetails If specified, return only the wells utilized by the active pipette
+     * nozzle configuration.
+     **/
+    getWellSetForMultichannel: (params: WellSetForMultiChannelParams) => string[] | null | undefined;
+    canPipetteUseLabware: (pipetteSpec: PipetteV2Specs, labwareDef?: LabwareDefinition2, trashName?: string) => boolean;
+}
+export declare const makeWellSetHelpers: () => WellSetHelpers;
+export {};

package/lib/js/index.d.ts

@@ -0,0 +1,17 @@
+export * from '../command';
+export * from '../deck';
+export * from '../protocol';
+export * from './constants';
+export * from './deck';
+export * from './errors';
+export * from './fixtures';
+export * from './getLabware';
+export * from './gripper';
+export * from './helpers';
+export * from './labware';
+export * from './labwareTools';
+export * from './modules';
+export * from './pipettes';
+export * from './protocols';
+export * from './titleCase';
+export * from './types';

package/lib/js/labware.d.ts

@@ -0,0 +1,131 @@
+import labwareSchemaV2 from '../labware/schemas/2.json';
+import fixture96Plate from '../labware/fixtures/2/fixture_96_plate.json';
+import fixture12Trough from '../labware/fixtures/2/fixture_12_trough.json';
+import fixture24Tuberack from '../labware/fixtures/2/fixture_24_tuberack.json';
+import fixtureTiprack10ul from '../labware/fixtures/2/fixture_tiprack_10_ul.json';
+import fixtureTiprack300ul from '../labware/fixtures/2/fixture_tiprack_300_ul.json';
+import fixtureTiprack1000ul from '../labware/fixtures/2/fixture_flex_96_tiprack_1000ul.json';
+import fixtureTiprackAdapter from '../labware/fixtures/2/fixture_flex_96_tiprack_adapter.json';
+import fixtureCalibrationBlock from '../labware/fixtures/2/fixture_calibration_block.json';
+import fixture384Plate from '../labware/fixtures/2/fixture_384_plate.json';
+import fixtureTrash from '../labware/fixtures/2/fixture_trash.json';
+import opentrons96Tiprack10UlV1Uncasted from '../labware/definitions/2/opentrons_96_tiprack_10ul/1.json';
+import type { LabwareDefByDefURI, LabwareDefinition2, LegacyLabwareDefByName } from './types';
+declare const opentrons1Trash3200MlFixedV1: LabwareDefinition2;
+declare const opentrons96PcrAdapterV1: LabwareDefinition2;
+declare const latestDefs: {
+    agilent1Reservoir290MlV1: LabwareDefinition2;
+    appliedbiosystemsmicroamp384Wellplate40UlV1: LabwareDefinition2;
+    armadillo96Wellplate200UlPcrFullSkirtV1: LabwareDefinition2;
+    armadillo96Wellplate200UlPcrFullSkirtV2: LabwareDefinition2;
+    axygen1Reservoir90MlV1: LabwareDefinition2;
+    biorad384Wellplate50UlV1: LabwareDefinition2;
+    biorad384Wellplate50UlV2: LabwareDefinition2;
+    biorad96Wellplate200UlPcrV1: LabwareDefinition2;
+    biorad96Wellplate200UlPcrV2: LabwareDefinition2;
+    corning12Wellplate69MlFlatV1: LabwareDefinition2;
+    corning12Wellplate69MlFlatV2: LabwareDefinition2;
+    corning24Wellplate34MlFlatV1: LabwareDefinition2;
+    corning24Wellplate34MlFlatV2: LabwareDefinition2;
+    corning384Wellplate112UlFlatV1: LabwareDefinition2;
+    corning384Wellplate112UlFlatV2: LabwareDefinition2;
+    corning48Wellplate16MlFlatV1: LabwareDefinition2;
+    corning48Wellplate16MlFlatV2: LabwareDefinition2;
+    corning6Wellplate168MlFlatV1: LabwareDefinition2;
+    corning6Wellplate168MlFlatV2: LabwareDefinition2;
+    corning96Wellplate360UlFlatV1: LabwareDefinition2;
+    corning96Wellplate360UlFlatV2: LabwareDefinition2;
+    eppendorf96Tiprack1000UlEptipsV1: LabwareDefinition2;
+    eppendorf96Tiprack10UlEptipsV1: LabwareDefinition2;
+    geb96Tiprack1000UlV1: LabwareDefinition2;
+    geb96Tiprack10UlV1: LabwareDefinition2;
+    nest12Reservoir15MlV1: LabwareDefinition2;
+    nest1Reservoir195MlV1: LabwareDefinition2;
+    nest1Reservoir195MlV2: LabwareDefinition2;
+    nest1Reservoir290MlV1: LabwareDefinition2;
+    nest96Wellplate100UlPcrFullSkirtV1: LabwareDefinition2;
+    nest96Wellplate100UlPcrFullSkirtV2: LabwareDefinition2;
+    nest96Wellplate200UlFlatV1: LabwareDefinition2;
+    nest96Wellplate200UlFlatV2: LabwareDefinition2;
+    nest96Wellplate2MlDeepV1: LabwareDefinition2;
+    nest96Wellplate2MlDeepV2: LabwareDefinition2;
+    opentrons10TuberackFalcon4X50Ml6X15MlConicalV1: LabwareDefinition2;
+    opentrons10TuberackFalcon4X50Ml6X15MlConicalAcrylicV1: LabwareDefinition2;
+    opentrons10TuberackNest4X50Ml6X15MlConicalV1: LabwareDefinition2;
+    opentrons15TuberackFalcon15MlConicalV1: LabwareDefinition2;
+    opentrons15TuberackNest15MlConicalV1: LabwareDefinition2;
+    opentrons1Trash3200MlFixedV1: LabwareDefinition2;
+    opentrons1Trash1100MlFixedV1: LabwareDefinition2;
+    opentrons1Trash850MlFixedV1: LabwareDefinition2;
+    opentrons24AluminumblockGeneric2MlScrewcapV1: LabwareDefinition2;
+    opentrons24AluminumblockGeneric2MlScrewcapV2: LabwareDefinition2;
+    opentrons24AluminumblockNest05MlScrewcapV1: LabwareDefinition2;
+    opentrons24AluminumblockNest15MlScrewcapV1: LabwareDefinition2;
+    opentrons24AluminumblockNest15MlSnapcapV1: LabwareDefinition2;
+    opentrons24AluminumblockNest2MlScrewcapV1: LabwareDefinition2;
+    opentrons24AluminumblockNest2MlSnapcapV1: LabwareDefinition2;
+    opentrons24TuberackEppendorf15MlSafelockSnapcapV1: LabwareDefinition2;
+    opentrons24TuberackEppendorf2MlSafelockSnapcapV1: LabwareDefinition2;
+    opentrons24TuberackEppendorf2MlSafelockSnapcapAcrylicV1: LabwareDefinition2;
+    opentrons24TuberackGeneric075MlSnapcapAcrylicV1: LabwareDefinition2;
+    opentrons24TuberackGeneric2MlScrewcapV1: LabwareDefinition2;
+    opentrons24TuberackNest05MlScrewcapV1: LabwareDefinition2;
+    opentrons24TuberackNest15MlScrewcapV1: LabwareDefinition2;
+    opentrons24TuberackNest15MlSnapcapV1: LabwareDefinition2;
+    opentrons24TuberackNest2MlScrewcapV1: LabwareDefinition2;
+    opentrons24TuberackNest2MlSnapcapV1: LabwareDefinition2;
+    opentrons40AluminumblockEppendorf24X2MlSafelockSnapcapGeneric16X02MlPcrStripV1: LabwareDefinition2;
+    opentrons6TuberackFalcon50MlConicalV1: LabwareDefinition2;
+    opentrons6TuberackNest50MlConicalV1: LabwareDefinition2;
+    opentrons96DeepWellTempModAdapterV1: LabwareDefinition2;
+    opentrons96AluminumblockBioradWellplate200UlV1: LabwareDefinition2;
+    opentrons96AluminumblockGenericPcrStrip200UlV1: LabwareDefinition2;
+    opentrons96AluminumblockGenericPcrStrip200UlV2: LabwareDefinition2;
+    opentrons96AluminumblockNestWellplate100UlV1: LabwareDefinition2;
+    opentrons96DeepWellAdapterV1: LabwareDefinition2;
+    opentrons96DeepWellAdapterNestWellplate2MlDeepV1: LabwareDefinition2;
+    opentrons96Filtertiprack1000UlV1: LabwareDefinition2;
+    opentrons96Filtertiprack10UlV1: LabwareDefinition2;
+    opentrons96Filtertiprack200UlV1: LabwareDefinition2;
+    opentrons96Filtertiprack20UlV1: LabwareDefinition2;
+    opentrons96FlatBottomAdapterV1: LabwareDefinition2;
+    opentrons96FlatBottomAdapterNestWellplate200UlFlatV1: LabwareDefinition2;
+    opentrons96PcrAdapterV1: LabwareDefinition2;
+    opentrons96PcrAdapterArmadilloWellplate200UlV1: LabwareDefinition2;
+    opentrons96PcrAdapterNestWellplate100UlPcrFullSkirtV1: LabwareDefinition2;
+    opentrons96Tiprack1000UlV1: LabwareDefinition2;
+    opentrons96Tiprack10UlV1: LabwareDefinition2;
+    opentrons96Tiprack20UlV1: LabwareDefinition2;
+    opentrons96Tiprack300UlV1: LabwareDefinition2;
+    opentrons96WellAluminumBlockV1: LabwareDefinition2;
+    opentrons96Wellplate200UlPcrFullSkirtV1: LabwareDefinition2;
+    opentrons96Wellplate200UlPcrFullSkirtV2: LabwareDefinition2;
+    opentronsAluminumFlatBottomPlateV1: LabwareDefinition2;
+    opentronsCalibrationAdapterHeatershakerModuleV1: LabwareDefinition2;
+    opentronsCalibrationAdapterTemperatureModuleV1: LabwareDefinition2;
+    opentronsCalibrationAdapterThermocyclerModuleV1: LabwareDefinition2;
+    opentronsCalibrationblockShortSideLeftV1: LabwareDefinition2;
+    opentronsCalibrationblockShortSideRightV1: LabwareDefinition2;
+    opentronsFlex96Filtertiprack1000UlV1: LabwareDefinition2;
+    opentronsFlex96Filtertiprack200UlV1: LabwareDefinition2;
+    opentronsFlex96Filtertiprack50UlV1: LabwareDefinition2;
+    opentronsFlex96Tiprack1000UlV1: LabwareDefinition2;
+    opentronsFlex96Tiprack200UlV1: LabwareDefinition2;
+    opentronsFlex96Tiprack50UlV1: LabwareDefinition2;
+    opentronsFlex96TiprackAdapterV1: LabwareDefinition2;
+    opentronsFlexDeckRiserV1: LabwareDefinition2;
+    opentronsFlexLidAbsorbancePlateReaderModuleV1: LabwareDefinition2;
+    opentronsToughPcrAutoSealingLidV1: LabwareDefinition2;
+    opentronsUniversalFlatAdapterV1: LabwareDefinition2;
+    opentronsUniversalFlatAdapterCorning384Wellplate112UlFlatV1: LabwareDefinition2;
+    thermoscientificnunc96Wellplate1300UlV1: LabwareDefinition2;
+    thermoscientificnunc96Wellplate2000UlV1: LabwareDefinition2;
+    tipone96Tiprack200UlV1: LabwareDefinition2;
+    usascientific12Reservoir22MlV1: LabwareDefinition2;
+    usascientific96Wellplate24MlDeepV1: LabwareDefinition2;
+};
+declare const getAllLabwareDefs: () => Record<keyof typeof latestDefs, LabwareDefinition2>;
+export declare function getAllDefinitions(blockList?: string[]): LabwareDefByDefURI;
+export declare function getAllLegacyDefinitions(): LegacyLabwareDefByName;
+export { labwareSchemaV2, fixture96Plate, fixture12Trough, fixture24Tuberack, fixtureTiprack10ul, fixtureTiprack300ul, fixtureTiprack1000ul, fixtureTiprackAdapter, opentrons96PcrAdapterV1, opentrons1Trash3200MlFixedV1, fixtureTrash, fixture384Plate, fixtureCalibrationBlock, opentrons96Tiprack10UlV1Uncasted, };
+export { getAllLabwareDefs };

package/lib/js/labwareTools/__tests__/createDefaultDisplayName.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/js/labwareTools/__tests__/createIrregularLabware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/js/labwareTools/__tests__/createLabware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/js/labwareTools/index.d.ts

@@ -0,0 +1,67 @@
+import type { LabwareDefinition2 as Definition, LabwareMetadata as Metadata, LabwareDimensions as Dimensions, LabwareBrand as Brand, LabwareParameters as Params, LabwareWell as Well, LabwareWellProperties as InputWell, LabwareWellGroup as WellGroup, LabwareOffset as Offset, LabwareVolumeUnits as VolumeUnits, ModuleModel, LabwareOffset } from '../types';
+export declare const DEFAULT_CUSTOM_NAMESPACE = "custom_beta";
+interface Cell {
+    row: number;
+    column: number;
+}
+interface GridStart {
+    rowStart: string;
+    colStart: string;
+    rowStride: number;
+    colStride: number;
+}
+type InputParams = Omit<Params, 'loadName'>;
+type InputWellGroup = Omit<WellGroup, 'wells'>;
+export interface BaseLabwareProps {
+    metadata: Metadata;
+    parameters: InputParams;
+    dimensions: Dimensions;
+    brand?: Brand;
+    version?: number;
+    namespace?: string;
+    loadNamePostfix?: string[];
+    strict?: boolean | null;
+    stackingOffsetWithLabware?: Record<string, LabwareOffset>;
+    stackingOffsetWithModule?: Record<ModuleModel, LabwareOffset>;
+}
+export interface RegularLabwareProps extends BaseLabwareProps {
+    offset: Offset;
+    grid: Cell;
+    spacing: Cell;
+    well: InputWell;
+    group?: InputWellGroup;
+}
+export interface IrregularLabwareProps extends BaseLabwareProps {
+    offset: Offset[];
+    grid: Cell[];
+    spacing: Cell[];
+    well: InputWell[];
+    gridStart: GridStart[];
+    group?: InputWellGroup[];
+}
+export declare function _irregularWellName(rowIdx: number, colIdx: number, gridStart: GridStart): string;
+export declare function _calculateWellCoord(rowIdx: number, colIdx: number, spacing: Cell, offset: Offset, well: InputWell): Well;
+export declare function _generateIrregularLoadName(args: {
+    grid: Cell[];
+    well: InputWell[];
+    totalWellCount: number;
+    units: VolumeUnits;
+    brand: string;
+    displayCategory: string;
+    loadNamePostfix?: string[];
+}): string;
+export declare function determineIrregularOrdering(wellsArray: string[]): string[][];
+export interface RegularNameProps {
+    displayCategory: string;
+    displayVolumeUnits: VolumeUnits;
+    gridRows: number;
+    gridColumns: number;
+    totalLiquidVolume: number;
+    brandName?: string;
+    loadNamePostfix?: string[];
+}
+export declare function createRegularLoadName(args: RegularNameProps): string;
+export declare function createDefaultDisplayName(args: RegularNameProps): string;
+export declare function createRegularLabware(args: RegularLabwareProps): Definition;
+export declare function createIrregularLabware(args: IrregularLabwareProps): Definition;
+export {};

package/lib/js/modules.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleModel, ModuleModelWithLegacy, ModuleType, ModuleDefinition } from './types';
+export declare const getModuleDef2: (moduleModel: ModuleModel) => ModuleDefinition;
+export declare function normalizeModuleModel(legacyModule: ModuleModelWithLegacy): ModuleModel;
+export declare function getModuleType(moduleModel: ModuleModel): ModuleType;
+export declare function getModuleDisplayName(moduleModel: ModuleModel): string;
+export declare function checkModuleCompatibility(modelA: ModuleModel, modelB: ModuleModel): boolean;

package/lib/js/pipettes.d.ts

@@ -0,0 +1,15 @@
+import pipetteNameSpecs from '../pipette/definitions/1/pipetteNameSpecs.json';
+import pipetteModelSpecs from '../pipette/definitions/1/pipetteModelSpecs.json';
+import type { PipetteV2Specs, PipetteNameSpecs, PipetteModelSpecs } from './types';
+type SortableProps = 'maxVolume' | 'channels';
+export type PipetteName = keyof typeof pipetteNameSpecs;
+export type PipetteModel = keyof typeof pipetteModelSpecs.config;
+export declare function getPipetteNameSpecs(name: PipetteName): PipetteNameSpecs | null;
+export declare function getPipetteModelSpecs(model: PipetteModel): PipetteModelSpecs | null;
+export declare function getAllPipetteNames(...sortBy: SortableProps[]): PipetteName[];
+export declare function shouldLevel(specs: PipetteNameSpecs): boolean;
+export declare function isFlexPipette(pipetteName: PipetteName): boolean;
+export declare const getIncompatiblePipetteNames: (currentPipette: PipetteName) => string[];
+export * from '../pipette/fixtures/name';
+export * from '../pipette/fixtures/index';
+export declare const getPipetteSpecsV2: (name?: PipetteName | PipetteModel) => PipetteV2Specs | null;

package/lib/js/protocols.d.ts

@@ -0,0 +1,4 @@
+import type * as ProtocolSchemas from '../protocol';
+export type { ProtocolSchemas };
+export declare function validate(toValidate: Record<string, unknown>): Promise<ProtocolSchemas.JsonProtocolFile>;
+export * from '../protocol/fixtures/index';

package/lib/js/schema.d.ts

@@ -0,0 +1,90 @@
+export declare const labwareSchemaV1: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        metadata: {
+            type: string;
+            required: string[];
+            properties: {
+                name: {
+                    type: string;
+                };
+                format: {
+                    enum: string[];
+                };
+                deprecated: {
+                    enum: boolean[];
+                };
+                displayName: {
+                    type: string;
+                };
+                displayCategory: {
+                    type: string;
+                };
+                isValidSource: {
+                    enum: boolean[];
+                };
+                isTiprack: {
+                    enum: boolean[];
+                };
+                tipVolume: {
+                    type: string;
+                    minimum: number;
+                };
+            };
+        };
+        ordering: {
+            type: string;
+            items: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+        };
+        wells: {
+            type: string;
+            patternProperties: {
+                '.*': {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        height: {
+                            type: string;
+                        };
+                        length: {
+                            type: string;
+                            minimum: number;
+                        };
+                        width: {
+                            type: string;
+                            minimum: number;
+                        };
+                        x: {
+                            type: string;
+                        };
+                        y: {
+                            type: string;
+                        };
+                        z: {
+                            type: string;
+                        };
+                        diameter: {
+                            type: string;
+                            minimum: number;
+                        };
+                        depth: {
+                            type: string;
+                            minimum: number;
+                        };
+                        'total-liquid-volume': {
+                            type: string;
+                            minimum: number;
+                        };
+                    };
+                };
+            };
+        };
+    };
+};

package/lib/js/titleCase.d.ts

@@ -0,0 +1 @@
+export declare function titleCase(input: string): string;