@opentrons/shared-data 0.1.1 → 0.1.2-alpha.1

package/lib/js/constants.d.ts

@@ -0,0 +1,156 @@
+import type { CutoutFixtureId, CutoutId, AddressableAreaName } from '../deck';
+import type { ModuleType } from './types';
+export declare const SLOT_LENGTH_MM = 127.76;
+export declare const SLOT_WIDTH_MM = 85.48;
+export declare const SLOT_RENDER_WIDTH = 127.76;
+export declare const SLOT_RENDER_HEIGHT = 85.48;
+export declare const FIXED_TRASH_RENDER_HEIGHT = 165.86;
+export declare const STD_SLOT_X_DIM = 128;
+export declare const STD_SLOT_Y_DIM = 86;
+export declare const STD_SLOT_DIVIDER_WIDTH = 4;
+export declare const OPENTRONS_LABWARE_NAMESPACE = "opentrons";
+export declare const FIXED_TRASH_ID = "fixedTrash";
+export declare const THERMOCYCLER: 'thermocycler';
+export declare const TEMPDECK: 'tempdeck';
+export declare const MAGDECK: 'magdeck';
+export declare const MAGNETIC_MODULE_V1: 'magneticModuleV1';
+export declare const MAGNETIC_MODULE_V2: 'magneticModuleV2';
+export declare const TEMPERATURE_MODULE_V1: 'temperatureModuleV1';
+export declare const TEMPERATURE_MODULE_V2: 'temperatureModuleV2';
+export declare const THERMOCYCLER_MODULE_V1: 'thermocyclerModuleV1';
+export declare const THERMOCYCLER_MODULE_V2: 'thermocyclerModuleV2';
+export declare const HEATERSHAKER_MODULE_V1: 'heaterShakerModuleV1';
+export declare const MAGNETIC_BLOCK_V1: 'magneticBlockV1';
+export declare const GRIPPER_V1: 'gripperV1';
+export declare const GRIPPER_V1_1: 'gripperV1.1';
+export declare const GRIPPER_V1_2: 'gripperV1.2';
+export declare const GRIPPER_MODELS: import("./types").GripperModel[];
+export declare const FLEX_DISPLAY_NAME: 'Opentrons Flex';
+export declare const FLEX: 'FLEX';
+export declare const GEN2: 'GEN2';
+export declare const GEN1: 'GEN1';
+export declare const LEFT: 'left';
+export declare const RIGHT: 'right';
+export declare const EXTENSION: 'extension';
+export declare const SPAN7_8_10_11_SLOT: 'span7_8_10_11';
+export declare const TEMPERATURE_MODULE_TYPE: 'temperatureModuleType';
+export declare const MAGNETIC_MODULE_TYPE: 'magneticModuleType';
+export declare const THERMOCYCLER_MODULE_TYPE: 'thermocyclerModuleType';
+export declare const HEATERSHAKER_MODULE_TYPE: 'heaterShakerModuleType';
+export declare const MAGNETIC_BLOCK_TYPE: 'magneticBlockType';
+export declare const MAGNETIC_MODULE_MODELS: import("./types").MagneticModuleModel[];
+export declare const NON_CONNECTING_MODULE_TYPES: ModuleType[];
+export declare const TEMPERATURE_MODULE_MODELS: import("./types").TemperatureModuleModel[];
+export declare const THERMOCYCLER_MODULE_MODELS: import("./types").ThermocyclerModuleModel[];
+export declare const HEATERSHAKER_MODULE_MODELS: "heaterShakerModuleV1"[];
+export declare const MAGNETIC_BLOCK_MODELS: "magneticBlockV1"[];
+export declare const MODULE_MODELS: import("./types").ModuleModel[];
+export declare const MODULE_MODELS_OT2_ONLY: ("magneticModuleV1" | "magneticModuleV2" | "temperatureModuleV1" | "thermocyclerModuleV1")[];
+export declare const MODULE_TYPES: ModuleType[];
+export declare const GEN_ONE_MULTI_PIPETTES: string[];
+export declare const IDENTITY_VECTOR: {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare const ROBOT_MODELS: string[];
+export declare const OT2_ROBOT_TYPE: "OT-2 Standard";
+export declare const FLEX_ROBOT_TYPE: "OT-3 Standard";
+export declare const OT3_PIPETTES: string[];
+export declare const OT2_PIPETTES: string[];
+export declare const MM: 'mm';
+export declare const MAGNETIC_MODULES_MAX_ENGAGE_HEIGHT = 20;
+export declare const MAGNETIC_MODULE_V2_DISNEGAGED_HEIGHT = -2.5;
+export declare const MAGNETIC_MODULE_V1_DISNEGAGED_HEIGHT = -2.5;
+export declare const MAGNETIC_MODULE_TYPE_LABWARE_BOTTOM_HEIGHT = 0;
+export declare const CELSIUS: '°C';
+export declare const TEMP_MIN = 4;
+export declare const TEMP_MAX = 96;
+export declare const TEMP_BLOCK_MAX = 99;
+export declare const TEMP_LID_MIN = 37;
+export declare const TEMP_LID_MAX = 110;
+export declare const HS_TEMP_MIN = 37;
+export declare const HS_TEMP_MAX = 95;
+export declare const MICRO_LITERS = "\u00B5L";
+export declare const RPM: 'RPM';
+export declare const HS_RPM_MIN = 200;
+export declare const HS_RPM_MAX = 3000;
+export declare const TOO_HOT_TEMP = 48.9;
+export declare const MAX_LABWARE_HEIGHT_EAST_WEST_HEATER_SHAKER_MM = 53;
+export declare const OT2_STANDARD_MODEL: 'OT-2 Standard';
+export declare const OT2_STANDARD_DECKID: 'ot2_standard';
+export declare const FLEX_STANDARD_MODEL: 'OT-3 Standard';
+export declare const FLEX_STANDARD_DECKID: 'ot3_standard';
+export declare const SINGLE_CHANNEL: 'Single-Channel';
+export declare const EIGHT_CHANNEL: '8-Channel';
+export declare const NINETY_SIX_CHANNEL: '96-Channel';
+export declare const SINGLE_MOUNT_PIPETTES: 'Single-Channel_and_8-Channel';
+export declare const TC_MODULE_LOCATION_OT2: '7,8,10,11';
+export declare const TC_MODULE_LOCATION_OT3: 'A1+B1';
+export declare const WEIGHT_OF_96_CHANNEL: '~10kg';
+export declare const MOVABLE_TRASH_CUTOUTS: CutoutId[];
+export declare const SINGLE_LEFT_CUTOUTS: CutoutId[];
+export declare const SINGLE_CENTER_CUTOUTS: CutoutId[];
+export declare const SINGLE_RIGHT_CUTOUTS: CutoutId[];
+export declare const STAGING_AREA_CUTOUTS: CutoutId[];
+export declare const WASTE_CHUTE_CUTOUT: 'cutoutD3';
+export declare const A1_ADDRESSABLE_AREA: 'A1';
+export declare const A2_ADDRESSABLE_AREA: 'A2';
+export declare const A3_ADDRESSABLE_AREA: 'A3';
+export declare const A4_ADDRESSABLE_AREA: 'A4';
+export declare const B1_ADDRESSABLE_AREA: 'B1';
+export declare const B2_ADDRESSABLE_AREA: 'B2';
+export declare const B3_ADDRESSABLE_AREA: 'B3';
+export declare const B4_ADDRESSABLE_AREA: 'B4';
+export declare const C1_ADDRESSABLE_AREA: 'C1';
+export declare const C2_ADDRESSABLE_AREA: 'C2';
+export declare const C3_ADDRESSABLE_AREA: 'C3';
+export declare const C4_ADDRESSABLE_AREA: 'C4';
+export declare const D1_ADDRESSABLE_AREA: 'D1';
+export declare const D2_ADDRESSABLE_AREA: 'D2';
+export declare const D3_ADDRESSABLE_AREA: 'D3';
+export declare const D4_ADDRESSABLE_AREA: 'D4';
+export declare const MOVABLE_TRASH_A1_ADDRESSABLE_AREA: 'movableTrashA1';
+export declare const MOVABLE_TRASH_A3_ADDRESSABLE_AREA: 'movableTrashA3';
+export declare const MOVABLE_TRASH_B1_ADDRESSABLE_AREA: 'movableTrashB1';
+export declare const MOVABLE_TRASH_B3_ADDRESSABLE_AREA: 'movableTrashB3';
+export declare const MOVABLE_TRASH_C1_ADDRESSABLE_AREA: 'movableTrashC1';
+export declare const MOVABLE_TRASH_C3_ADDRESSABLE_AREA: 'movableTrashC3';
+export declare const MOVABLE_TRASH_D1_ADDRESSABLE_AREA: 'movableTrashD1';
+export declare const MOVABLE_TRASH_D3_ADDRESSABLE_AREA: 'movableTrashD3';
+export declare const ONE_CHANNEL_WASTE_CHUTE_ADDRESSABLE_AREA: '1ChannelWasteChute';
+export declare const EIGHT_CHANNEL_WASTE_CHUTE_ADDRESSABLE_AREA: '8ChannelWasteChute';
+export declare const NINETY_SIX_CHANNEL_WASTE_CHUTE_ADDRESSABLE_AREA: '96ChannelWasteChute';
+export declare const GRIPPER_WASTE_CHUTE_ADDRESSABLE_AREA: 'gripperWasteChute';
+export declare const ADDRESSABLE_AREA_1: '1';
+export declare const ADDRESSABLE_AREA_2: '2';
+export declare const ADDRESSABLE_AREA_3: '3';
+export declare const ADDRESSABLE_AREA_4: '4';
+export declare const ADDRESSABLE_AREA_5: '5';
+export declare const ADDRESSABLE_AREA_6: '6';
+export declare const ADDRESSABLE_AREA_7: '7';
+export declare const ADDRESSABLE_AREA_8: '8';
+export declare const ADDRESSABLE_AREA_9: '9';
+export declare const ADDRESSABLE_AREA_10: '10';
+export declare const ADDRESSABLE_AREA_11: '11';
+export declare const OT2_SINGLE_SLOT_ADDRESSABLE_AREAS: AddressableAreaName[];
+export declare const FLEX_SINGLE_SLOT_ADDRESSABLE_AREAS: AddressableAreaName[];
+export declare const FLEX_STAGING_AREA_SLOT_ADDRESSABLE_AREAS: AddressableAreaName[];
+export declare const MOVABLE_TRASH_ADDRESSABLE_AREAS: AddressableAreaName[];
+export declare const WASTE_CHUTE_ADDRESSABLE_AREAS: AddressableAreaName[];
+export declare const SINGLE_LEFT_SLOT_FIXTURE: 'singleLeftSlot';
+export declare const SINGLE_CENTER_SLOT_FIXTURE: 'singleCenterSlot';
+export declare const SINGLE_RIGHT_SLOT_FIXTURE: 'singleRightSlot';
+export declare const STAGING_AREA_RIGHT_SLOT_FIXTURE: 'stagingAreaRightSlot';
+export declare const TRASH_BIN_ADAPTER_FIXTURE: 'trashBinAdapter';
+export declare const WASTE_CHUTE_RIGHT_ADAPTER_COVERED_FIXTURE: 'wasteChuteRightAdapterCovered';
+export declare const WASTE_CHUTE_RIGHT_ADAPTER_NO_COVER_FIXTURE: 'wasteChuteRightAdapterNoCover';
+export declare const STAGING_AREA_SLOT_WITH_WASTE_CHUTE_RIGHT_ADAPTER_COVERED_FIXTURE: 'stagingAreaSlotWithWasteChuteRightAdapterCovered';
+export declare const STAGING_AREA_SLOT_WITH_WASTE_CHUTE_RIGHT_ADAPTER_NO_COVER_FIXTURE: 'stagingAreaSlotWithWasteChuteRightAdapterNoCover';
+export declare const SINGLE_SLOT_FIXTURES: CutoutFixtureId[];
+export declare const WASTE_CHUTE_FIXTURES: CutoutFixtureId[];
+export declare const WASTE_CHUTE_ONLY_FIXTURES: CutoutFixtureId[];
+export declare const WASTE_CHUTE_STAGING_AREA_FIXTURES: CutoutFixtureId[];
+export declare const LOW_VOLUME_PIPETTES: string[];
+export declare const DEFAULT_LIQUID_COLORS: string[];
+export declare const DEPRECATED_WHALE_GREY = "#9395a0";

package/lib/js/cypressUtils.d.ts

@@ -0,0 +1 @@
+export declare const expectDeepEqual: (assert: any, a: any, b: any) => void;

package/lib/js/errors.d.ts

@@ -0,0 +1,13 @@
+import errorDefinitions from '../errors/definitions/1/errors.json';
+export declare type ErrorCodes = keyof typeof errorDefinitions.codes;
+export declare type ErrorCategories = keyof typeof errorDefinitions.categories;
+export interface ErrorCategory {
+    detail: string;
+    codePrefix: string;
+}
+export interface ErrorBody {
+    detail: string;
+    category: ErrorCategory;
+    code: ErrorCodes;
+}
+export declare function getError(code: ErrorCodes): ErrorBody | null;

package/lib/js/fixtures.d.ts

@@ -0,0 +1,13 @@
+import type { CutoutFixtureId, CutoutId, OT2CutoutId } from '../deck';
+import type { AddressableArea, CoordinateTuple, DeckDefinition } from './types';
+export declare function getCutoutDisplayName(cutout: CutoutId): string;
+export declare const OT2_CUTOUT_BY_SLOT_ID: {
+    [slotId: string]: OT2CutoutId;
+};
+export declare const FLEX_CUTOUT_BY_SLOT_ID: {
+    [slotId: string]: CutoutId;
+};
+export declare function getPositionFromSlotId(slotId: string, deckDef: DeckDefinition): CoordinateTuple | null;
+export declare function getAddressableAreaFromSlotId(slotId: string, deckDef: DeckDefinition): AddressableArea | null;
+export declare function getFixtureDisplayName(cutoutFixtureId: CutoutFixtureId | null): string;
+export declare const isAddressableAreaStandardSlot: (addressableAreaId: string, deckDef: DeckDefinition) => boolean;

package/lib/js/getLabware.d.ts

@@ -0,0 +1,8 @@
+import type { LabwareDefinition1, LabwareDefinition2, WellDefinition } from './types';
+export declare const LABWAREV2_DO_NOT_LIST: string[];
+export declare const PD_DO_NOT_LIST: string[];
+export declare function getIsLabwareV1Tiprack(def: LabwareDefinition1): boolean;
+export declare function getIsTiprack(labwareDef: LabwareDefinition2): boolean;
+export declare function getLabwareDefaultEngageHeight(labwareDef: LabwareDefinition2): number | null;
+/** For display. Flips Y axis to match SVG, applies offset to wells */
+export declare function getWellPropsForSVGLabwareV1(def: LabwareDefinition1): Record<string, WellDefinition>;

package/lib/js/gripper.d.ts

@@ -0,0 +1,3 @@
+import type { GripperModel, GripperDefinition } from './types';
+export declare const getGripperDef: (gripperModel: GripperModel) => GripperDefinition;
+export declare function getGripperDisplayName(gripperModel: GripperModel): string;

package/lib/js/helpers/__tests__/getAdapterName.test.d.ts

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

package/lib/js/helpers/__tests__/getDeckDefFromLoadedLabware.test.d.ts

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

package/lib/js/helpers/__tests__/getSimplestFlexDeckConfig.test.d.ts

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

package/lib/js/helpers/__tests__/getVectorDifference.test.d.ts

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

package/lib/js/helpers/__tests__/getVectorSum.test.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export declare function get96Channel384WellPlateWells(all384Wells: string[], well: string): string[];

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

@@ -0,0 +1,4 @@
+import type { AddressableAreaName } from '../../deck';
+import type { ProtocolAnalysisOutput } from '../../protocol';
+import type { CompletedProtocolAnalysis, DeckDefinition } from '../types';
+export declare function getAddressableAreasInProtocol(protocolAnalysis: CompletedProtocolAnalysis | ProtocolAnalysisOutput, deckDef: DeckDefinition): AddressableAreaName[];

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

@@ -0,0 +1,5 @@
+import type { RunTimeCommand, LabwareDefinition2 } from '..';
+export interface LabwareDefinitionsByUri {
+    [defURI: string]: LabwareDefinition2;
+}
+export declare function getLoadedLabwareDefinitionsByUri(commands: RunTimeCommand[]): LabwareDefinitionsByUri;

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

@@ -0,0 +1,16 @@
+import { ModuleType, ModuleOrientation } from '../types';
+export interface ModuleVizDims {
+    xOffset: number;
+    yOffset: number;
+    xDimension: number;
+    yDimension: number;
+    childXOffset: number;
+    childYOffset: number;
+    childXDimension: number;
+    childYDimension: number;
+}
+export declare const getModuleVizDims: (orientation: ModuleOrientation, moduleType: ModuleType) => ModuleVizDims;
+declare type DeckSlot = string;
+export declare const inferModuleOrientationFromSlot: (slot: DeckSlot) => ModuleOrientation;
+export declare const inferModuleOrientationFromXCoordinate: (xCoordinate: number) => ModuleOrientation;
+export {};

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

@@ -0,0 +1,2 @@
+import type { ModuleType, RobotType } from '..';
+export declare function getOccludedSlotCountForModule(moduleType: ModuleType, robotType: RobotType): number;

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

@@ -0,0 +1,14 @@
+import type { AddressableAreaName, CutoutId } from '../../deck';
+import type { ProtocolAnalysisOutput } from '../../protocol';
+import type { CutoutConfig, CutoutFixture, DeckDefinition, DeckConfiguration, CompletedProtocolAnalysis } from '../types';
+export interface CutoutConfigProtocolSpec extends CutoutConfig {
+    requiredAddressableAreas: AddressableAreaName[];
+}
+export declare const FLEX_SIMPLEST_DECK_CONFIG: DeckConfiguration;
+export declare const FLEX_SIMPLEST_DECK_CONFIG_PROTOCOL_SPEC: CutoutConfigProtocolSpec[];
+export declare function getSimplestDeckConfigForProtocol(protocolAnalysis: CompletedProtocolAnalysis | ProtocolAnalysisOutput | null): CutoutConfigProtocolSpec[];
+export declare function getCutoutFixturesForAddressableAreas(addressableAreas: AddressableAreaName[], cutoutFixtures: CutoutFixture[]): CutoutFixture[];
+export declare function getCutoutFixturesForCutoutId(cutoutId: CutoutId, cutoutFixtures: CutoutFixture[]): CutoutFixture[];
+export declare function getCutoutIdForSlotName(slotName: string, deckDef: DeckDefinition): CutoutId | null;
+export declare function getCutoutIdForAddressableArea(addressableArea: AddressableAreaName, cutoutFixtures: CutoutFixture[]): CutoutId | null;
+export declare function getSimplestFixtureForAddressableAreas(cutoutId: CutoutId, requiredAddressableAreas: AddressableAreaName[], allCutoutFixtures: CutoutFixture[]): CutoutFixture | null;

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

@@ -0,0 +1,2 @@
+import type { Coordinates } from '../types';
+export declare function getVectorDifference(pointA: Coordinates, pointB: Coordinates): Coordinates;

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

@@ -0,0 +1,2 @@
+import type { Coordinates } from '../types';
+export declare function getVectorSum(pointA: Coordinates, pointB: Coordinates): Coordinates;

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

@@ -0,0 +1,3 @@
+import type { LabwareDefinition2 } from '../types';
+export declare function findWellAt(labwareDef: LabwareDefinition2, x: number, y: number): string | null | undefined;
+export declare function getWellNamePerMultiTip(labwareDef: LabwareDefinition2, topWellName: string, channels: 8 | 96): string[] | null;

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

@@ -0,0 +1,2 @@
+import type { LabwareDefinition2 } from '../types';
+export declare const getWellTotalVolume: (labwareDef: LabwareDefinition2, wellName: string) => number | null | undefined;

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

@@ -0,0 +1,44 @@
+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 * from './parseProtocolData';
+export * from './volume';
+export * from './wellSets';
+export * from './getModuleVizDims';
+export * from './getVectorDifference';
+export * from './getVectorSum';
+export * from './getLoadedLabwareDefinitionsByUri';
+export * from './getOccludedSlotCountForModule';
+export * from './labwareInference';
+export * from './getAddressableAreasInProtocol';
+export * from './getSimplestFlexDeckConfig';
+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 getSlotHasMatingSurfaceUnitVector: (deckDef: DeckDefinition, addressableAreaName: string) => boolean;
+export declare const getAreSlotsHorizontallyAdjacent: (slotNameA?: string | null | undefined, slotNameB?: string | null | undefined) => boolean;
+export declare const getAreSlotsVerticallyAdjacent: (slotNameA?: string | null | undefined, slotNameB?: string | null | undefined) => boolean;
+export declare const getAreSlotsAdjacent: (slotNameA?: string | null | undefined, slotNameB?: string | null | undefined) => 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/orderWells.d.ts

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

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

@@ -0,0 +1,23 @@
+import type { ErrorObject } from 'ajv';
+import type { JsonProtocolFile } from '../../protocol';
+export declare type ProtocolParseErrorKey = 'INVALID_FILE_TYPE' | 'INVALID_JSON_FILE';
+interface ProtocolParseErrorDetails {
+    rawError?: string;
+    schemaErrors?: ErrorObject[] | null;
+}
+export declare type ProtocolParseErrorHandler = (errorKey: ProtocolParseErrorKey, errorDetails?: ProtocolParseErrorDetails) => unknown;
+export interface PythonProtocolMetadata {
+    source?: string;
+    [key: string]: unknown;
+}
+export declare 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/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,9 @@
+import type { LabwareDefinition2, PipetteNameSpecs } from '../types';
+declare type WellSetByPrimaryWell = string[][];
+export interface WellSetHelpers {
+    getAllWellSetsForLabware: (labwareDef: LabwareDefinition2) => WellSetByPrimaryWell;
+    getWellSetForMultichannel: (labwareDef: LabwareDefinition2, well: string, channels: 8 | 96) => string[] | null | undefined;
+    canPipetteUseLabware: (pipetteSpec: PipetteNameSpecs, labwareDef?: LabwareDefinition2, trashName?: string) => boolean;
+}
+export declare const makeWellSetHelpers: () => WellSetHelpers;
+export {};

package/lib/js/index.d.ts

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

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,65 @@
+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 } 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;
+}
+declare type InputParams = Omit<Params, 'loadName'>;
+declare 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;
+}
+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,13 @@
+import pipetteNameSpecs from '../pipette/definitions/1/pipetteNameSpecs.json';
+import pipetteModelSpecs from '../pipette/definitions/1/pipetteModelSpecs.json';
+import type { PipetteNameSpecs, PipetteModelSpecs } from './types';
+declare type SortableProps = 'maxVolume' | 'channels';
+export declare type PipetteName = keyof typeof pipetteNameSpecs;
+export declare type PipetteModel = keyof typeof pipetteModelSpecs.config;
+export declare function getPipetteNameSpecs(name: PipetteName): PipetteNameSpecs | null;
+export declare function getPipetteModelSpecs(model: PipetteModel): PipetteModelSpecs | null | undefined;
+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 {};

package/lib/js/protocols.d.ts

@@ -0,0 +1,3 @@
+import type * as ProtocolSchemas from '../protocol';
+export type { ProtocolSchemas };
+export declare function validate(toValidate: any): Promise<ProtocolSchemas.JsonProtocolFile>;

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;