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

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

@@ -0,0 +1,206 @@
+import type { AddressableAreaName } from '../../deck';
+import type { CommonCommandRunTimeInfo, CommonCommandCreateInfo } from '.';
+import type { DropTipWellLocation, WellLocation } from './support';
+export type PipettingRunTimeCommand = AspirateInPlaceRunTimeCommand | AspirateInPlaceRunTimeCommand | AspirateRunTimeCommand | BlowoutInPlaceRunTimeCommand | BlowoutRunTimeCommand | ConfigureForVolumeRunTimeCommand | DispenseInPlaceRunTimeCommand | DispenseRunTimeCommand | DropTipInPlaceRunTimeCommand | DropTipRunTimeCommand | GetTipPresenceRunTimeCommand | MoveToAddressableAreaForDropTipRunTimeCommand | PickUpTipRunTimeCommand | PrepareToAspirateRunTimeCommand | TouchTipRunTimeCommand | VerifyTipPresenceRunTimeCommand | LiquidProbeRunTimeCommand | TryLiquidProbeRunTimeCommand | AirGapInPlaceRunTimeCommand;
+export type PipettingCreateCommand = AspirateCreateCommand | AspirateInPlaceCreateCommand | BlowoutCreateCommand | BlowoutInPlaceCreateCommand | ConfigureForVolumeCreateCommand | DispenseCreateCommand | DispenseInPlaceCreateCommand | DropTipCreateCommand | DropTipInPlaceCreateCommand | GetTipPresenceCreateCommand | MoveToAddressableAreaForDropTipCreateCommand | PickUpTipCreateCommand | PrepareToAspirateCreateCommand | TouchTipCreateCommand | VerifyTipPresenceCreateCommand | LiquidProbeCreateCommand | TryLiquidProbeCreateCommand | AirGapInPlaceCreateCommand;
+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 type AirGapInPlaceParams = FlowRateParams & PipetteIdentityParams & VolumeParams;
+export interface AirGapInPlaceCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'airGapInPlace';
+    params: AirGapInPlaceParams;
+}
+export interface AirGapInPlaceRunTimeCommand extends CommonCommandRunTimeInfo, AirGapInPlaceCreateCommand {
+    result?: BasicLiquidHandlingResult;
+}
+export interface AspirateCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'aspirate';
+    params: AspDispAirgapParams;
+}
+export interface AspirateRunTimeCommand extends CommonCommandRunTimeInfo, AspirateCreateCommand {
+    result?: BasicLiquidHandlingResult;
+}
+export interface AspirateInPlaceCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'aspirateInPlace';
+    params: AspirateInPlaceParams;
+}
+export interface AspirateInPlaceRunTimeCommand extends CommonCommandRunTimeInfo, AspirateInPlaceCreateCommand {
+    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 DispenseInPlaceCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'dispenseInPlace';
+    params: DispenseInPlaceParams;
+}
+export interface DispenseInPlaceRunTimeCommand extends CommonCommandRunTimeInfo, DispenseInPlaceCreateCommand {
+    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 interface MoveToAddressableAreaForDropTipCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'moveToAddressableAreaForDropTip';
+    params: MoveToAddressableAreaForDropTipParams;
+}
+export interface MoveToAddressableAreaForDropTipRunTimeCommand extends CommonCommandRunTimeInfo, MoveToAddressableAreaForDropTipCreateCommand {
+    result?: any;
+}
+export interface PrepareToAspirateCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'prepareToAspirate';
+    params: PipetteIdentityParams;
+}
+export interface PrepareToAspirateRunTimeCommand extends CommonCommandRunTimeInfo, PrepareToAspirateCreateCommand {
+    result?: any;
+}
+export interface GetTipPresenceCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'getTipPresence';
+    params: PipetteIdentityParams;
+}
+export interface GetTipPresenceRunTimeCommand extends CommonCommandRunTimeInfo, GetTipPresenceCreateCommand {
+    result?: TipPresenceResult;
+}
+export interface VerifyTipPresenceCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'verifyTipPresence';
+    params: VerifyTipPresenceParams;
+}
+export interface VerifyTipPresenceRunTimeCommand extends CommonCommandRunTimeInfo, VerifyTipPresenceCreateCommand {
+    result?: any;
+}
+export interface LiquidProbeCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'liquidProbe';
+    params: WellLocationParam & PipetteAccessParams;
+}
+export interface LiquidProbeRunTimeCommand extends CommonCommandRunTimeInfo, LiquidProbeCreateCommand {
+    result?: Record<string, unknown>;
+}
+export interface TryLiquidProbeCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'tryLiquidProbe';
+    params: WellLocationParam & PipetteAccessParams;
+}
+export interface TryLiquidProbeRunTimeCommand extends CommonCommandRunTimeInfo, TryLiquidProbeCreateCommand {
+    result?: Record<string, unknown>;
+}
+export type AspDispAirgapParams = FlowRateParams & PipetteAccessParams & VolumeParams & WellLocationParam;
+export type BlowoutParams = FlowRateParams & PipetteAccessParams & WellLocationParam;
+export type TouchTipParams = PipetteAccessParams & WellLocationParam;
+export type DropTipParams = PipetteAccessParams & DropTipWellLocationParam;
+export type PickUpTipParams = TouchTipParams;
+interface AddressableOffsetVector {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface DropTipInPlaceParams {
+    pipetteId: string;
+}
+export interface MoveToAddressableAreaForDropTipParams {
+    pipetteId: string;
+    addressableAreaName: AddressableAreaName;
+    offset?: AddressableOffsetVector;
+    alternateDropLocation?: boolean;
+    speed?: number;
+    minimumZHeight?: number;
+    forceDirect?: boolean;
+}
+export interface BlowoutInPlaceParams {
+    pipetteId: string;
+    flowRate: number;
+}
+export interface DispenseInPlaceParams {
+    pipetteId: string;
+    volume: number;
+    flowRate: number;
+    pushOut?: number;
+}
+export interface AspirateInPlaceParams {
+    pipetteId: string;
+    volume: number;
+    flowRate: number;
+}
+interface FlowRateParams {
+    flowRate: number;
+}
+interface PipetteIdentityParams {
+    pipetteId: string;
+}
+interface PipetteAccessParams extends PipetteIdentityParams {
+    labwareId: string;
+    wellName: string;
+}
+interface VolumeParams {
+    volume: number;
+}
+interface WellLocationParam {
+    wellLocation?: WellLocation;
+}
+interface DropTipWellLocationParam {
+    wellLocation?: DropTipWellLocation;
+}
+interface VerifyTipPresenceParams extends PipetteIdentityParams {
+    expectedState?: 'present' | 'absent';
+    followSingularSensor?: 'primary' | 'secondary';
+}
+interface BasicLiquidHandlingResult {
+    volume: number;
+}
+interface TipPresenceResult {
+    status?: 'present' | 'absent' | 'unknown';
+}
+export {};

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

@@ -0,0 +1,155 @@
+import type { AddressableAreaName, 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 ReloadLabwareCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'reloadLabware';
+    params: {
+        labwareId: string;
+    };
+}
+export interface ReloadLabwareRunTimeCommand extends CommonCommandRunTimeInfo, ReloadLabwareCreateCommand {
+    result?: ReloadLabwareResult;
+}
+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 interface ConfigureNozzleLayoutCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'configureNozzleLayout';
+    params: ConfigureNozzleLayoutParams;
+}
+export interface ConfigureNozzleLayoutRunTimeCommand extends CommonCommandRunTimeInfo, ConfigureNozzleLayoutCreateCommand {
+    result?: {};
+}
+export type SetupRunTimeCommand = ConfigureNozzleLayoutRunTimeCommand | LoadPipetteRunTimeCommand | LoadLabwareRunTimeCommand | ReloadLabwareRunTimeCommand | LoadModuleRunTimeCommand | LoadLiquidRunTimeCommand | MoveLabwareRunTimeCommand;
+export type SetupCreateCommand = ConfigureNozzleLayoutCreateCommand | LoadPipetteCreateCommand | LoadLabwareCreateCommand | ReloadLabwareCreateCommand | LoadModuleCreateCommand | LoadLiquidCreateCommand | MoveLabwareCreateCommand;
+export type LabwareLocation = 'offDeck' | {
+    slotName: string;
+} | {
+    moduleId: string;
+} | {
+    labwareId: string;
+} | {
+    addressableAreaName: AddressableAreaName;
+};
+export type OnDeckLabwareLocation = {
+    slotName: string;
+} | {
+    moduleId: string;
+} | {
+    labwareId: string;
+} | {
+    addressableAreaName: AddressableAreaName;
+};
+export type NonStackedLocation = 'offDeck' | {
+    slotName: string;
+} | {
+    moduleId: string;
+} | {
+    addressableAreaName: AddressableAreaName;
+};
+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;
+}
+interface ReloadLabwareResult {
+    labwareId: string;
+    offsetId?: string | null;
+}
+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 declare const COLUMN = "COLUMN";
+export declare const SINGLE = "SINGLE";
+export declare const ROW = "ROW";
+export declare const QUADRANT = "QUADRANT";
+export declare const ALL = "ALL";
+export type NozzleConfigurationStyle = typeof COLUMN | typeof SINGLE | typeof ROW | typeof QUADRANT | typeof ALL;
+interface NozzleConfigurationParams {
+    primaryNozzle?: string;
+    style: NozzleConfigurationStyle;
+}
+interface ConfigureNozzleLayoutParams {
+    pipetteId: string;
+    configurationParams: NozzleConfigurationParams;
+}
+export {};

package/lib/command/types/support.d.ts

@@ -0,0 +1,17 @@
+type BaseWellOrigin = 'top' | 'bottom' | 'center';
+export type WellOrigin = BaseWellOrigin | 'meniscus';
+export interface WellOffset {
+    x?: number;
+    y?: number;
+    z?: number;
+}
+export interface WellLocation {
+    origin?: WellOrigin;
+    offset?: WellOffset;
+}
+export type DropTipWellOrigin = BaseWellOrigin | 'default';
+export interface DropTipWellLocation {
+    origin?: DropTipWellOrigin;
+    offset?: WellOffset;
+}
+export {};

package/lib/command/types/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/command/types/unsafe.d.ts

@@ -0,0 +1,63 @@
+import type { CommonCommandRunTimeInfo, CommonCommandCreateInfo, OnDeckLabwareLocation } from '.';
+import type { MotorAxes } from '../../js/types';
+export type UnsafeRunTimeCommand = UnsafeBlowoutInPlaceRunTimeCommand | UnsafeDropTipInPlaceRunTimeCommand | UnsafeUpdatePositionEstimatorsRunTimeCommand | UnsafeEngageAxesRunTimeCommand | UnsafeUngripLabwareRunTimeCommand | UnsafePlaceLabwareRunTimeCommand;
+export type UnsafeCreateCommand = UnsafeBlowoutInPlaceCreateCommand | UnsafeDropTipInPlaceCreateCommand | UnsafeUpdatePositionEstimatorsCreateCommand | UnsafeEngageAxesCreateCommand | UnsafeUngripLabwareCreateCommand | UnsafePlaceLabwareCreateCommand;
+export interface UnsafeBlowoutInPlaceParams {
+    pipetteId: string;
+    flowRate: number;
+}
+export interface UnsafeBlowoutInPlaceCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'unsafe/blowOutInPlace';
+    params: UnsafeBlowoutInPlaceParams;
+}
+export interface UnsafeBlowoutInPlaceRunTimeCommand extends CommonCommandRunTimeInfo, UnsafeBlowoutInPlaceCreateCommand {
+    result?: {};
+}
+export interface UnsafeDropTipInPlaceParams {
+    pipetteId: string;
+}
+export interface UnsafeDropTipInPlaceCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'unsafe/dropTipInPlace';
+    params: UnsafeDropTipInPlaceParams;
+}
+export interface UnsafeDropTipInPlaceRunTimeCommand extends CommonCommandRunTimeInfo, UnsafeDropTipInPlaceCreateCommand {
+    result?: any;
+}
+export interface UnsafeUpdatePositionEstimatorsParams {
+    axes: MotorAxes;
+}
+export interface UnsafeUpdatePositionEstimatorsCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'unsafe/updatePositionEstimators';
+    params: UnsafeUpdatePositionEstimatorsParams;
+}
+export interface UnsafeUpdatePositionEstimatorsRunTimeCommand extends CommonCommandRunTimeInfo, UnsafeUpdatePositionEstimatorsCreateCommand {
+    result?: any;
+}
+export interface UnsafeEngageAxesParams {
+    axes: MotorAxes;
+}
+export interface UnsafeEngageAxesCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'unsafe/engageAxes';
+    params: UnsafeUpdatePositionEstimatorsParams;
+}
+export interface UnsafeEngageAxesRunTimeCommand extends CommonCommandRunTimeInfo, UnsafeEngageAxesCreateCommand {
+    result?: any;
+}
+export interface UnsafeUngripLabwareCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'unsafe/ungripLabware';
+    params: {};
+}
+export interface UnsafeUngripLabwareRunTimeCommand extends CommonCommandRunTimeInfo, UnsafeUngripLabwareCreateCommand {
+    result?: any;
+}
+export interface UnsafePlaceLabwareParams {
+    labwareId: string;
+    location: OnDeckLabwareLocation;
+}
+export interface UnsafePlaceLabwareCreateCommand extends CommonCommandCreateInfo {
+    commandType: 'unsafe/placeLabware';
+    params: UnsafePlaceLabwareParams;
+}
+export interface UnsafePlaceLabwareRunTimeCommand extends CommonCommandRunTimeInfo, UnsafePlaceLabwareCreateCommand {
+    result?: any;
+}

package/lib/commandAnnotation/schemas/1.json

@@ -0,0 +1,74 @@
+{
+    "$id": "opentronsCommandAnnotationSchemaV1#",
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$defs": {
+        "baseAnnotation": {
+            "description": "Things all annotations have",
+            "type": "object",
+            "required": ["annotationType", "commandKeys"],
+            "properties": {
+                "commandKeys": {
+                    "type": "array",
+                    "items": {
+                        "description": "Command keys to which this annotation applies",
+                        "type": "string"
+                    }
+                },
+                "annotationType": {
+                    "description": "The type of annotation (for machine parsing)",
+                    "type": "string"
+                }
+            }
+        },
+        "secondOrderCommand": {
+            "description": "Annotates a group of atomic commands which were the direct result of a second order command (e.g. transfer, consolidate, mix)",
+            "allOf": [{ "$ref": "#/$defs/baseAnnotation" }],
+            "type": "object",
+            "required": [
+                "annotationType",
+                "commandKeys",
+                "params",
+                "machineReadableName"
+            ],
+            "properties": {
+                "annotationType": {
+                    "type": "string",
+                    "enum": ["secondOrderCommand"]
+                },
+                "params": {
+                    "description": "key value pairs of the parameters that were passed to the second order command that this annotates",
+                    "type": "object"
+                },
+                "machineReadableName": {
+                    "description": "The name of the second order command in the form that the generating software refers to it. (e.g. 'transfer', 'thermocyclerStep')",
+                    "type": "string"
+                },
+                "userSpecifiedName": {
+                    "description": "The optional user-specified name of the second order command",
+                    "type": "string"
+                },
+                "userSpecifiedDescription": {
+                    "description": "The optional user-specified description of the second order command",
+                    "type": "string"
+                }
+            }
+        },
+        "custom": {
+            "description": "Annotates a group of atomic commands in some manner that Opentrons software does not anticipate or originate",
+            "allOf": [{ "$ref": "#/$defs/baseAnnotation" }],
+            "type": "object",
+            "required": ["annotationType", "commandKeys"],
+            "properties": {
+                "annotationType": {
+                    "type": "string",
+                    "enum": ["custom"]
+                }
+            },
+            "additionalProperties": true
+        }
+    },
+    "oneOf": [
+        { "$ref": "#/$defs/secondOrderCommand" },
+        { "$ref": "#/$defs/custom" }
+    ]
+}

package/lib/commandAnnotation/types/index.d.ts

@@ -0,0 +1,19 @@
+interface SharedCommandAnnotationProperties {
+    commandKeys: string[];
+}
+export type CustomCommandAnnotation = SharedCommandAnnotationProperties & {
+    [key: string]: any;
+} & {
+    annotationType: 'custom';
+};
+export interface SecondOrderCommandAnnotation extends SharedCommandAnnotationProperties {
+    annotationType: 'secondOrderCommand';
+    machineReadableName: string;
+    params: {
+        [key: string]: any;
+    };
+    userSpecifiedName?: string;
+    userSpecifiedDescription?: string;
+}
+export type CommandAnnotation = SecondOrderCommandAnnotation | CustomCommandAnnotation;
+export {};