@opentrons/step-generation 0.3.0-alpha.0

package/lib/fixtures/commandFixtures.d.ts

@@ -0,0 +1,511 @@
+import type { AddressableAreaName, AspDispAirgapParams, AspirateInPlaceParams, BlowoutParams, CreateCommand, DispenseInPlaceParams, DispenseParams, MoveToWellParams, NozzleConfigurationParams, TouchTipParams, WellLocation } from '@opentrons/shared-data';
+import type { CommandCreatorErrorResponse, CommandsAndWarnings } from '../types';
+/** Used to wrap command creators in tests, effectively casting their results
+ **  to normal response or error response
+ **/
+export declare function getSuccessResult(result: CommandsAndWarnings | CommandCreatorErrorResponse): CommandsAndWarnings;
+export declare function getErrorResult(result: CommandsAndWarnings | CommandCreatorErrorResponse): CommandCreatorErrorResponse;
+export declare const replaceTipCommands: (tip: number | string) => CreateCommand[];
+export declare const prepareAndConfigureCommands: (volumeToConfigure?: number) => CreateCommand[];
+export declare const BLOWOUT_FLOW_RATE = 2.3;
+export declare const ASPIRATE_OFFSET_FROM_BOTTOM_MM = 3.1;
+export declare const DISPENSE_OFFSET_FROM_BOTTOM_MM = 3.2;
+export declare const BLOWOUT_OFFSET_FROM_TOP_MM = 3.3;
+interface FlowRateAndOffsetParamsTransferlike {
+    aspirateFlowRateUlSec: number;
+    dispenseFlowRateUlSec: number;
+    blowoutFlowRateUlSec: number;
+    aspirateOffsetFromBottomMm: number;
+    dispenseOffsetFromBottomMm: number;
+    blowoutOffsetFromTopMm: number;
+    touchTipAfterAspirateOffsetMmFromTop: number;
+    touchTipAfterDispenseOffsetMmFromTop: number;
+}
+export declare const getFlowRateAndOffsetParamsTransferLike: () => FlowRateAndOffsetParamsTransferlike;
+interface FlowRateAndOffsetParamsMix {
+    aspirateFlowRateUlSec: number;
+    dispenseFlowRateUlSec: number;
+    blowoutFlowRateUlSec: number;
+    aspirateOffsetFromBottomMm: number;
+    dispenseOffsetFromBottomMm: number;
+    blowoutOffsetFromTopMm: number;
+    touchTipMmFromTop: number;
+}
+export declare const getFlowRateAndOffsetParamsMix: () => FlowRateAndOffsetParamsMix;
+type MakeAspDispHelper<P> = (bakedParams?: Partial<P>) => (well: string, volume: number, params?: Partial<P>) => CreateCommand;
+type MakeAspDispCompoundHelper<P, P2> = (bakedParams?: Partial<P>) => (inPlaceParams: P, moveToWellParams?: P2, doMove?: boolean) => CreateCommand[];
+export declare const makeAspirateHelper: MakeAspDispHelper<AspDispAirgapParams>;
+export declare const makeAspirateInPlaceHelper: MakeAspDispCompoundHelper<AspirateInPlaceParams, MoveToWellParams>;
+export declare const makeDispenseInPlaceHelper: MakeAspDispCompoundHelper<DispenseInPlaceParams, MoveToWellParams>;
+export declare const aspirateHelperLiquidClass: (submergeParams: {
+    pipetteId: string;
+    labwareId: string;
+    wellName: string;
+    volume: number;
+    submergeSpeed: number;
+    retractSpeed: number;
+    aspirateFlowRate: number;
+    submergeLocation: WellLocation;
+    aspirateLocation: WellLocation;
+    retractLocation: WellLocation;
+    aspirateAirGap?: number;
+    dispenseAirGap?: number;
+    dispenseFlowRate?: number;
+    shouldProbe?: boolean;
+    shouldPreWet?: boolean;
+    shouldTouchTip?: boolean;
+    submergeDelay?: number;
+    aspirateDelay?: number;
+    retractDelay?: number;
+    dispenseDelay?: number;
+    mixTimes?: number;
+    mixVolume?: number;
+    touchTipMmFromTop?: number;
+    touchTipMmFromEdge?: number;
+    touchTipSpeed?: number;
+    isRetractSafeForAirGap?: boolean;
+}) => ({
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        labwareId: string;
+        wellName: string;
+        wellLocation: WellLocation;
+        volume?: undefined;
+        flowRate?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        volume: number;
+        flowRate: number | undefined;
+        pushOut: number;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta: {
+        isAirGap: boolean;
+    };
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        seconds: number;
+        pipetteId?: undefined;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        volume?: undefined;
+        flowRate?: undefined;
+        pushOut?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        volume?: undefined;
+        flowRate?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        labwareId: string;
+        speed: number;
+        wellName: string;
+        wellLocation: WellLocation;
+        volume?: undefined;
+        flowRate?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        volume: number;
+        flowRate: number;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        volume: number;
+        flowRate: number | undefined;
+        pushOut: number;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        labwareId: string;
+        wellName: string;
+        wellLocation: {
+            origin: "top";
+            offset: {
+                z: number | undefined;
+            };
+        };
+        mmFromEdge: number | undefined;
+        speed: number | undefined;
+        volume?: undefined;
+        flowRate?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+    };
+    meta?: undefined;
+})[];
+export declare const blowoutInTrashCommands: (args: {
+    pipetteId: string;
+    addressableAreaName: string;
+    blowoutFlowRate: number;
+    dispenseAirGap?: number;
+    aspirateDelay?: number;
+    aspirateFlowRate?: number;
+}) => ({
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        addressableAreaName: string;
+        offset: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        flowRate?: undefined;
+        seconds?: undefined;
+    };
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        flowRate: number;
+        addressableAreaName?: undefined;
+        offset?: undefined;
+        seconds?: undefined;
+    };
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        addressableAreaName?: undefined;
+        offset?: undefined;
+        flowRate?: undefined;
+        seconds?: undefined;
+    };
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        flowRate?: number | undefined;
+        pipetteId: string;
+        volume: number;
+        addressableAreaName?: undefined;
+        offset?: undefined;
+        seconds?: undefined;
+    };
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        seconds: number;
+        pipetteId?: undefined;
+        addressableAreaName?: undefined;
+        offset?: undefined;
+        flowRate?: undefined;
+    };
+})[];
+export declare const dispenseHelperLiquidClass: (params: {
+    pipetteId: string;
+    labwareId: string;
+    wellName: string;
+    volume: number;
+    submergeSpeed: number;
+    retractSpeed: number;
+    dispenseFlowRate: number;
+    submergeLocation: WellLocation;
+    dispenseLocation: WellLocation;
+    retractLocation: WellLocation;
+    aspirateFlowRate?: number;
+    aspirateAirGap?: number;
+    dispenseAirGap?: number;
+    shouldTouchTip?: boolean;
+    submergeDelay?: number;
+    aspirateDelay?: number;
+    retractDelay?: number;
+    dispenseDelay?: number;
+    mixTimes?: number;
+    mixVolume?: number;
+    touchTipMmFromTop?: number;
+    touchTipMmFromEdge?: number;
+    touchTipSpeed?: number;
+    pushOut?: number;
+    shouldBlowoutInDestination?: boolean;
+    blowoutFlowRate?: number;
+    isRetractSafeForAirGap?: boolean;
+}) => ({
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        labwareId: string;
+        wellName: string;
+        wellLocation: WellLocation;
+        volume?: undefined;
+        flowRate?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        volume: number;
+        flowRate: number;
+        pushOut: number;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta: {
+        isAirGap: boolean;
+    };
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        seconds: number;
+        pipetteId?: undefined;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        volume?: undefined;
+        flowRate?: undefined;
+        pushOut?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        labwareId: string;
+        speed: number;
+        wellName: string;
+        wellLocation: WellLocation;
+        volume?: undefined;
+        flowRate?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pushOut?: number | undefined;
+        pipetteId: string;
+        volume: number;
+        flowRate: number;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        volume: number;
+        flowRate: number | undefined;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        flowRate: number | undefined;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        volume?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        labwareId: string;
+        wellName: string;
+        wellLocation: {
+            origin: "top";
+            offset: {
+                z: number | undefined;
+            };
+        };
+        mmFromEdge: number | undefined;
+        speed: number | undefined;
+        volume?: undefined;
+        flowRate?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+    };
+    meta?: undefined;
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        labwareId?: undefined;
+        wellName?: undefined;
+        wellLocation?: undefined;
+        volume?: undefined;
+        flowRate?: undefined;
+        pushOut?: undefined;
+        seconds?: undefined;
+        speed?: undefined;
+        mmFromEdge?: undefined;
+    };
+    meta?: undefined;
+})[];
+export declare const makeMoveToWellHelper: (wellName: string, labwareId?: string) => {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        labwareId: string;
+        wellName: string;
+        wellLocation: {
+            origin: string;
+            offset: {
+                x: number;
+                y: number;
+                z: number;
+            };
+        };
+    };
+};
+export declare const makeAirGapAfterAspirateHelper: (volume: number, flowRate?: number) => {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        volume: number;
+        flowRate: number;
+    };
+};
+export declare const makeAirGapHelper: (volume: number, flowRate?: number) => ({
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        volume?: undefined;
+        flowRate?: undefined;
+    };
+} | {
+    commandType: string;
+    key: any;
+    params: {
+        pipetteId: string;
+        volume: number;
+        flowRate: number;
+    };
+})[];
+export declare const blowoutHelper: (labware: string, params?: Partial<BlowoutParams>) => CreateCommand;
+export declare const blowoutInPlaceHelper: () => CreateCommand[];
+export declare const makeDispenseHelper: MakeAspDispHelper<DispenseParams>;
+export declare const makeDispenseAirGapHelper: (wellName: string, volume: number) => CreateCommand;
+type MakeTouchTipHelper = (bakedParams?: Partial<TouchTipParams>) => (wellName: string, params?: Partial<TouchTipParams>) => CreateCommand;
+export declare const makeTouchTipHelper: MakeTouchTipHelper;
+export declare const delayCommand: (seconds: number, message?: string) => CreateCommand;
+export declare const delayWithOffset: (wellName: string, labwareId: string, seconds?: number, zOffset?: number, forceDirect?: boolean, minimumZHeight?: number, message?: string) => CreateCommand[];
+export declare const dropTipHelper: (pipette?: string) => CreateCommand[];
+export declare const dropTipIntoWasteChuteHelper: (pipette?: string) => CreateCommand[];
+export declare const configureNozzleLayoutHelper: (pipetteId: string, configurationParams: NozzleConfigurationParams) => CreateCommand;
+export declare const pickUpTipHelper: (tip: number | string, params?: {
+    pipetteId?: string;
+    labwareId?: string;
+}) => CreateCommand;
+export declare const dropTipInPlaceHelper: (params?: {
+    pipetteId?: string;
+}) => CreateCommand;
+export declare const moveToAddressableAreaHelper: (params?: {
+    pipetteId?: string;
+    addressableAreaName: AddressableAreaName;
+}) => CreateCommand;
+export {};

package/lib/fixtures/data.d.ts

@@ -0,0 +1,12 @@
+export declare const tiprackWellNamesFlat: string[];
+export declare const DEFAULT_PIPETTE = "p300SingleId";
+export declare const MULTI_PIPETTE = "p300MultiId";
+export declare const PIPETTE_96 = "p100096Id";
+export declare const SOURCE_LABWARE = "sourcePlateId";
+export declare const DEST_LABWARE = "destPlateId";
+export declare const TROUGH_LABWARE = "troughId";
+export declare const DEFAULT_BLOWOUT_WELL = "A1";
+export declare const TIPRACK_1 = "tiprack1Id";
+export declare const AIR_GAP_META: {
+    isAirGap: boolean;
+};

package/lib/fixtures/index.d.ts

@@ -0,0 +1,3 @@
+export * from './robotStateFixtures';
+export * from './commandFixtures';
+export * from './data';

package/lib/fixtures/robotStateFixtures.d.ts

@@ -0,0 +1,39 @@
+import { TEMPERATURE_DEACTIVATED } from '../constants';
+import type { Config, InvariantContext, RobotState, RobotStateAndWarnings } from '../';
+import type { TEMPERATURE_APPROACHING_TARGET, TEMPERATURE_AT_TARGET } from '../constants';
+import type { TipState } from '../types';
+export declare const DEFAULT_CONFIG: Config;
+type WellTipState = Record<string, TipState>;
+export declare function getTiprackTipstate(filled: boolean | null | undefined): WellTipState;
+export declare function getTipColumn<T>(index: number, filled: T): Record<string, T>;
+export declare function makeContext(): InvariantContext;
+export declare const makeState: (args: {
+    invariantContext: InvariantContext;
+    labwareLocations: RobotState['labware'];
+    moduleLocations?: RobotState['modules'];
+    pipetteLocations: RobotState['pipettes'];
+    tiprackSetting: Record<string, boolean>;
+}) => RobotState;
+interface StandardMakeStateArgs {
+    pipetteLocations: RobotState['pipettes'];
+    labwareLocations: RobotState['labware'];
+    moduleLocations: RobotState['modules'];
+}
+export declare const makeStateArgsStandard: () => StandardMakeStateArgs;
+export declare const makeStateArgsLabwareOffDeck: () => StandardMakeStateArgs;
+export declare const getInitialRobotStateStandard: (invariantContext: InvariantContext) => RobotState;
+export declare const getInitialRobotStateWithOffDeckLabwareStandard: (invariantContext: InvariantContext) => RobotState;
+export declare const getRobotStateAndWarningsStandard: (invariantContext: InvariantContext) => RobotStateAndWarnings;
+export declare const getRobotStateWithTipStandard: (invariantContext: InvariantContext) => RobotState;
+export declare const getRobotStatePickedUpTipStandard: (invariantContext: InvariantContext) => RobotState;
+export declare const getRobotInitialStateNoTipsRemain: (invariantContext: InvariantContext) => RobotState;
+interface StateAndContext {
+    robotState: RobotState;
+    invariantContext: InvariantContext;
+}
+export declare const getStateAndContextTempTCModules: ({ temperatureModuleId, thermocyclerId, }: {
+    temperatureModuleId: string;
+    thermocyclerId: string;
+}) => StateAndContext;
+export declare const robotWithStatusAndTemp: (robotState: RobotState, temperatureModuleId: string, status: typeof TEMPERATURE_AT_TARGET | typeof TEMPERATURE_APPROACHING_TARGET | typeof TEMPERATURE_DEACTIVATED, targetTemperature: number | null) => RobotState;
+export {};

package/lib/getNextRobotStateAndWarnings/__tests__/dispenseUpdateLiquidState.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/__tests__/forAspirate.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/__tests__/forBlowout.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/__tests__/forDropTip.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/__tests__/forMoveLabware.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/__tests__/forPickUpTip.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/__tests__/heaterShakerUpdates.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/__tests__/stackerUpdates.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/__tests__/temperatureUpdates.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/__tests__/thermocyclerUpdates.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/__tests__/updateMagneticModule.test.d.ts

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

package/lib/getNextRobotStateAndWarnings/absorbanceReaderUpdates.d.ts

@@ -0,0 +1,5 @@
+import type { AbsorbanceReaderInitializeParams, ModuleOnlyParams } from '@opentrons/shared-data';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+export declare const forAbsorbanceReaderOpenLid: (params: ModuleOnlyParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings) => void;
+export declare const forAbsorbanceReaderCloseLid: (params: ModuleOnlyParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings) => void;
+export declare const forAbsorbanceReaderInitialize: (params: AbsorbanceReaderInitializeParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings) => void;

package/lib/getNextRobotStateAndWarnings/dispenseUpdateLiquidState.d.ts

@@ -0,0 +1,15 @@
+import type { InvariantContext, RobotState, RobotStateAndWarnings } from '../types';
+type LiquidState = RobotState['liquidState'];
+export interface DispenseUpdateLiquidStateArgs {
+    invariantContext: InvariantContext;
+    prevLiquidState: LiquidState;
+    pipetteId: string;
+    useFullVolume: boolean;
+    robotStateAndWarnings: RobotStateAndWarnings;
+    entityId: string;
+    wellName?: string;
+    volume?: number;
+}
+/** This is a helper to do dispense/blowout liquid state updates. */
+export declare function dispenseUpdateLiquidState(args: DispenseUpdateLiquidStateArgs): void;
+export {};

package/lib/getNextRobotStateAndWarnings/forAirGapInPlace.d.ts

@@ -0,0 +1,3 @@
+import type { AirGapInPlaceParams } from '@opentrons/shared-data';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+export declare function forAirGapInPlace(params: AirGapInPlaceParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings): void;

package/lib/getNextRobotStateAndWarnings/forAspirate.d.ts

@@ -0,0 +1,3 @@
+import type { AspDispAirgapParams, AspirateInPlaceParams } from '@opentrons/shared-data';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+export declare function forAspirate(params: AspDispAirgapParams | AspirateInPlaceParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings): void;

package/lib/getNextRobotStateAndWarnings/forBlowout.d.ts

@@ -0,0 +1,3 @@
+import type { BlowoutParams } from '@opentrons/shared-data';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+export declare function forBlowout(params: BlowoutParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings): void;

package/lib/getNextRobotStateAndWarnings/forConfigureNozzleLayout.d.ts

@@ -0,0 +1,11 @@
+import type { NozzleConfigurationStyle, PrimaryNozzleConfigurationStyle } from '@opentrons/shared-data';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+interface ConfigureNozzleLayoutParams {
+    pipetteId: string;
+    configurationParams: {
+        style: NozzleConfigurationStyle;
+        primaryNozzle?: PrimaryNozzleConfigurationStyle;
+    };
+}
+export declare function forConfigureNozzleLayout(params: ConfigureNozzleLayoutParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings): void;
+export {};

package/lib/getNextRobotStateAndWarnings/forDispense.d.ts

@@ -0,0 +1,3 @@
+import type { AspDispAirgapParams, DispenseInPlaceParams } from '@opentrons/shared-data';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+export declare function forDispense(params: AspDispAirgapParams | DispenseInPlaceParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings): void;

package/lib/getNextRobotStateAndWarnings/forDropTip.d.ts

@@ -0,0 +1,3 @@
+import type { DropTipParams } from '@opentrons/shared-data/protocol/types/schemaV6/command/pipetting';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+export declare function forDropTip(params: DropTipParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings): void;

package/lib/getNextRobotStateAndWarnings/forLoadLiquid.d.ts

@@ -0,0 +1,3 @@
+import type { LoadLiquidCreateCommand } from '@opentrons/shared-data';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+export declare function forLoadLiquid(params: LoadLiquidCreateCommand['params'], _invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings): void;

package/lib/getNextRobotStateAndWarnings/forMoveLabware.d.ts

@@ -0,0 +1,3 @@
+import type { MoveLabwareParams } from '@opentrons/shared-data';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+export declare function forMoveLabware(params: MoveLabwareParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings): void;

package/lib/getNextRobotStateAndWarnings/forMoveToAddressableArea.d.ts

@@ -0,0 +1,3 @@
+import type { MoveToAddressableAreaForDropTipParams, MoveToAddressableAreaParams } from '@opentrons/shared-data';
+import type { InvariantContext, RobotStateAndWarnings } from '../types';
+export declare function forMoveToAddressableArea(params: MoveToAddressableAreaParams | MoveToAddressableAreaForDropTipParams, invariantContext: InvariantContext, robotStateAndWarnings: RobotStateAndWarnings): void;