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

package/lib/protocol/types/schemaV7/command/pipetting.d.ts

@@ -0,0 +1,119 @@
+import type { CommonCommandRunTimeInfo, CommonCommandCreateInfo } from '.';
+export type PipettingRunTimeCommand = AspirateRunTimeCommand | DispenseRunTimeCommand | BlowoutRunTimeCommand | BlowoutInPlaceRunTimeCommand | TouchTipRunTimeCommand | PickUpTipRunTimeCommand | DropTipRunTimeCommand | DropTipInPlaceRunTimeCommand | ConfigureForVolumeRunTimeCommand;
+export type PipettingCreateCommand = AspirateCreateCommand | DispenseCreateCommand | BlowoutCreateCommand | BlowoutInPlaceCreateCommand | TouchTipCreateCommand | PickUpTipCreateCommand | DropTipCreateCommand | DropTipInPlaceCreateCommand | ConfigureForVolumeCreateCommand;
+export interface ConfigureForVolumeCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'configureForVolume';
+    params: ConfigureForVolumeParams;
+}
+export interface ConfigureForVolumeParams {
+    pipetteId: string;
+    volume: number;
+}
+export interface ConfigureForVolumeRunTimeCommand extends CommonCommandRunTimeInfo, ConfigureForVolumeCreateCommand {
+    result?: BasicLiquidHandlingResult;
+}
+export interface AspirateCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'aspirate';
+    params: AspDispAirgapParams;
+}
+export interface AspirateRunTimeCommand extends CommonCommandRunTimeInfo, AspirateCreateCommand {
+    result?: BasicLiquidHandlingResult;
+}
+export type DispenseParams = AspDispAirgapParams & {
+    pushOut?: number;
+};
+export interface DispenseCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'dispense';
+    params: DispenseParams;
+}
+export interface DispenseRunTimeCommand extends CommonCommandRunTimeInfo, DispenseCreateCommand {
+    result?: BasicLiquidHandlingResult;
+}
+export interface BlowoutCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'blowout';
+    params: BlowoutParams;
+}
+export interface BlowoutRunTimeCommand extends CommonCommandRunTimeInfo, BlowoutCreateCommand {
+    result?: BasicLiquidHandlingResult;
+}
+export interface BlowoutInPlaceCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'blowOutInPlace';
+    params: BlowoutInPlaceParams;
+}
+export interface BlowoutInPlaceRunTimeCommand extends CommonCommandRunTimeInfo, BlowoutInPlaceCreateCommand {
+    result?: BasicLiquidHandlingResult;
+}
+export interface TouchTipCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'touchTip';
+    params: TouchTipParams;
+}
+export interface TouchTipRunTimeCommand extends CommonCommandRunTimeInfo, TouchTipCreateCommand {
+    result?: BasicLiquidHandlingResult;
+}
+export interface PickUpTipCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'pickUpTip';
+    params: PickUpTipParams;
+}
+export interface PickUpTipRunTimeCommand extends CommonCommandRunTimeInfo, PickUpTipCreateCommand {
+    result?: any;
+}
+export interface DropTipCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'dropTip';
+    params: DropTipParams;
+}
+export interface DropTipRunTimeCommand extends CommonCommandRunTimeInfo, DropTipCreateCommand {
+    result?: any;
+}
+export interface DropTipInPlaceCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'dropTipInPlace';
+    params: DropTipInPlaceParams;
+}
+export interface DropTipInPlaceRunTimeCommand extends CommonCommandRunTimeInfo, DropTipInPlaceCreateCommand {
+    result?: any;
+}
+export type AspDispAirgapParams = FlowRateParams & PipetteAccessParams & VolumeParams & WellLocationParam;
+export type BlowoutParams = FlowRateParams & PipetteAccessParams & WellLocationParam;
+export type TouchTipParams = PipetteAccessParams & WellLocationParam;
+export type DropTipParams = PipetteAccessParams & {
+    wellLocation?: {
+        origin?: 'default' | 'top' | 'center' | 'bottom';
+        offset?: {
+            x?: number;
+            y?: number;
+            z?: number;
+        };
+    };
+};
+export type PickUpTipParams = TouchTipParams;
+export interface DropTipInPlaceParams {
+    pipetteId: string;
+}
+export interface BlowoutInPlaceParams {
+    pipetteId: string;
+    flowRate: number;
+}
+interface FlowRateParams {
+    flowRate: number;
+}
+interface PipetteAccessParams {
+    pipetteId: string;
+    labwareId: string;
+    wellName: string;
+}
+interface VolumeParams {
+    volume: number;
+}
+interface WellLocationParam {
+    wellLocation?: {
+        origin?: 'top' | 'center' | 'bottom';
+        offset?: {
+            x?: number;
+            y?: number;
+            z?: number;
+        };
+    };
+}
+interface BasicLiquidHandlingResult {
+    volume: number;
+}
+export {};

package/lib/protocol/types/schemaV7/command/setup.d.ts

@@ -0,0 +1,108 @@
+import type { CommonCommandRunTimeInfo, CommonCommandCreateInfo, LabwareDefinition2, LabwareOffset, PipetteName, ModuleModel } from '../../../../js';
+export interface LoadPipetteCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'loadPipette';
+    params: LoadPipetteParams;
+}
+export interface LoadPipetteRunTimeCommand extends CommonCommandRunTimeInfo, Omit<LoadPipetteCreateCommand, 'params'> {
+    params: LoadPipetteParams & {
+        pipetteName: PipetteName;
+    };
+    result?: LoadPipetteResult;
+}
+export interface LoadLabwareCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'loadLabware';
+    params: LoadLabwareParams;
+}
+export interface LoadLabwareRunTimeCommand extends CommonCommandRunTimeInfo, LoadLabwareCreateCommand {
+    result?: LoadLabwareResult;
+}
+export interface MoveLabwareCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'moveLabware';
+    params: MoveLabwareParams;
+}
+export interface MoveLabwareRunTimeCommand extends CommonCommandRunTimeInfo, MoveLabwareCreateCommand {
+    result?: MoveLabwareResult;
+}
+export interface LoadModuleCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'loadModule';
+    params: LoadModuleParams;
+}
+export interface LoadModuleRunTimeCommand extends CommonCommandRunTimeInfo, Omit<LoadModuleCreateCommand, 'params'> {
+    params: LoadModuleParams & {
+        model: ModuleModel;
+    };
+    result?: LoadModuleResult;
+}
+export interface LoadLiquidCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'loadLiquid';
+    params: LoadLiquidParams;
+}
+export interface LoadLiquidRunTimeCommand extends CommonCommandRunTimeInfo, LoadLiquidCreateCommand {
+    result?: LoadLiquidResult;
+}
+export type SetupRunTimeCommand = LoadPipetteRunTimeCommand | LoadLabwareRunTimeCommand | LoadModuleRunTimeCommand | LoadLiquidRunTimeCommand | MoveLabwareRunTimeCommand;
+export type SetupCreateCommand = LoadPipetteCreateCommand | LoadLabwareCreateCommand | LoadModuleCreateCommand | LoadLiquidCreateCommand | MoveLabwareCreateCommand;
+export type LabwareLocation = 'offDeck' | {
+    slotName: string;
+} | {
+    moduleId: string;
+} | {
+    labwareId: string;
+};
+export type NonStackedLocation = 'offDeck' | {
+    slotName: string;
+} | {
+    moduleId: string;
+};
+export interface ModuleLocation {
+    slotName: string;
+}
+export interface LoadPipetteParams {
+    pipetteName: string;
+    pipetteId: string;
+    mount: 'left' | 'right';
+}
+interface LoadPipetteResult {
+    pipetteId: string;
+}
+interface LoadLabwareParams {
+    location: LabwareLocation;
+    version: number;
+    namespace: string;
+    loadName: string;
+    displayName?: string;
+    labwareId?: string;
+}
+interface LoadLabwareResult {
+    labwareId: string;
+    definition: LabwareDefinition2;
+    offset: LabwareOffset;
+}
+export type LabwareMovementStrategy = 'usingGripper' | 'manualMoveWithPause' | 'manualMoveWithoutPause';
+export interface MoveLabwareParams {
+    labwareId: string;
+    newLocation: LabwareLocation;
+    strategy: LabwareMovementStrategy;
+}
+interface MoveLabwareResult {
+    offsetId: string;
+}
+interface LoadModuleParams {
+    moduleId?: string;
+    location: ModuleLocation;
+    model: ModuleModel;
+}
+interface LoadModuleResult {
+    moduleId: string;
+}
+interface LoadLiquidParams {
+    liquidId: string;
+    labwareId: string;
+    volumeByWell: {
+        [wellName: string]: number;
+    };
+}
+interface LoadLiquidResult {
+    liquidId: string;
+}
+export {};

package/lib/protocol/types/schemaV7/command/timing.d.ts

@@ -0,0 +1,39 @@
+import type { CommonCommandRunTimeInfo, CommonCommandCreateInfo } from '.';
+export type TimingCreateCommand = WaitForResumeCreateCommand | WaitForDurationCreateCommand | DeprecatedDelayCreateCommand;
+export type TimingRunTimeCommand = WaitForResumeRunTimeCommand | WaitForDurationRunTimeCommand | DeprecatedDelayRunTimeCommand;
+export interface WaitForResumeCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'waitForResume' | 'pause';
+    params: WaitForResumeParams;
+}
+export interface WaitForResumeRunTimeCommand extends CommonCommandRunTimeInfo, WaitForResumeCreateCommand {
+    result?: any;
+}
+interface WaitForResumeParams {
+    message?: string;
+}
+export interface WaitForDurationCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'waitForDuration';
+    params: WaitForDurationParams;
+}
+export interface WaitForDurationRunTimeCommand extends CommonCommandRunTimeInfo, WaitForDurationCreateCommand {
+    result?: any;
+}
+interface WaitForDurationParams {
+    seconds: number;
+    message?: string;
+}
+export interface DeprecatedDelayCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'delay';
+    params: DeprecatedDelayParams;
+}
+export interface DeprecatedDelayRunTimeCommand extends CommonCommandRunTimeInfo, DeprecatedDelayCreateCommand {
+    result?: {};
+}
+type DeprecatedDelayParams = {
+    waitForResume: true;
+    message?: string;
+} | {
+    seconds: number;
+    message?: string;
+};
+export {};

package/lib/protocol/types/schemaV7/index.d.ts

@@ -0,0 +1,94 @@
+import type { LoadedPipette, LoadedLabware, LoadedModule, Liquid } from '../../../js';
+import type { CreateCommand, RunTimeCommand } from './command';
+import type { LabwareDefinition2, RobotType } from '../../../js/types';
+export * from './command';
+export interface ProtocolFile<DesignerApplicationData = {}> {
+    $otSharedSchema: '#/protocol/schemas/7';
+    schemaVersion: 7;
+    metadata: {
+        protocolName?: string;
+        author?: string;
+        description?: string | null | undefined;
+        created?: number;
+        lastModified?: number | null | undefined;
+        category?: string | null | undefined;
+        subcategory?: string | null | undefined;
+        tags?: string[];
+    };
+    designerApplication?: {
+        name?: string;
+        version?: string;
+        data?: DesignerApplicationData;
+    };
+    robot: {
+        model: 'OT-2 Standard' | 'OT-3 Standard';
+        deckId: 'ot2_standard' | 'ot2_short_trash' | 'ot3_standard';
+    };
+    labwareDefinitions: {
+        [definitionId: string]: LabwareDefinition2;
+    };
+    liquids: {
+        [liquidId: string]: {
+            displayName: string;
+            description: string;
+            displayColor?: string;
+        };
+    };
+    commands: CreateCommand[];
+    commandAnnotations?: {
+        commandIds: string[];
+        annotationType: string;
+        params?: {
+            [key: string]: any;
+        };
+    };
+}
+/**
+ * This type should not be used, any time you want a function/hook/component to take in
+ * a protocol file with run time commands, split your function signature to take in each param
+ * separately, and import the RunTimeCommand type separately. RunTimeCommand is a server concept
+ * and should not be mixed with our Protocol types
+ * @deprecated Use {@link ProtocolFile}
+ */
+export interface ProtocolAnalysisFile<DesignerApplicationData = {}> extends Omit<ProtocolFile<DesignerApplicationData>, 'commands'> {
+    commands: RunTimeCommand[];
+}
+/**
+ * This type interface is represents the output of the opentrons analyze cli tool
+ * which contains the protocol analysis engine
+ * TODO: reconcile this type with that of the analysis returned from
+ * the protocols record endpoints on the robot-server
+ */
+export interface ProtocolAnalysisOutput {
+    createdAt: string;
+    files: AnalysisSourceFile[];
+    config: JsonConfig | PythonConfig;
+    metadata: {
+        [key: string]: any;
+    };
+    commands: RunTimeCommand[];
+    labware: LoadedLabware[];
+    pipettes: LoadedPipette[];
+    modules: LoadedModule[];
+    liquids: Liquid[];
+    errors: AnalysisError[];
+    robotType?: RobotType;
+}
+interface AnalysisSourceFile {
+    name: string;
+    role: 'main' | 'labware';
+}
+export interface JsonConfig {
+    protocolType: 'json';
+    schemaVersion: number;
+}
+export interface PythonConfig {
+    protocolType: 'python';
+    apiVersion: [major: number, minor: number];
+}
+interface AnalysisError {
+    id: string;
+    errorType: string;
+    createdAt: string;
+    detail: string;
+}

package/lib/protocol/types/schemaV8/index.d.ts

@@ -0,0 +1,132 @@
+import type { CreateCommand } from '../../../command/types';
+import type { LoadedPipette, LoadedLabware, LoadedModule, Liquid, RunTimeParameter } from '../../../js';
+import type { CommandAnnotation } from '../../../commandAnnotation/types';
+import type { LabwareDefinition2, RobotType } from '../../../js/types';
+import type { RunTimeCommand } from '../schemaV8';
+export * from '../../../command/types';
+export interface CommandsStructure {
+    commandSchemaId: string;
+    commands: any[];
+}
+export interface CommandV8Mixin {
+    commandSchemaId: 'opentronsCommandSchemaV8';
+    commands: CreateCommand[];
+}
+export interface CommandV9Mixin {
+    commandSchemaId: 'opentronsCommandSchemaV9';
+    commands: CreateCommand[];
+}
+export interface CommandAnnotationsStructure {
+    commandAnnotationSchemaId: string;
+    commandAnnotations: any[];
+}
+export interface CommandAnnotationV1Mixin {
+    commandAnnotationSchemaId: 'opentronsCommandAnnotationSchemaV1';
+    commandAnnotations: CommandAnnotation[];
+}
+export interface LabwareStructure {
+    labwareDefinitionSchemaId: string;
+    labwareDefinitions: {
+        [definitionId: string]: any;
+    };
+}
+export interface LabwareV2Mixin {
+    labwareDefinitionSchemaId: 'opentronsLabwareSchemaV2';
+    labwareDefinitions: {
+        [definitionId: string]: LabwareDefinition2;
+    };
+}
+export interface LiquidStructure {
+    liquidSchemaId: string;
+    liquids: {
+        [liquidId: string]: any;
+    };
+}
+export interface LiquidV1Mixin {
+    liquidSchemaId: 'opentronsLiquidSchemaV1';
+    liquids: {
+        [liquidId: string]: {
+            displayName: string;
+            description: string;
+            displayColor?: string;
+        };
+    };
+}
+export interface RobotStructure {
+    model: string;
+    deckId: string;
+}
+export interface OT2RobotMixin {
+    robot: {
+        model: 'OT-2 Standard';
+        deckId: 'ot2_standard' | 'ot2_short_trash';
+    };
+}
+export interface OT3RobotMixin {
+    robot: {
+        model: 'OT-3 Standard';
+        deckId: 'ot3_standard';
+    };
+}
+export interface ProtocolBase<DesignerApplicationData> {
+    $otSharedSchema: '#/protocol/schemas/8';
+    schemaVersion: 8;
+    metadata: {
+        protocolName?: string;
+        author?: string;
+        description?: string | null | undefined;
+        created?: number;
+        lastModified?: number | null | undefined;
+        category?: string | null | undefined;
+        subcategory?: string | null | undefined;
+        tags?: string[];
+    };
+    designerApplication?: {
+        name?: string;
+        version?: string;
+        data?: DesignerApplicationData;
+    };
+}
+export type ProtocolFile<DesignerApplicationData = {}> = ProtocolBase<DesignerApplicationData> & (OT2RobotMixin | OT3RobotMixin) & LabwareV2Mixin & LiquidV1Mixin & (CommandV8Mixin | CommandV9Mixin) & CommandAnnotationV1Mixin;
+export type ProtocolStructure = ProtocolBase<{}> & RobotStructure & LabwareStructure & LiquidStructure & CommandsStructure & CommandAnnotationsStructure;
+/**
+ * This type interface is represents the output of the opentrons analyze cli tool
+ * which contains the protocol analysis engine
+ * TODO: reconcile this type with that of the analysis returned from
+ * the protocols record endpoints on the robot-server
+ */
+export interface ProtocolAnalysisOutput {
+    createdAt: string;
+    files: AnalysisSourceFile[];
+    config: JsonConfig | PythonConfig;
+    metadata: {
+        [key: string]: any;
+    };
+    commands: RunTimeCommand[];
+    labware: LoadedLabware[];
+    pipettes: LoadedPipette[];
+    modules: LoadedModule[];
+    liquids: Liquid[];
+    errors: AnalysisError[];
+    runTimeParameters: RunTimeParameter[];
+    robotType?: RobotType;
+    result: 'ok' | 'not-ok' | 'error' | 'parameter-value-required';
+}
+interface AnalysisSourceFile {
+    name: string;
+    role: 'main' | 'labware';
+}
+export interface JsonConfig {
+    protocolType: 'json';
+    schemaVersion: number;
+}
+export interface PythonConfig {
+    protocolType: 'python';
+    apiVersion: [major: number, minor: number];
+}
+interface AnalysisError {
+    id: string;
+    errorType: string;
+    createdAt: string;
+    detail: string;
+}

package/lib/vite.config.d.mts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;