effect-web-midi 0.2.3

package/dist-types/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPort.d.ts

@@ -0,0 +1,76 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import * as EMIDIPort from '../EMIDIPort.ts';
+import * as StreamMaker from '../StreamMaker.ts';
+/**
+ *
+ * @internal
+ */
+export declare const makePortStateChangesStreamFactory: <THighLevelPortType extends MIDIPortType>(is: (port: unknown) => port is EMIDIPort.EMIDIPort<THighLevelPortType>) => DualMakeStateChangesStreamByPort<THighLevelPortType>;
+/**
+ * Function to create a stream of remapped {@linkcode MIDIConnectionEvent}s
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIConnectionEvent)
+ */
+export declare const makePortStateChangesStreamByPort: DualMakeStateChangesStreamByPort<MIDIPortType>;
+/**
+ * Function to create a stream of remapped {@linkcode MIDIConnectionEvent}s
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIConnectionEvent)
+ */
+export declare const makeInputStateChangesStreamByPort: DualMakeStateChangesStreamByPort<"input">;
+/**
+ * Function to create a stream of remapped {@linkcode MIDIConnectionEvent}s
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIConnectionEvent)
+ */
+export declare const makeOutputStateChangesStreamByPort: DualMakeStateChangesStreamByPort<"output">;
+/**
+ * A custom type is needed because the port type will be generic, but this is
+ * not possible if using just {@linkcode StreamMaker.createStreamMakerFrom}
+ */
+export interface DualMakeStateChangesStreamByPort<THighLevelPortType extends MIDIPortType = MIDIPortType> extends MakeStateChangesStreamPortFirst<THighLevelPortType>, MakeStateChangesStreamPortLast<THighLevelPortType> {
+}
+/**
+ * A custom type is needed because the port type will be generic, but this is
+ * not possible if using just {@linkcode StreamMaker.createStreamMakerFrom}
+ */
+export interface MakeStateChangesStreamPortFirst<THighLevelPortType extends MIDIPortType = MIDIPortType> {
+    /**
+     * @param options Passing a value of a `boolean` type is equivalent to setting `options.capture`
+     * property
+     */
+    <TPortType extends THighLevelPortType, const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined, E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, TPortType>, options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>): StateChangesStream<TOnNullStrategy, TPortType, E, R>;
+}
+/**
+ * A custom type is needed because the port type will be generic, but this is
+ * not possible if using just {@linkcode StreamMaker.createStreamMakerFrom}
+ */
+export interface MakeStateChangesStreamPortLast<THighLevelPortType extends MIDIPortType = MIDIPortType> {
+    /**
+     * @param options Passing a value of a `boolean` type is equivalent to setting `options.capture`
+     * property
+     */
+    <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>): {
+        /**
+         *
+         *
+         */
+        <TPortType extends THighLevelPortType, E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, TPortType>): StateChangesStream<TOnNullStrategy, TPortType, E, R>;
+    };
+}
+/**
+ * A custom type is needed because the port type will be generic, but this is
+ * not possible if using just {@linkcode StreamMaker.createStreamMakerFrom}
+ */
+export interface StateChangesStream<TOnNullStrategy extends StreamMaker.OnNullStrategy, TPortType extends MIDIPortType, E = never, R = never> extends StreamMaker.BuiltStream<'MIDIPortStateChange', EMIDIPort.EMIDIPort<TPortType>, {
+    readonly newState: {
+        readonly ofDevice: MIDIPortDeviceState;
+        readonly ofConnection: MIDIPortConnectionState;
+    } | null;
+}, TOnNullStrategy, E, R> {
+}
+//# sourceMappingURL=makePortStateChangesStreamByPort.d.ts.map

package/dist-types/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makePortStateChangesStreamByPort.d.ts","sourceRoot":"","sources":["../../../../src/internal/makePortStateChangesStream/makePortStateChangesStreamByPort.ts"],"names":[],"mappings":"AAAA;gEACgE;AAIhE,OAAO,KAAK,SAAS,MAAM,iBAAiB,CAAA;AAC5C,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAGhD;;;GAGG;AACH,eAAO,MAAM,iCAAiC,GAC5C,kBAAkB,SAAS,YAAY,MAEnC,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,IAAI,SAAS,CAAC,SAAS,CAAC,kBAAkB,CAAC,KA0BjE,gCAAgC,CAAC,kBAAkB,CAAC,CAAA;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,gDACI,CAAA;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,2CACI,CAAA;AAElD;;;;;GAKG;AACH,eAAO,MAAM,kCAAkC,4CACI,CAAA;AAEnD;;;GAGG;AACH,MAAM,WAAW,gCAAgC,CAC/C,kBAAkB,SAAS,YAAY,GAAG,YAAY,CACtD,SAAQ,+BAA+B,CAAC,kBAAkB,CAAC,EACzD,8BAA8B,CAAC,kBAAkB,CAAC;CAAG;AAEzD;;;GAGG;AACH,MAAM,WAAW,+BAA+B,CAC9C,kBAAkB,SAAS,YAAY,GAAG,YAAY;IAEtD;;;OAGG;IACH,CACE,SAAS,SAAS,kBAAkB,EACpC,KAAK,CAAC,eAAe,SAAS,WAAW,CAAC,cAAc,GAAG,SAAS,EACpE,CAAC,GAAG,KAAK,EACT,CAAC,GAAG,KAAK,EAET,eAAe,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,EAC3D,OAAO,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,eAAe,CAAC,GACxD,kBAAkB,CAAC,eAAe,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACxD;AAED;;;GAGG;AACH,MAAM,WAAW,8BAA8B,CAC7C,kBAAkB,SAAS,YAAY,GAAG,YAAY;IAEtD;;;OAGG;IACH,CAAC,KAAK,CAAC,eAAe,SAAS,WAAW,CAAC,cAAc,GAAG,SAAS,EACnE,OAAO,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,eAAe,CAAC,GACxD;QACD;;;WAGG;QACH,CAAC,SAAS,SAAS,kBAAkB,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACzD,eAAe,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,GAC1D,kBAAkB,CAAC,eAAe,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;KACxD,CAAA;CACF;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB,CACjC,eAAe,SAAS,WAAW,CAAC,cAAc,EAClD,SAAS,SAAS,YAAY,EAC9B,CAAC,GAAG,KAAK,EACT,CAAC,GAAG,KAAK,CACT,SAAQ,WAAW,CAAC,WAAW,CAC7B,qBAAqB,EACrB,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,EAC9B;IACE,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAA;QACtC,QAAQ,CAAC,YAAY,EAAE,uBAAuB,CAAA;KAC/C,GAAG,IAAI,CAAA;CACT,EACD,eAAe,EACf,CAAC,EACD,CAAC,CACF;CAAG"}

package/dist-types/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdAndAccess.d.ts

@@ -0,0 +1,39 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import * as EMIDIAccess from '../EMIDIAccess.ts';
+import type * as EMIDIPort from '../EMIDIPort.ts';
+import type * as MIDIErrors from '../MIDIErrors.ts';
+import type * as StreamMaker from '../StreamMaker.ts';
+import * as Make from './makePortStateChangesStreamByPort.ts';
+/**
+ *
+ */
+export declare const makePortStateChangesStreamByPortIdAndAccess: MakePortStateChangesStreamByIdAndAccess<MIDIPortType, MIDIErrors.PortNotFoundError, never>;
+/**
+ *
+ */
+export declare const makeInputStateChangesStreamByPortIdAndAccess: MakePortStateChangesStreamByIdAndAccess<"input", MIDIErrors.PortNotFoundError, never>;
+/**
+ *
+ */
+export declare const makeOutputStateChangesStreamByPortIdAndAccess: MakePortStateChangesStreamByIdAndAccess<"output", MIDIErrors.PortNotFoundError, never>;
+export interface MakePortStateChangesStreamByIdAndAccess<TTypeOfPortId extends MIDIPortType, TPortGettingError, TPortGettingRequirement> extends MakePortStateChangesStreamByIdAccessLast<TTypeOfPortId, TPortGettingError, TPortGettingRequirement>, MakePortStateChangesStreamByIdAccessFirst<TTypeOfPortId, TPortGettingError, TPortGettingRequirement> {
+}
+export interface MakePortStateChangesStreamByIdAccessFirst<TTypeOfPortId extends MIDIPortType, TPortGettingError, TPortGettingRequirement> {
+    /**
+     *
+     */
+    <TAccessError = never, TAccessRequirement = never, const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<TAccessError, TAccessRequirement>, id: EMIDIPort.Id<TTypeOfPortId>, options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>): Make.StateChangesStream<TOnNullStrategy, TTypeOfPortId, MIDIErrors.PortNotFoundError | TAccessError | TPortGettingError, TAccessRequirement | TPortGettingRequirement>;
+}
+export interface MakePortStateChangesStreamByIdAccessLast<TTypeOfPortId extends MIDIPortType, TPortGettingError, TPortGettingRequirement> {
+    /**
+     *
+     */
+    <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(id: EMIDIPort.Id<TTypeOfPortId>, options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>): {
+        /**
+         *
+         */
+        <TAccessError = never, TAccessRequirement = never>(polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<TAccessError, TAccessRequirement>): Make.StateChangesStream<TOnNullStrategy, TTypeOfPortId, MIDIErrors.PortNotFoundError | TAccessError | TPortGettingError, TAccessRequirement | TPortGettingRequirement>;
+    };
+}
+//# sourceMappingURL=makePortStateChangesStreamByPortIdAndAccess.d.ts.map

package/dist-types/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdAndAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makePortStateChangesStreamByPortIdAndAccess.d.ts","sourceRoot":"","sources":["../../../../src/internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdAndAccess.ts"],"names":[],"mappings":"AAAA;gEACgE;AAIhE,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,KAAK,SAAS,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,KAAK,UAAU,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAErD,OAAO,KAAK,IAAI,MAAM,uCAAuC,CAAA;AA8B7D;;GAEG;AACH,eAAO,MAAM,2CAA2C,4FAGvD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,4CAA4C,uFAGxD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,6CAA6C,wFAGzD,CAAA;AAED,MAAM,WAAW,uCAAuC,CACtD,aAAa,SAAS,YAAY,EAClC,iBAAiB,EACjB,uBAAuB,CACvB,SAAQ,wCAAwC,CAC5C,aAAa,EACb,iBAAiB,EACjB,uBAAuB,CACxB,EACD,yCAAyC,CACvC,aAAa,EACb,iBAAiB,EACjB,uBAAuB,CACxB;CAAG;AAER,MAAM,WAAW,yCAAyC,CACxD,aAAa,SAAS,YAAY,EAClC,iBAAiB,EACjB,uBAAuB;IAEvB;;OAEG;IACH,CACE,YAAY,GAAG,KAAK,EACpB,kBAAkB,GAAG,KAAK,EAC1B,KAAK,CAAC,eAAe,SAAS,WAAW,CAAC,cAAc,GAAG,SAAS,EAEpE,iBAAiB,EAAE,WAAW,CAAC,yBAAyB,CACtD,YAAY,EACZ,kBAAkB,CACnB,EACD,EAAE,EAAE,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,EAC/B,OAAO,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,eAAe,CAAC,GACxD,IAAI,CAAC,kBAAkB,CACxB,eAAe,EACf,aAAa,EACb,UAAU,CAAC,iBAAiB,GAAG,YAAY,GAAG,iBAAiB,EAC/D,kBAAkB,GAAG,uBAAuB,CAC7C,CAAA;CACF;AAED,MAAM,WAAW,wCAAwC,CACvD,aAAa,SAAS,YAAY,EAClC,iBAAiB,EACjB,uBAAuB;IAEvB;;OAEG;IACH,CAAC,KAAK,CAAC,eAAe,SAAS,WAAW,CAAC,cAAc,GAAG,SAAS,EACnE,EAAE,EAAE,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,EAC/B,OAAO,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,eAAe,CAAC,GACxD;QACD;;WAEG;QACH,CAAC,YAAY,GAAG,KAAK,EAAE,kBAAkB,GAAG,KAAK,EAC/C,iBAAiB,EAAE,WAAW,CAAC,yBAAyB,CACtD,YAAY,EACZ,kBAAkB,CACnB,GACA,IAAI,CAAC,kBAAkB,CACxB,eAAe,EACf,aAAa,EACb,UAAU,CAAC,iBAAiB,GAAG,YAAY,GAAG,iBAAiB,EAC/D,kBAAkB,GAAG,uBAAuB,CAC7C,CAAA;KACF,CAAA;CACF"}

package/dist-types/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdInContext.d.ts

@@ -0,0 +1,29 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import type * as EMIDIPort from '../../EMIDIPort.ts';
+import * as EMIDIAccess from '../EMIDIAccess.ts';
+import type * as MIDIErrors from '../MIDIErrors.ts';
+import type * as StreamMaker from '../StreamMaker.ts';
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export declare const makePortStateChangesStreamByPortIdInContext: MakePortStateChangesStreamByPortIdInContext<MIDIPortType, MIDIErrors.PortNotFoundError, never>;
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export declare const makeInputStateChangesStreamByPortIdInContext: MakePortStateChangesStreamByPortIdInContext<"input", MIDIErrors.PortNotFoundError, never>;
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export declare const makeOutputStateChangesStreamByPortIdInContext: MakePortStateChangesStreamByPortIdInContext<"output", MIDIErrors.PortNotFoundError, never>;
+interface MakePortStateChangesStreamByPortIdInContext<TTypeOfPortId extends MIDIPortType, TPortGettingError, TPortGettingRequirement> {
+    /**
+     *
+     */
+    <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(id: EMIDIPort.Id<TTypeOfPortId>, options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>): EMIDIPort.StateChangesStream<TOnNullStrategy, TTypeOfPortId, TPortGettingError | MIDIErrors.PortNotFoundError, TPortGettingRequirement | EMIDIAccess.EMIDIAccess>;
+}
+export {};
+//# sourceMappingURL=makePortStateChangesStreamByPortIdInContext.d.ts.map

package/dist-types/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makePortStateChangesStreamByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../src/internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdInContext.ts"],"names":[],"mappings":"AAAA;gEACgE;AAEhE,OAAO,KAAK,KAAK,SAAS,MAAM,oBAAoB,CAAA;AACpD,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,KAAK,UAAU,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAsBrD;;;GAGG;AACH,eAAO,MAAM,2CAA2C,gGAEvD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,4CAA4C,2FAExD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,6CAA6C,4FAEzD,CAAA;AAED,UAAU,2CAA2C,CACnD,aAAa,SAAS,YAAY,EAClC,iBAAiB,EACjB,uBAAuB;IAEvB;;OAEG;IACH,CAAC,KAAK,CAAC,eAAe,SAAS,WAAW,CAAC,cAAc,GAAG,SAAS,EACnE,EAAE,EAAE,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,EAC/B,OAAO,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,eAAe,CAAC,GACxD,SAAS,CAAC,kBAAkB,CAC7B,eAAe,EACf,aAAa,EACb,iBAAiB,GAAG,UAAU,CAAC,iBAAiB,EAChD,uBAAuB,GAAG,WAAW,CAAC,WAAW,CAClD,CAAA;CACF"}

package/dist-types/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPort.d.ts

@@ -0,0 +1,62 @@
+import * as Util from '../../Util.ts';
+/**
+ *
+ */
+export declare const isPortDeviceConnectedByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, MIDIPortType>) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainDeviceState", "connected">, E, R>;
+/**
+ *
+ */
+export declare const isPortDeviceDisconnectedByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, MIDIPortType>) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainDeviceState", "disconnected">, E, R>;
+/**
+ *
+ */
+export declare const isPortConnectionOpenByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, MIDIPortType>) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainConnectionState", "open">, E, R>;
+/**
+ *
+ */
+export declare const isPortConnectionPendingByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, MIDIPortType>) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainConnectionState", "pending">, E, R>;
+/**
+ *
+ */
+export declare const isPortConnectionClosedByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, MIDIPortType>) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainConnectionState", "closed">, E, R>;
+/**
+ *
+ */
+export declare const isInputDeviceConnectedByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, "input">) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainDeviceState", "connected">, E, R>;
+/**
+ *
+ */
+export declare const isInputDeviceDisconnectedByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, "input">) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainDeviceState", "disconnected">, E, R>;
+/**
+ *
+ */
+export declare const isInputConnectionOpenByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, "input">) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainConnectionState", "open">, E, R>;
+/**
+ *
+ */
+export declare const isInputConnectionPendingByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, "input">) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainConnectionState", "pending">, E, R>;
+/**
+ *
+ */
+export declare const isInputConnectionClosedByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, "input">) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainConnectionState", "closed">, E, R>;
+/**
+ *
+ */
+export declare const isOutputDeviceConnectedByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, "output">) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainDeviceState", "connected">, E, R>;
+/**
+ *
+ */
+export declare const isOutputDeviceDisconnectedByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, "output">) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainDeviceState", "disconnected">, E, R>;
+/**
+ *
+ */
+export declare const isOutputConnectionOpenByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, "output">) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainConnectionState", "open">, E, R>;
+/**
+ *
+ */
+export declare const isOutputConnectionPendingByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, "output">) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainConnectionState", "pending">, E, R>;
+/**
+ *
+ */
+export declare const isOutputConnectionClosedByPort: <E = never, R = never>(polymorphicPort: import("../../EMIDIPort.ts").PolymorphicPort<E, R, "output">) => import("effect/Effect").Effect<Util.IsEqualFlag<"isCertainConnectionState", "closed">, E, R>;
+//# sourceMappingURL=doesMutablePortPropertyHaveSpecificValueByPort.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doesMutablePortPropertyHaveSpecificValueByPort.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,IAAI,MAAM,eAAe,CAAA;AAGrC;;GAEG;AACH,eAAO,MAAM,2BAA2B,0MAGvC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,8BAA8B,6MAG1C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B,yMAGtC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,6BAA6B,4MAGzC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,4BAA4B,2MAGxC,CAAA;AAID;;GAEG;AACH,eAAO,MAAM,4BAA4B,qMAGxC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,+BAA+B,wMAG3C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,2BAA2B,oMAGvC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,8BAA8B,uMAG1C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,6BAA6B,sMAGzC,CAAA;AAID;;GAEG;AACH,eAAO,MAAM,6BAA6B,sMAGzC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,gCAAgC,yMAG5C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,4BAA4B,qMAGxC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,+BAA+B,wMAG3C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,8BAA8B,uMAG1C,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdAndAccess.d.ts

@@ -0,0 +1,16 @@
+export declare const isInputConnectionClosedByPortIdAndAccess: () => never;
+export declare const isInputConnectionOpenByPortIdAndAccess: () => never;
+export declare const isInputConnectionPendingByPortIdAndAccess: () => never;
+export declare const isInputDeviceConnectedByPortIdAndAccess: () => never;
+export declare const isInputDeviceDisconnectedByPortIdAndAccess: () => never;
+export declare const isOutputConnectionClosedByPortIdAndAccess: () => never;
+export declare const isOutputConnectionOpenByPortIdAndAccess: () => never;
+export declare const isOutputConnectionPendingByPortIdAndAccess: () => never;
+export declare const isOutputDeviceConnectedByPortIdAndAccess: () => never;
+export declare const isOutputDeviceDisconnectedByPortIdAndAccess: () => never;
+export declare const isPortConnectionClosedByPortIdAndAccess: () => never;
+export declare const isPortConnectionOpenByPortIdAndAccess: () => never;
+export declare const isPortConnectionPendingByPortIdAndAccess: () => never;
+export declare const isPortDeviceConnectedByPortIdAndAccess: () => never;
+export declare const isPortDeviceDisconnectedByPortIdAndAccess: () => never;
+//# sourceMappingURL=doesMutablePortPropertyHaveSpecificValueByPortIdAndAccess.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdAndAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doesMutablePortPropertyHaveSpecificValueByPortIdAndAccess.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdAndAccess.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,wCAAwC,aAEpD,CAAA;AAGD,eAAO,MAAM,sCAAsC,aAElD,CAAA;AAGD,eAAO,MAAM,yCAAyC,aAErD,CAAA;AAGD,eAAO,MAAM,uCAAuC,aAEnD,CAAA;AAGD,eAAO,MAAM,0CAA0C,aAEtD,CAAA;AAGD,eAAO,MAAM,yCAAyC,aAErD,CAAA;AAGD,eAAO,MAAM,uCAAuC,aAEnD,CAAA;AAGD,eAAO,MAAM,0CAA0C,aAEtD,CAAA;AAGD,eAAO,MAAM,wCAAwC,aAEpD,CAAA;AAGD,eAAO,MAAM,2CAA2C,aAEvD,CAAA;AAGD,eAAO,MAAM,uCAAuC,aAEnD,CAAA;AAGD,eAAO,MAAM,qCAAqC,aAEjD,CAAA;AAGD,eAAO,MAAM,wCAAwC,aAEpD,CAAA;AAGD,eAAO,MAAM,sCAAsC,aAElD,CAAA;AAGD,eAAO,MAAM,yCAAyC,aAErD,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdInContext.d.ts

@@ -0,0 +1,65 @@
+/**
+ *
+ */
+export declare const closePortConnectionByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isInputConnectionClosedByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isInputConnectionOpenByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isInputConnectionPendingByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isInputDeviceConnectedByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isInputDeviceDisconnectedByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isOutputConnectionClosedByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isOutputConnectionOpenByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isOutputConnectionPendingByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isOutputDeviceConnectedByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isOutputDeviceDisconnectedByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isPortConnectionClosedByPortIdInContext: (id: import("../../EMIDIPort.ts").BothId) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isPortConnectionOpenByPortIdInContext: (id: import("../../EMIDIPort.ts").BothId) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isPortConnectionPendingByPortIdInContext: (id: import("../../EMIDIPort.ts").BothId) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isPortDeviceConnectedByPortIdInContext: (id: import("../../EMIDIPort.ts").BothId) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const isPortDeviceDisconnectedByPortIdInContext: (id: import("../../EMIDIPort.ts").BothId) => import("effect/Effect").Effect<import("../../Util.ts").IsEqualFlag<"isCertainConnectionState", "closed">, import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+//# sourceMappingURL=doesMutablePortPropertyHaveSpecificValueByPortIdInContext.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doesMutablePortPropertyHaveSpecificValueByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdInContext.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,eAAO,MAAM,oCAAoC,6SAGhD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,wCAAwC,6SAGpD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,sCAAsC,6SAGlD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,yCAAyC,6SAGrD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,uCAAuC,6SAGnD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,0CAA0C,6SAGtD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,yCAAyC,8SAGrD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,uCAAuC,8SAGnD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,0CAA0C,8SAGtD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,wCAAwC,8SAGpD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,2CAA2C,8SAGvD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,uCAAuC,qPAGnD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,qCAAqC,qPAGjD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,wCAAwC,qPAGpD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,sCAAsC,qPAGlD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,yCAAyC,qPAGrD,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPort.d.ts

@@ -0,0 +1,36 @@
+import * as Effect from 'effect/Effect';
+import type * as EMIDIPort from '../../EMIDIPort.ts';
+/**
+ * @returns A state of the hardware connection between the OS and the device
+ * ({@linkcode MIDIPortDeviceState}). Because it can change over time, it's
+ * wrapped in effect. It's taken from the {@linkcode MIDIPort.state|state}
+ * read-only property of the {@linkcode MIDIPort} interface ([MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIPort/state)).
+ */
+export declare const getPortDeviceStateByPort: <E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, MIDIPortType>) => Effect.Effect<MIDIPortDeviceState, E, R>;
+/**
+ * @returns A state of the connection between the browser's tab and OS
+ * abstraction of the device ({@linkcode MIDIPortConnectionState}). Because it
+ * can change over time, it's wrapped in effect. It's taken from the
+ * {@linkcode MIDIPort.connection|connection} read-only property of the
+ * {@linkcode MIDIPort} interface ([MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIPort/connection)).
+ */
+export declare const getPortConnectionStateByPort: <E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, MIDIPortType>) => Effect.Effect<MIDIPortConnectionState, E, R>;
+/**
+ *
+ */
+export declare const getInputDeviceStateByPort: <E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, "input">) => Effect.Effect<MIDIPortDeviceState, E, R>;
+/**
+ *
+ */
+export declare const getInputConnectionStateByPort: <E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, "input">) => Effect.Effect<MIDIPortConnectionState, E, R>;
+/**
+ *
+ */
+export declare const getOutputDeviceStateByPort: <E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, "output">) => Effect.Effect<MIDIPortDeviceState, E, R>;
+/**
+ *
+ */
+export declare const getOutputConnectionStateByPort: <E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, "output">) => Effect.Effect<MIDIPortConnectionState, E, R>;
+//# sourceMappingURL=getMutablePortPropertyByPort.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMutablePortPropertyByPort.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAqBpD;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GAhBlC,CAAC,UAAU,CAAC,qHAgBsD,CAAA;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,GA1BtC,CAAC,UAAU,CAAC,yHA0B+D,CAAA;AAE9E;;GAEG;AACH,eAAO,MAAM,yBAAyB,GA/BnC,CAAC,UAAU,CAAC,gHA+BgE,CAAA;AAE/E;;GAEG;AACH,eAAO,MAAM,6BAA6B,GApCvC,CAAC,UAAU,CAAC,oHAqC8B,CAAA;AAE7C;;GAEG;AACH,eAAO,MAAM,0BAA0B,GA1CpC,CAAC,UAAU,CAAC,iHA2C0B,CAAA;AAEzC;;GAEG;AACH,eAAO,MAAM,8BAA8B,GAhDxC,CAAC,UAAU,CAAC,qHAiD+B,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdAndAccess.d.ts

@@ -0,0 +1,23 @@
+import * as Effect from 'effect/Effect';
+import * as EMIDIAccess from '../../EMIDIAccess.ts';
+import type * as EMIDIInput from '../../EMIDIInput.ts';
+import type * as EMIDIOutput from '../../EMIDIOutput.ts';
+import type * as EMIDIPort from '../../EMIDIPort.ts';
+import * as MIDIErrors from '../../MIDIErrors.ts';
+/**
+ *
+ *
+ */
+export declare const getPortDeviceStateByPortIdAndAccess: <E = never, R = never>(polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>, id: EMIDIPort.BothId) => Effect.Effect<MIDIPortDeviceState, Exclude<E, {
+    _tag: "PortNotFound";
+}>, R>;
+/**
+ *
+ *
+ */
+export declare const getPortConnectionStateByPortIdAndAccess: <E = never, R = never>(polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>, id: EMIDIPort.BothId) => Effect.Effect<MIDIPortConnectionState, E | MIDIErrors.PortNotFoundError, R>;
+export declare const getInputConnectionStateByPortIdAndAccess: <E = never, R = never>(_polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>, _id: EMIDIInput.Id) => never;
+export declare const getInputDeviceStateByPortIdAndAccess: <E = never, R = never>(_polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>, _id: EMIDIInput.Id) => never;
+export declare const getOutputConnectionStateByPortIdAndAccess: <E = never, R = never>(_polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>, _id: EMIDIOutput.Id) => never;
+export declare const getOutputDeviceStateByPortIdAndAccess: <E = never, R = never>(_polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>, _id: EMIDIOutput.Id) => never;
+//# sourceMappingURL=getMutablePortPropertyByPortIdAndAccess.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdAndAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMutablePortPropertyByPortIdAndAccess.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdAndAccess.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,KAAK,WAAW,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,KAAK,UAAU,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,KAAK,WAAW,MAAM,sBAAsB,CAAA;AACxD,OAAO,KAAK,KAAK,SAAS,MAAM,oBAAoB,CAAA;AACpD,OAAO,KAAK,UAAU,MAAM,qBAAqB,CAAA;AAwCjD;;;GAGG;AACH,eAAO,MAAM,mCAAmC,GAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,qBACnD,WAAW,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,MAC1D,SAAS,CAAC,MAAM;;MAWnB,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,uCAAuC,GAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,qBACvD,WAAW,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,MAC1D,SAAS,CAAC,MAAM,gFAMnB,CAAA;AAGH,eAAO,MAAM,wCAAwC,GAAI,CAAC,UAAU,CAAC,8BAC/C,WAAW,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,OAC1D,UAAU,CAAC,EAAE,UAGnB,CAAA;AAGD,eAAO,MAAM,oCAAoC,GAAI,CAAC,UAAU,CAAC,8BAC3C,WAAW,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,OAC1D,UAAU,CAAC,EAAE,UAGnB,CAAA;AAGD,eAAO,MAAM,yCAAyC,GAAI,CAAC,UAAU,CAAC,8BAChD,WAAW,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,OAC1D,WAAW,CAAC,EAAE,UAGpB,CAAA;AAGD,eAAO,MAAM,qCAAqC,GAAI,CAAC,UAAU,CAAC,8BAC5C,WAAW,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,OAC1D,WAAW,CAAC,EAAE,UAGpB,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.d.ts

@@ -0,0 +1,35 @@
+import * as EMIDIAccess from '../../EMIDIAccess.ts';
+import type * as EMIDIInput from '../../EMIDIInput.ts';
+import type * as EMIDIOutput from '../../EMIDIOutput.ts';
+import type * as EMIDIPort from '../../EMIDIPort.ts';
+/**
+ *
+ *
+ */
+export declare const getPortDeviceStateByPortId: (id: EMIDIPort.BothId) => import("effect/Effect").Effect<MIDIPortDeviceState, never, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ *
+ */
+export declare const getPortConnectionStateByPortId: (id: EMIDIPort.BothId) => import("effect/Effect").Effect<MIDIPortConnectionState, import("../../MIDIErrors.ts").PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ *
+ */
+export declare const getInputDeviceStateByPortId: (id: EMIDIInput.Id) => never;
+/**
+ *
+ *
+ */
+export declare const getInputConnectionStateByPortId: (id: EMIDIInput.Id) => never;
+/**
+ *
+ *
+ */
+export declare const getOutputDeviceStateByPortId: (id: EMIDIOutput.Id) => never;
+/**
+ *
+ *
+ */
+export declare const getOutputConnectionStateByPortId: (id: EMIDIOutput.Id) => never;
+//# sourceMappingURL=getMutablePortPropertyByPortIdInContext.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMutablePortPropertyByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,KAAK,UAAU,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,KAAK,WAAW,MAAM,sBAAsB,CAAA;AACxD,OAAO,KAAK,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAGpD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAQ,SAAS,CAAC,MAAM,wFACO,CAAA;AAEtE;;;GAGG;AACH,eAAO,MAAM,8BAA8B,OAAQ,SAAS,CAAC,MAAM,sIACO,CAAA;AAE1E;;;GAGG;AACH,eAAO,MAAM,2BAA2B,OAAQ,UAAU,CAAC,EAAE,UACU,CAAA;AAEvE;;;GAGG;AACH,eAAO,MAAM,+BAA+B,OAAQ,UAAU,CAAC,EAAE,UACU,CAAA;AAE3E;;;GAGG;AACH,eAAO,MAAM,4BAA4B,OAAQ,WAAW,CAAC,EAAE,UACS,CAAA;AAExE;;;GAGG;AACH,eAAO,MAAM,gCAAgC,OAAQ,WAAW,CAAC,EAAE,UACS,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/getValueInRawPortFieldUnsafe.d.ts

@@ -0,0 +1,7 @@
+import * as EMIDIPort from '../EMIDIPort.ts';
+import type { MIDIPortMutableProperty } from './matchMutablePortProperty/matchMutablePortPropertyByPort.ts';
+/**
+ * @internal
+ */
+export declare const getValueInRawPortFieldUnsafe: <const TMIDIPortMutableProperty extends MIDIPortMutableProperty>(property: TMIDIPortMutableProperty) => (port: EMIDIPort.EMIDIPort) => MIDIPort[TMIDIPortMutableProperty];
+//# sourceMappingURL=getValueInRawPortFieldUnsafe.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/getValueInRawPortFieldUnsafe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getValueInRawPortFieldUnsafe.d.ts","sourceRoot":"","sources":["../../../../src/internal/mutablePropertyTools/getValueInRawPortFieldUnsafe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,iBAAiB,CAAA;AAC5C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8DAA8D,CAAA;AAE3G;;GAEG;AACH,eAAO,MAAM,4BAA4B,GACtC,KAAK,CAAC,wBAAwB,SAAS,uBAAuB,YACnD,wBAAwB,YAE7B,SAAS,CAAC,SAAS,uCACkB,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPort.d.ts

@@ -0,0 +1,71 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import * as Effect from 'effect/Effect';
+import * as EMIDIPort from '../../EMIDIPort.ts';
+/**
+ *
+ */
+export declare const matchPortConnectionStateByPort: DualMatchPortState<MIDIPortType, "connection">;
+/**
+ *
+ */
+export declare const matchPortDeviceStateByPort: DualMatchPortState<MIDIPortType, "state">;
+/**
+ *
+ */
+export declare const matchInputConnectionStateByPort: DualMatchPortState<"input", "connection">;
+/**
+ *
+ */
+export declare const matchInputDeviceStateByPort: DualMatchPortState<"input", "state">;
+/**
+ *
+ */
+export declare const matchOutputConnectionStateByPort: DualMatchPortState<"output", "connection">;
+/**
+ *
+ */
+export declare const matchOutputDeviceStateByPort: DualMatchPortState<"output", "state">;
+export type MIDIPortMutableProperty = 'state' | 'connection';
+export interface PortStateHandler {
+    (port: EMIDIPort.EMIDIPort): any;
+}
+export interface MatcherConfigPlain extends Record<string, PortStateHandler> {
+}
+export interface MatchResult<TActualConf extends MatcherConfigPlain, E, R> extends Effect.Effect<ReturnType<TActualConf[keyof TActualConf]>, E, R> {
+}
+export interface DualMatchPortState<THighLevelPortType extends MIDIPortType, TMIDIPortProperty extends MIDIPortMutableProperty> extends MatchStatePortLast<THighLevelPortType, TMIDIPortProperty>, MatchStatePortFirst<THighLevelPortType, TMIDIPortProperty> {
+}
+export interface MatchStatePortFirst<THighLevelPortType extends MIDIPortType, TMIDIPortProperty extends MIDIPortMutableProperty> {
+    /**
+     * Description placeholder
+     *
+     * @param polymorphicPort
+     * @param stateCaseToHandlerMap
+     * @returns
+     */
+    <TStateCaseToHandlerMap extends StateCaseToHandlerMap<TMIDIPortProperty, THighLevelPortType, TStateCaseToHandlerMap>, E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, THighLevelPortType>, stateCaseToHandlerMap: TStateCaseToHandlerMap): MatchResult<TStateCaseToHandlerMap, E, R>;
+}
+export interface MatchStatePortLast<THighLevelPortType extends MIDIPortType, TMIDIPortProperty extends MIDIPortMutableProperty> {
+    /**
+     * Description placeholder
+     *
+     * @param stateCaseToHandlerMap
+     * @returns
+     */
+    <TStateCaseToHandlerMap extends StateCaseToHandlerMap<TMIDIPortProperty, THighLevelPortType, TStateCaseToHandlerMap>>(stateCaseToHandlerMap: TStateCaseToHandlerMap): {
+        /**
+         * Description placeholder
+         *
+         * @param polymorphicPort
+         * @returns
+         */
+        <E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, THighLevelPortType>): MatchResult<TStateCaseToHandlerMap, E, R>;
+    };
+}
+export type StateCaseToHandlerMap<TMIDIPortProperty extends MIDIPortMutableProperty, TMIDIPortType extends MIDIPortType, TConfigSelf> = {
+    readonly [StateCase in MIDIPort[TMIDIPortProperty]]: (port: EMIDIPort.EMIDIPort<TMIDIPortType>) => any;
+} & {
+    readonly [RedundantValueCaseHandling in Exclude<keyof TConfigSelf, MIDIPort[TMIDIPortProperty]>]: never;
+};
+//# sourceMappingURL=matchMutablePortPropertyByPort.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchMutablePortPropertyByPort.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPort.ts"],"names":[],"mappings":"AAAA;gEACgE;AAEhE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAuC/C;;GAEG;AACH,eAAO,MAAM,8BAA8B,gDAG1C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B,2CAGtC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,+BAA+B,2CAG3C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,2BAA2B,sCAGvC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,gCAAgC,4CAG5C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,4BAA4B,uCAGxC,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG,OAAO,GAAG,YAAY,CAAA;AAE5D,MAAM,WAAW,gBAAgB;IAC/B,CAAC,IAAI,EAAE,SAAS,CAAC,SAAS,GAAG,GAAG,CAAA;CACjC;AACD,MAAM,WAAW,kBAAmB,SAAQ,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC;CAAG;AAE/E,MAAM,WAAW,WAAW,CAAC,WAAW,SAAS,kBAAkB,EAAE,CAAC,EAAE,CAAC,CACvE,SAAQ,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CAAG;AAE5E,MAAM,WAAW,kBAAkB,CACjC,kBAAkB,SAAS,YAAY,EACvC,iBAAiB,SAAS,uBAAuB,CACjD,SAAQ,kBAAkB,CAAC,kBAAkB,EAAE,iBAAiB,CAAC,EAC/D,mBAAmB,CAAC,kBAAkB,EAAE,iBAAiB,CAAC;CAAG;AAEjE,MAAM,WAAW,mBAAmB,CAClC,kBAAkB,SAAS,YAAY,EACvC,iBAAiB,SAAS,uBAAuB;IAEjD;;;;;;OAMG;IACH,CACE,sBAAsB,SAAS,qBAAqB,CAClD,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,CACvB,EACD,CAAC,GAAG,KAAK,EACT,CAAC,GAAG,KAAK,EAET,eAAe,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,kBAAkB,CAAC,EACpE,qBAAqB,EAAE,sBAAsB,GAC5C,WAAW,CAAC,sBAAsB,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAC7C;AAED,MAAM,WAAW,kBAAkB,CACjC,kBAAkB,SAAS,YAAY,EACvC,iBAAiB,SAAS,uBAAuB;IAEjD;;;;;OAKG;IACH,CACE,sBAAsB,SAAS,qBAAqB,CAClD,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,CACvB,EAED,qBAAqB,EAAE,sBAAsB,GAC5C;QACD;;;;;WAKG;QACH,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACnB,eAAe,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,kBAAkB,CAAC,GACnE,WAAW,CAAC,sBAAsB,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;KAC7C,CAAA;CACF;AAED,MAAM,MAAM,qBAAqB,CAC/B,iBAAiB,SAAS,uBAAuB,EACjD,aAAa,SAAS,YAAY,EAClC,WAAW,IACT;IACF,QAAQ,EAAE,SAAS,IAAI,QAAQ,CAAC,iBAAiB,CAAC,GAAG,CACnD,IAAI,EAAE,SAAS,CAAC,SAAS,CAAC,aAAa,CAAC,KACrC,GAAG;CACT,GAAG;IACF,QAAQ,EAAE,0BAA0B,IAAI,OAAO,CAC7C,MAAM,WAAW,EACjB,QAAQ,CAAC,iBAAiB,CAAC,CAC5B,GAAG,KAAK;CACV,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdAndAccess.d.ts

@@ -0,0 +1,7 @@
+export declare const matchInputConnectionStateByPortIdAndAccess: () => never;
+export declare const matchInputDeviceStateByPortIdAndAccess: () => never;
+export declare const matchOutputConnectionStateByPortIdAndAccess: () => never;
+export declare const matchOutputDeviceStateByPortIdAndAccess: () => never;
+export declare const matchPortConnectionStateByPortIdAndAccess: () => never;
+export declare const matchPortDeviceStateByPortIdAndAccess: () => never;
+//# sourceMappingURL=matchMutablePortPropertyByPortIdAndAccess.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdAndAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchMutablePortPropertyByPortIdAndAccess.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdAndAccess.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,0CAA0C,aAEtD,CAAA;AAGD,eAAO,MAAM,sCAAsC,aAElD,CAAA;AAGD,eAAO,MAAM,2CAA2C,aAEvD,CAAA;AAGD,eAAO,MAAM,uCAAuC,aAEnD,CAAA;AAGD,eAAO,MAAM,yCAAyC,aAErD,CAAA;AAGD,eAAO,MAAM,qCAAqC,aAEjD,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdInContext.d.ts

@@ -0,0 +1,28 @@
+import type * as EMIDIAccess from '../../EMIDIAccess.ts';
+import type * as MIDIErrors from '../../MIDIErrors.ts';
+import * as Match from './matchMutablePortPropertyByPort.ts';
+/**
+ *
+ */
+export declare const matchPortConnectionStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"connection", MIDIPortType, TStateCaseToHandlerMap>>(id: (string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) | (string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">), stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ */
+export declare const matchInputConnectionStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"connection", "input", TStateCaseToHandlerMap>>(id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">, stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ */
+export declare const matchOutputConnectionStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"connection", "output", TStateCaseToHandlerMap>>(id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">, stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ */
+export declare const matchPortDeviceStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"state", MIDIPortType, TStateCaseToHandlerMap>>(id: (string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) | (string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">), stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ */
+export declare const matchInputDeviceStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"state", "input", TStateCaseToHandlerMap>>(id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">, stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ */
+export declare const matchOutputDeviceStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"state", "output", TStateCaseToHandlerMap>>(id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">, stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+//# sourceMappingURL=matchMutablePortPropertyByPortIdInContext.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchMutablePortPropertyByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdInContext.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,WAAW,MAAM,sBAAsB,CAAA;AAGxD,OAAO,KAAK,KAAK,UAAU,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,KAAK,MAAM,qCAAqC,CAAA;AA+B5D;;GAEG;AACH,eAAO,MAAM,yCAAyC,GAdlD,sBAAsB,SAAS,KAAK,CAAC,qBAAqB,oDAIzD,wVAcF,CAAA;AAEH;;GAEG;AACH,eAAO,MAAM,0CAA0C,GAvBnD,sBAAsB,SAAS,KAAK,CAAC,qBAAqB,+CAIzD,qPAuBF,CAAA;AAEH;;GAEG;AACH,eAAO,MAAM,2CAA2C,GAhCpD,sBAAsB,SAAS,KAAK,CAAC,qBAAqB,gDAIzD,sPAgCF,CAAA;AAEH;;GAEG;AACH,eAAO,MAAM,qCAAqC,GAzC9C,sBAAsB,SAAS,KAAK,CAAC,qBAAqB,+CAIzD,wVAwCJ,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,sCAAsC,GAjD/C,sBAAsB,SAAS,KAAK,CAAC,qBAAqB,0CAIzD,qPAgDJ,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,uCAAuC,GAzDhD,sBAAsB,SAAS,KAAK,CAAC,qBAAqB,2CAIzD,sPAwDJ,CAAA"}

package/index.ts

@@ -0,0 +1 @@
+export * from './src/index.ts'