@opentrons/step-generation 0.3.0-alpha.0

package/lib/utils/__tests__/getIsSafePipetteMovement.test.d.ts

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

package/lib/utils/__tests__/getLabwareSlot.test.d.ts

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

package/lib/utils/__tests__/glue.test.d.ts

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

package/lib/utils/__tests__/liquidClassUtils.test.d.ts

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

package/lib/utils/__tests__/misc.test.d.ts

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

package/lib/utils/__tests__/modulePipetteCollision.test.d.ts

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

package/lib/utils/__tests__/pythonFileUtils.test.d.ts

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

package/lib/utils/__tests__/pythonFormat.test.d.ts

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

package/lib/utils/__tests__/removePairs.test.d.ts

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

package/lib/utils/__tests__/safePipetteMovements.test.d.ts

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

package/lib/utils/__tests__/stripNoOpMixCommands.test.d.ts

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

package/lib/utils/__tests__/swatchColors.test.d.ts

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

package/lib/utils/__tests__/thermocyclerProfileConversions.test.d.ts

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

package/lib/utils/__tests__/traversals.test.d.ts

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

package/lib/utils/__tests__/utils.test.d.ts

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

package/lib/utils/absorbanceReaderCollision.d.ts

@@ -0,0 +1,2 @@
+import type { RobotState } from '../types';
+export declare const absorbanceReaderCollision: (modules: RobotState['modules'], labware: RobotState['labware'], labwareId: string) => boolean;

package/lib/utils/commandCreatorArgsGetters.d.ts

@@ -0,0 +1,5 @@
+import type { CommandCreatorArgs } from '../types';
+/** If command creator is of a type that uses a pipette, get the pipetteId */
+export declare const getPipetteIdFromCCArgs: (args: CommandCreatorArgs) => string | null;
+/** If command creator is of a type that doesn't ever have wells, return true */
+export declare const getHasNoWellsFromCCArgs: (stepArgs: CommandCreatorArgs) => boolean;

package/lib/utils/commandCreatorsTimeline.d.ts

@@ -0,0 +1,2 @@
+import type { CurriedCommandCreator, InvariantContext, RobotState, Timeline } from '../types';
+export declare const commandCreatorsTimeline: (commandCreators: CurriedCommandCreator[], invariantContext: InvariantContext, initialRobotState: RobotState) => Timeline;

package/lib/utils/constructInvariantContextFromAnalysis.d.ts

@@ -0,0 +1,3 @@
+import type { CompletedProtocolAnalysis, ProtocolAnalysisOutput } from '@opentrons/shared-data';
+import type { InvariantContext } from '../types';
+export declare function constructInvariantContextFromAnalysis(analysis: ProtocolAnalysisOutput | CompletedProtocolAnalysis, config: ProtocolAnalysisOutput['config'], createdDate: Date): InvariantContext;

package/lib/utils/createTimelineFromRunCommands.d.ts

@@ -0,0 +1,11 @@
+import type { RunTimeCommand } from '@opentrons/shared-data';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+export type RunCommandTimelineFrame = RobotStateAndWarnings & {
+    command: RunTimeCommand;
+};
+interface ResultingTimelineFrame {
+    frame: RunCommandTimelineFrame;
+    invariantContext: InvariantContext;
+}
+export declare function getResultingTimelineFrameFromRunCommands(commands: RunTimeCommand[], invariantContext: InvariantContext): ResultingTimelineFrame;
+export {};

package/lib/utils/curryCommandCreator.d.ts

@@ -0,0 +1,8 @@
+import type { CommandCreator, CurriedCommandCreator } from '../types';
+/** Curry a command creator so its args are baked-in,
+ * but it is still open to receiving different input states */
+export declare function curryCommandCreator<Args>(commandCreator: CommandCreator<Args>, args: Args): CurriedCommandCreator;
+/** Curry a CommandCreator but discard any Python code in it.
+ * Useful for compound commands when you need to suppress the Python for some of
+ * the constituent atomic commands. */
+export declare function curryWithoutPython<Args>(commandCreator: CommandCreator<Args>, args: Args): CurriedCommandCreator;

package/lib/utils/getActiveNozzleAmount.d.ts

@@ -0,0 +1,7 @@
+import type { ActiveNozzleNumber, NozzleConfigurationStyle, PipetteV2Specs, PrimaryNozzleConfigurationStyle } from '@opentrons/shared-data';
+export interface ActiveNozzleAmountProps {
+    nozzles: NozzleConfigurationStyle | undefined;
+    pipetteSpec: PipetteV2Specs;
+    primaryNozzle: PrimaryNozzleConfigurationStyle | undefined;
+}
+export declare const getActiveNozzleAmount: (props: ActiveNozzleAmountProps) => ActiveNozzleNumber;

package/lib/utils/getLabwareSlot.d.ts

@@ -0,0 +1,2 @@
+import type { RobotState } from '../types';
+export declare const getLabwareSlot: (labwareId: string, labware: RobotState['labware']) => string;

package/lib/utils/getNozzleConfig.d.ts

@@ -0,0 +1,2 @@
+import type { NozzleConfigurationStyle, PipetteV2Specs } from '@opentrons/shared-data';
+export declare const getNozzleConfig: (nozzles: NozzleConfigurationStyle | undefined, pipetteSpec: PipetteV2Specs) => NozzleConfigurationStyle;

package/lib/utils/heaterShakerCollision.d.ts

@@ -0,0 +1,9 @@
+import type { PipetteV2Specs, RobotType } from '@opentrons/shared-data';
+import type { DeckSlot, LabwareEntities, LabwareEntity, RobotState } from '../types';
+export declare const getIsHeaterShakerEastWestWithLatchOpen: (hwModules: RobotState['modules'], slot: DeckSlot) => boolean;
+export declare const getIsHeaterShakerEastWestMultiChannelPipette: (hwModules: RobotState['modules'], slot: DeckSlot, pipetteSpecs: PipetteV2Specs) => boolean;
+export declare const getIsHeaterShakerNorthSouthOfNonTiprackWithMultiChannelPipette: (hwModules: RobotState['modules'], slot: DeckSlot, pipetteSpecs: PipetteV2Specs, labwareEntity: LabwareEntity) => boolean;
+export declare const getIsTallLabwareEastWestOfHeaterShaker: (labwareState: RobotState['labware'], labwareEntities: LabwareEntities, heaterShakerSlot: string) => boolean;
+export declare const pipetteIntoHeaterShakerLatchOpen: (modules: RobotState['modules'], labware: RobotState['labware'], labwareId: string) => boolean;
+export declare const pipetteAdjacentHeaterShakerWhileShaking: (hwModules: RobotState['modules'], slot: DeckSlot, robotType: RobotType) => boolean;
+export declare const pipetteIntoHeaterShakerWhileShaking: (modules: RobotState['modules'], labware: RobotState['labware'], labwareId: string) => boolean;

package/lib/utils/index.d.ts

@@ -0,0 +1,22 @@
+import { absorbanceReaderCollision } from './absorbanceReaderCollision';
+import { commandCreatorsTimeline } from './commandCreatorsTimeline';
+import { curryCommandCreator, curryWithoutPython } from './curryCommandCreator';
+import { getLabwareSlot } from './getLabwareSlot';
+import { modulePipetteCollision } from './modulePipetteCollision';
+import { reduceCommandCreators } from './reduceCommandCreators';
+import { thermocyclerPipetteCollision } from './thermocyclerPipetteCollision';
+export { absorbanceReaderCollision, commandCreatorsTimeline, curryCommandCreator, curryWithoutPython, reduceCommandCreators, modulePipetteCollision, thermocyclerPipetteCollision, getLabwareSlot, };
+export * from './commandCreatorArgsGetters';
+export * from './constructInvariantContextFromAnalysis';
+export * from './createTimelineFromRunCommands';
+export * from './getNozzleConfig';
+export * from './heaterShakerCollision';
+export * from './liquidClassUtils';
+export * from './liquidUtils';
+export * from './misc';
+export * from './pythonFileUtils';
+export * from './pythonFormat';
+export * from './safePipetteMovements';
+export * from './thermocyclerProfileConversions';
+export * from './traversals';
+export declare const uuid: () => string;

package/lib/utils/liquidClassUtils.d.ts

@@ -0,0 +1,15 @@
+import type { ByTipTypeSetting } from '@opentrons/shared-data';
+import type { ConsolidateArgs, DistributeArgs, LabwareEntities, TransferArgs } from '../types';
+interface CustomLiquidClassPropertiesProps {
+    args: TransferArgs | ConsolidateArgs | DistributeArgs;
+    pipetteName: string;
+    tiprackUri: string;
+    liquidClassValuesForTip: ByTipTypeSetting | null;
+}
+export declare const getCustomLiquidClassProperties: (props: CustomLiquidClassPropertiesProps) => string;
+export declare const getLiquidClassName: (liquidClass: string, showBase?: boolean) => string;
+export declare const getPythonAssignTipRacksString: (args: {
+    labwareEntities: LabwareEntities;
+    tiprackIds: string[];
+}) => string;
+export {};

package/lib/utils/liquidUtils.d.ts

@@ -0,0 +1,13 @@
+import type { LabwareDefinition2 } from '@opentrons/shared-data';
+import type { SingleLabwareLiquidState, WellContents, WellContentsByNumber } from '../types';
+/** All wells for labware, in arbitrary order. */
+export declare function getAllWellsForLabware(def: LabwareDefinition2): string[];
+export type ContentsByWell = Record<string, WellContents> | null;
+export declare const _wellContentsForLabware: (labwareLiquids: SingleLabwareLiquidState, labwareDef: LabwareDefinition2) => ContentsByWell;
+export declare const getVolumesPerLiquid: (wellContents: ContentsByWell, individualIds: string[]) => Record<string, WellContentsByNumber>;
+export declare const getLiquidIdsOnLabwareStack: (wellContents: ContentsByWell[]) => string[];
+export declare const getLiquidIdsOnLabware: (wellContents: ContentsByWell) => string[];
+export declare const MIXED_WELL_COLOR = "#737578";
+export declare const swatchColors: (ingredGroupId: string) => string;
+export type WellFill = Record<string, string>;
+export declare const wellFillFromWellContents: (wellContents: ContentsByWell, displayColors: Record<string, string>) => WellFill;

package/lib/utils/misc.d.ts

@@ -0,0 +1,180 @@
+import { COLUMN_4_SLOTS } from '../constants';
+import type { ActiveNozzleNumber, AddressableAreaName, BlowoutParams, CutoutFixtureId, CutoutId, LabwareDefinition2, LabwareLocationSequence, LoadLabwareRunTimeCommand, LoadLidParams, LoadLidStackRunTimeCommand, NozzleConfigurationStyle, PipetteChannels, PipetteV2Specs, PositionReference, PrimaryNozzleConfigurationStyle, RobotType } from '@opentrons/shared-data';
+import type { CommandCreator, CurriedCommandCreator, FlexStackerModuleState, InvariantContext, LabwareEntities, LabwareTemporalProperties, LocationLiquidState, ModuleEntities, PathOption, RobotState, SourceAndDest, StagingAreaEntities, TrashBinEntities, WasteChuteEntities } from '../types';
+export declare const AIR: '__air__';
+export declare const SOURCE_WELL_BLOWOUT_DESTINATION: 'source_well';
+export declare const DEST_WELL_BLOWOUT_DESTINATION: 'dest_well';
+type trashOrLabware = 'wasteChute' | 'trashBin' | 'labware' | null;
+export declare const getCutoutIdByAddressableArea: (addressableAreaName: AddressableAreaName, cutoutFixtureId: CutoutFixtureId, robotType: RobotType) => CutoutId;
+export declare function getWasteChuteAddressableAreaNamePip(channels: PipetteChannels): AddressableAreaName;
+export declare function getTrashBinAddressableAreaName(trashLocation: CutoutId): AddressableAreaName;
+export declare function getTrashLocationFromAddressableAreaName(addressableAreaName: AddressableAreaName): CutoutId | null;
+export declare function getTrashOrLabware(labwareEntities: LabwareEntities, wasteChuteEntities: WasteChuteEntities, trashBinEntities: TrashBinEntities, destinationId: string): trashOrLabware;
+export declare function repeatArray<T>(array: T[], repeats: number): T[];
+/** Total volume of a location ("air" is not included in the sum) */
+export declare function getLocationTotalVolume(loc: LocationLiquidState): number;
+/** Breaks a liquid volume state into 2 parts. Assumes all liquids are evenly mixed. */
+export declare function splitLiquid(volume: number, sourceLiquidState: LocationLiquidState): SourceAndDest;
+/** The converse of splitLiquid. Adds all of one liquid to the other.
+ * The args are called 'source' and 'dest', but here they're interchangable.
+ */
+export declare function mergeLiquid(source: LocationLiquidState, dest: LocationLiquidState): LocationLiquidState;
+export declare function getWellsForTips(channels: ActiveNozzleNumber, labwareDef: LabwareDefinition2, well: string): {
+    wellsForTips: string[];
+    allWellsShared: boolean;
+};
+export declare const mixBlowoutLocationHelper: (args: {
+    pipette: BlowoutParams['pipetteId'];
+    sourceLabwareId: string;
+    sourceWell: BlowoutParams['wellName'];
+    destLabwareId: string;
+    blowoutLocation: string | null | undefined;
+    flowRate: number;
+    offsetFromTopMm: number;
+    invariantContext: InvariantContext;
+    destWell: BlowoutParams['wellName'] | null;
+}) => CurriedCommandCreator[];
+export declare function createEmptyLiquidState(invariantContext: InvariantContext): RobotState['liquidState'];
+export declare function createTipLiquidState<T>(channels: number, contents: T): Record<string, T>;
+export declare const getDispenseAirGapLocation: (args: {
+    destLabware: string;
+    destWell: string;
+    sourceWell?: string;
+    sourceLabware?: string;
+    blowoutLocation?: string | null;
+}) => {
+    dispenseAirGapLabware: string;
+    dispenseAirGapWell: string;
+};
+export declare function makeInitialRobotState(args: {
+    invariantContext: InvariantContext;
+    labwareLocations: RobotState['labware'];
+    moduleLocations: RobotState['modules'];
+    pipetteLocations: RobotState['pipettes'];
+}): RobotState;
+export declare const getTiprackHasTips: (tipState: RobotState['tipState'], labwareId: string) => boolean;
+export declare const getLabwareHasLiquid: (liquidState: RobotState['liquidState'], labwareId: string) => boolean;
+interface DispenseLocationHelperArgs {
+    destinationId: string;
+    pipetteId: string;
+    volume: number;
+    flowRate: number;
+    xOffset: number;
+    yOffset: number;
+    tipRack: string;
+    primaryNozzle: PrimaryNozzleConfigurationStyle;
+    nozzles: NozzleConfigurationStyle;
+    offsetFromBottomMm?: number;
+    well?: string;
+}
+export declare const dispenseLocationHelper: CommandCreator<DispenseLocationHelperArgs>;
+interface MoveHelperArgs {
+    destinationId: string;
+    pipetteId: string;
+    zOffset: number;
+    primaryNozzle: PrimaryNozzleConfigurationStyle;
+    well?: string;
+}
+export declare const moveHelper: CommandCreator<MoveHelperArgs>;
+interface AirGapLocationArgs {
+    destinationId: string;
+    destWell: string | null;
+    flowRate: number;
+    pipetteId: string;
+    volume: number;
+    blowOutLocation?: string | null;
+    sourceId?: string;
+    sourceWell?: string;
+}
+export declare const airGapLocationHelper: CommandCreator<AirGapLocationArgs>;
+interface DelayLocationHelperArgs {
+    pipetteId: string;
+    destinationId: string;
+    well: string | null;
+    zOffset: number;
+    seconds: number;
+}
+export declare const delayLocationHelper: CommandCreator<DelayLocationHelperArgs>;
+export declare const getSlotInLocationStack: (stack: string[] | null, isStacker?: boolean) => string;
+export declare const getTopLocationInStack: (stack?: string[]) => string;
+export declare const getNearestParentInStack: (stack: string[]) => string | null;
+export declare const getLargestStackInSlot: (labwareState: RobotState['labware'], slot: string) => string[];
+/** Single-slot deck id (e.g. A3) for a staging-area slot (e.g. A4) on Flex. */
+export declare const getFlexStackerCutoutBaseDeckSlotId: (column4StagingSlotId: (typeof COLUMN_4_SLOTS)[number]) => string;
+export declare const column4StagingSlotIdFromFlexStackerShuttleAddressableArea: (addressableAreaName: AddressableAreaName) => (typeof COLUMN_4_SLOTS)[number] | null;
+/** Deck slot id used as the stack suffix for labware on the stacker shuttle. */
+export declare const deckSlotKeyForFlexStackerShuttleAddressableArea: (addressableAreaName: AddressableAreaName) => string | null;
+/**
+ * Staging column ids (A4, B4, …) are the same physical cutout as the stacker's
+ * module slot (A3, B3, …). Labware on the shuttle uses the module slot in
+ * `labware.stack`; normalize here so stack-height checks match.
+ */
+export declare const resolveDeckSlotKeyForLabwareStackInSlot: (deckSlotKey: string | null, modules: RobotState['modules'], moduleEntities: ModuleEntities) => string | null;
+export declare const getFlexStackerShuttleAddressableArea: (moduleSlot: string) => AddressableAreaName | null;
+interface CompatibleWithStack {
+    isCompatible: boolean;
+    isAboveStackLimit: boolean;
+}
+export declare const getIsLabwareCompatibleWithStack: (labwareId: string, stack: string[], labwareEntities: LabwareEntities, moduleEntities: ModuleEntities) => CompatibleWithStack;
+export declare const getModuleIdFromRobotStateStack: (modules: RobotState['modules'], stack?: string[]) => string | null;
+/**
+ * Get the full stack in a slot given labware state
+ * If the slot is offDeck, the offDeckOverrideId must be provided to override the offDeck slot,
+ * since different offDeck stacks specify the same base "slot" being offDeck
+ * @param labware - The labware object containing all labware entities
+ * @param slot - The slot to get the full stack from
+ * @param offDeckOverrideId - Labware ID for an offDeck stack
+ * @returns The top full stack from the labware object
+ */
+export declare const getFullStackFromLabwares: (labware: {
+    [labwareId: string]: LabwareTemporalProperties;
+}, slot: string, offDeckOverrideId?: string) => string[];
+export declare const getTopmostLabwareOnModuleFromStackRobotState: (moduleId: string, labware: {
+    [labwareId: string]: LabwareTemporalProperties;
+}) => string;
+export interface ReferenceVolumes {
+    pushOut: number;
+    airGap: ValueByLiquidHandlingType;
+    correction: ValueByLiquidHandlingType;
+    flowRate: ValueByLiquidHandlingType;
+    conditioning?: number;
+    disposal?: number;
+}
+interface ValueByLiquidHandlingType {
+    aspirate: number;
+    dispense: number;
+}
+export declare const getTransferPlanAndReferenceVolumes: (args: {
+    pipetteSpecs: PipetteV2Specs;
+    tiprackDefinition: LabwareDefinition2 | null;
+    volume: number;
+    path: PathOption;
+    numAspirateWells: number;
+    numDispenseWells: number;
+    aspirateAirGapByVolume: Array<[number, number]>;
+    conditioningByVolume: Array<[number, number]> | null;
+    disposalByVolume: Array<[number, number]> | null;
+}) => {
+    referenceVolumes: ReferenceVolumes;
+    multiWellHandling: {
+        isSupported: boolean;
+        numWellsToFitInTip?: number;
+    };
+};
+export declare const getIsRetractSafeForAirGap: (args: {
+    retractZOffset: number;
+    retractPositionReference: PositionReference;
+    labwareEntities: LabwareEntities;
+    labwareId: string;
+    well: string | null;
+}) => boolean;
+export declare const getStackForLabwareLocation: (locationSequence: LabwareLocationSequence) => string[];
+export declare function createStagingAreaForInvariantContext(params: LoadLidStackRunTimeCommand['params'] | LoadLabwareRunTimeCommand['params'] | LoadLidParams): StagingAreaEntities;
+export declare const getLabwareIdOnHopper: (labware: {
+    [labwareId: string]: LabwareTemporalProperties;
+}, moduleSlotLocation: string) => string;
+export declare const getIsSlotAHopper: (slot: string) => boolean;
+export declare const getLabwareIdOnShuttle: (stackerState: FlexStackerModuleState) => string | null;
+export declare const labwareMatchesLabwareInHopper: (labwareId: string, invariantContext: InvariantContext, stackerState: FlexStackerModuleState | null) => boolean;
+export declare const getIsSpaceInHopper: (stackerState: FlexStackerModuleState | null, labwareEntities: LabwareEntities) => boolean;
+export {};

package/lib/utils/modulePipetteCollision.d.ts

@@ -0,0 +1,7 @@
+import type { InvariantContext, RobotState } from '../types';
+export declare const modulePipetteCollision: (args: {
+    pipette: string | null | undefined;
+    labware: string | null | undefined;
+    invariantContext: InvariantContext;
+    prevRobotState: RobotState;
+}) => boolean;

package/lib/utils/pythonFileUtils.d.ts

@@ -0,0 +1,30 @@
+import type { ProtocolFile, RobotType } from '@opentrons/shared-data';
+import type { ChangeTipOptions, InvariantContext, LabwareEntities, LabwareLiquidState, LabwareTemporalProperties, LiquidEntities, ModuleEntities, ModuleTemporalProperties, PipetteEntities, Timeline, TimelineFrame, TrashBinEntities, WasteChuteEntities } from '../types';
+export declare const PAPI_VERSION = "2.28";
+export declare const PD_APPLICATION_VERSION = "8.11.0";
+export declare function pythonImports(): string;
+export declare function pythonMetadata(fileMetadata: ProtocolFile<{}>['metadata'] & {
+    protocolDesigner?: string;
+} & {
+    internalAppBuildDate?: string;
+}): string;
+export declare function pythonRequirements(robotType: RobotType): string;
+export declare function getLoadModules(moduleEntities: ModuleEntities, moduleRobotState: TimelineFrame['modules']): string;
+export declare function getLoadAdapters(moduleEntities: ModuleEntities, labwareEntities: LabwareEntities, labwareRobotState: TimelineFrame['labware']): string;
+export declare const getLoadLidStacks: (allLabwareEntities: LabwareEntities, labwareRobotState: TimelineFrame['labware']) => string;
+export declare function getLoadLabware(moduleRobotState: TimelineFrame['modules'], moduleEntities: ModuleEntities, allLabwareEntities: LabwareEntities, labwareRobotState: TimelineFrame['labware'], labwareNicknamesById: Record<string, string>): string;
+export declare function getLoadPipettes(pipetteEntities: PipetteEntities, pipetteRobotState: TimelineFrame['pipettes']): string;
+export declare function getDefineLiquids(liquidEntities: LiquidEntities): string;
+export declare function getLoadLiquids(liquidsByLabwareId: LabwareLiquidState, liquidEntities: LiquidEntities, labwareEntities: LabwareEntities): string;
+export declare function getLoadLiquidClasses(allUniqueLiquidClassesFromForms: string[]): string;
+export declare function getLoadTrashBins(trashBinEntities: TrashBinEntities): string;
+export declare function getLoadWasteChute(wasteChuteEntities: WasteChuteEntities): string;
+export declare function stepCommands(robotStateTimeline: Timeline): string;
+export declare function pythonDefRun(invariantContext: InvariantContext, robotState: TimelineFrame, robotStateTimeline: Timeline, liquidsByLabwareId: LabwareLiquidState, labwareNicknamesById: Record<string, string>, robotType: RobotType, allUniqueLiquidClassesFromForms: string[]): string;
+export declare function pythonCustomLabwareDict(labwareEntities: LabwareEntities): string;
+export declare const formatChangeTipArg: (changeTip: ChangeTipOptions) => string;
+export declare const getSetStoredLabware: (moduleEntities: ModuleEntities, labwareEntities: LabwareEntities, labware: {
+    [labwareId: string]: LabwareTemporalProperties;
+}, modules: {
+    [moduleId: string]: ModuleTemporalProperties;
+}, robotStateTimeline: Timeline) => string;

package/lib/utils/pythonFormat.d.ts

@@ -0,0 +1,29 @@
+/** Utility functions for Python code generation. */
+import type { WellLocation } from '@opentrons/shared-data/command/types/support';
+/** The variable name for the ProtocolContext object in the run() function.
+ * Our docs call it `protocol`, which is slightly misleading since the object is not
+ * the protocol itself, but we'll try to stay consistent with the docs.
+ */
+export declare const PROTOCOL_CONTEXT_NAME = "protocol";
+/** The variable name for defining a labware that is off-deck or being moved to off-deck */
+export declare const OFF_DECK = "protocol_api.OFF_DECK";
+/** The variable name for the Python dict containing the custom labware defintions. */
+export declare const CUSTOM_LABWARE_DICT_NAME = "CUSTOM_LABWARE";
+export declare const INDENT = "    ";
+/** Indent each of the lines in `text`. */
+export declare function indentPyLines(text: string): string;
+/** Render an arbitrary JavaScript value to Python. */
+export declare function formatPyValue(value: any): string;
+/** Render the string value to Python. */
+export declare function formatPyStr(str: string): string;
+/** Render an array value as a Python tuple. */
+export declare function formatPyTuple(list: any[]): string;
+/** Render an array value as a Python list. */
+export declare function formatPyList(list: any[]): string;
+/** Render an object as a Python dict. */
+export declare function formatPyDict(dict: Record<string, any>): string;
+/** Render a WellLocation to Python.
+ * Append the returned string to a Python well reference to get the wellLocation relative to the well.
+ */
+export declare function formatPyWellLocation(wellLocation?: WellLocation): string;
+export declare function getChunkForIndentingLists(lists: string[], size: number): string[][];

package/lib/utils/reduceCommandCreators.d.ts

@@ -0,0 +1,2 @@
+import type { CommandCreatorResult, CurriedCommandCreator, InvariantContext, RobotState } from '../types';
+export declare const reduceCommandCreators: (commandCreators: CurriedCommandCreator[], invariantContext: InvariantContext, initialRobotState: RobotState) => CommandCreatorResult;

package/lib/utils/removePairs.d.ts

@@ -0,0 +1 @@
+export declare function removePairs<T>(input: T[], excludeWhen: (arg0: T, arg1: T) => boolean): T[];

package/lib/utils/safePipetteMovements.d.ts

@@ -0,0 +1,49 @@
+import type { AddressableArea, CoordinateTuple, CutoutId, LabwareDefinition, NozzleConfigurationStyle, PipetteChannels, PrimaryNozzleConfigurationStyle } from '@opentrons/shared-data';
+import type { InvariantContext, RobotState, TipState } from '../types';
+interface SlotInfo {
+    addressableArea: AddressableArea | null;
+    position: CoordinateTuple | null;
+}
+export interface Point {
+    x: number;
+    y: number;
+    z?: number;
+}
+export declare const getCutoutIdFromSlot: (slotInfo: SlotInfo) => CutoutId | null;
+export declare const getIsSafePipetteMovement: (args: {
+    robotState: RobotState;
+    invariantContext: InvariantContext;
+    pipetteId: string;
+    labwareId: string;
+    wellLocationOffset?: Point;
+    wellTargetName?: string;
+    primaryNozzle: PrimaryNozzleConfigurationStyle;
+    nozzleConfiguration: NozzleConfigurationStyle;
+}) => boolean;
+interface TipPickupAvailability {
+    isSafe: boolean;
+    isComplete?: boolean;
+}
+export declare const getIsSafePickupWithinTiprack: (args: {
+    tipState: Record<string, TipState>;
+    primaryNozzle: PrimaryNozzleConfigurationStyle;
+    channels: PipetteChannels;
+    nozzleConfiguration: NozzleConfigurationStyle;
+    wellName: string;
+    tiprackDef: LabwareDefinition;
+    tipsToIgnore?: string[];
+}) => TipPickupAvailability;
+export declare const getTipRowName: (wellName: string) => string;
+export declare const getTipColumnName: (wellName: string) => string;
+export declare const getTipColumnIndex: (wellName: string) => number;
+export declare const getDefaultPrimaryNozzle: (args: {
+    nozzles: NozzleConfigurationStyle;
+    channels: PipetteChannels;
+}) => PrimaryNozzleConfigurationStyle;
+export declare const getTargetTipsFromWellSets: (args: {
+    wellSets: string[][];
+    nozzles: NozzleConfigurationStyle;
+    channels: PipetteChannels;
+    primaryNozzle: string;
+}) => string[];
+export {};

package/lib/utils/stripNoOpCommands.d.ts

@@ -0,0 +1,3 @@
+import type { CreateCommand } from '@opentrons/shared-data';
+export declare const _stripNoOpMixCommands: (commands: CreateCommand[]) => CreateCommand[];
+export declare const stripNoOpCommands: (commands: CreateCommand[]) => CreateCommand[];

package/lib/utils/thermocyclerPipetteCollision.d.ts

@@ -0,0 +1,2 @@
+import type { RobotState } from '../types';
+export declare const thermocyclerPipetteCollision: (modules: RobotState['modules'], labware: RobotState['labware'], labwareId: string) => boolean;

package/lib/utils/thermocyclerProfileConversions.d.ts

@@ -0,0 +1,19 @@
+import type { AtomicProfileStep, TCExtendedProfileParams } from '@opentrons/shared-data';
+type ProfileElements = TCExtendedProfileParams['profileElements'];
+interface ThermocyclerProfileRepetitionsForPython {
+    repeatingProfileSteps: AtomicProfileStep[];
+    numRepetitions: number;
+}
+/**
+ * Protocol Engine and step-generation specify Thermocycler profiles as an array of
+ * loops. The Python Protocol API's `execute_profile()` method, on the other hand,
+ * currently only takes a single loop.
+ *
+ * This converts the array-of-loops format to the single-loop format.
+ */
+export declare function getThermocyclerProfileRepetitionsForPython(profileElements: ProfileElements): ThermocyclerProfileRepetitionsForPython;
+/**
+ * Unroll a Thermocycler profile's cycles into an equivalent flat list of steps.
+ */
+export declare function unrollThermocyclerProfile(profileElements: ProfileElements): AtomicProfileStep[];
+export {};

package/lib/utils/thermocyclerStateDiff.d.ts

@@ -0,0 +1,10 @@
+import type { ThermocyclerModuleState, ThermocyclerStateStepArgs } from '../types';
+export interface Diff {
+    lidOpen: boolean;
+    lidClosed: boolean;
+    setBlockTemperature: boolean;
+    deactivateBlockTemperature: boolean;
+    setLidTemperature: boolean;
+    deactivateLidTemperature: boolean;
+}
+export declare const thermocyclerStateDiff: (prevThermocyclerState: ThermocyclerModuleState, args: ThermocyclerStateStepArgs) => Diff;