effect-web-midi 0.1.0

package/dist-types/src/internal/errors.d.ts

@@ -0,0 +1,260 @@
+import * as Schema from 'effect/Schema';
+import type * as Types from 'effect/Types';
+import * as EMIDIPort from './EMIDIPort.ts';
+declare const AbortError_base: Schema.TaggedErrorClass<AbortError, "AbortError", {
+    readonly _tag: Schema.tag<"AbortError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["AbortError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+}>;
+/**
+ * Thrown if the document or page is going to be closed due to user navigation.
+ *
+ * Wraps `DOMException { name: 'AbortError' }`
+ *
+ * @see {@link https://webidl.spec.whatwg.org/#aborterror|Web IDL spec}
+ */
+export declare class AbortError extends AbortError_base {
+}
+declare const UnderlyingSystemError_base: Schema.TaggedErrorClass<UnderlyingSystemError, "UnderlyingSystemError", {
+    readonly _tag: Schema.tag<"UnderlyingSystemError">;
+} & {
+    whileAskingForPermissions: Schema.Struct<{
+        sysex: Schema.optional<typeof Schema.Boolean>;
+        software: Schema.optional<typeof Schema.Boolean>;
+    }>;
+    cause: Schema.Struct<{
+        name: Schema.Literal<["InvalidStateError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+}>;
+/**
+ * Thrown if the underlying system raises any errors when trying to open the
+ * port.
+ *
+ * Wraps `DOMException { name: 'InvalidStateError' }`
+ *
+ * @see {@link https://webidl.spec.whatwg.org/#invalidstateerror|Web IDL spec}
+ */
+export declare class UnderlyingSystemError extends UnderlyingSystemError_base {
+}
+declare const MIDIAccessNotSupportedError_base: Schema.TaggedErrorClass<MIDIAccessNotSupportedError, "MIDIAccessNotSupportedError", {
+    readonly _tag: Schema.tag<"MIDIAccessNotSupportedError">;
+} & {
+    whileAskingForPermissions: Schema.Struct<{
+        sysex: Schema.optional<typeof Schema.Boolean>;
+        software: Schema.optional<typeof Schema.Boolean>;
+    }>;
+    cause: Schema.Struct<{
+        name: Schema.Literal<["ReferenceError", "TypeError", "NotSupportedError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+}>;
+/**
+ * Thrown if the MIDI API, or a certain configuration of it is not supported by
+ * the system.
+ *
+ * Wraps `ReferenceError | TypeError | DOMException { name: 'NotSupportedError' }`
+ *
+ * @see {@link https://webidl.spec.whatwg.org/#notsupportederror|Web IDL spec}
+ */
+export declare class MIDIAccessNotSupportedError extends MIDIAccessNotSupportedError_base {
+}
+declare const ClearingSendingQueueIsNotSupportedError_base: Schema.TaggedErrorClass<ClearingSendingQueueIsNotSupportedError, "ClearingSendingQueueIsNotSupportedError", {
+    readonly _tag: Schema.tag<"ClearingSendingQueueIsNotSupportedError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["TypeError", "NotSupportedError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+}>;
+/**
+ * Thrown on platforms where `.clear()` method of output ports is not supported
+ * (currently supported only in Firefox)
+ *
+ * Wraps `TypeError | DOMException { name: 'NotSupportedError' }`
+ *
+ * @see {@link https://webidl.spec.whatwg.org/#notsupportederror|Web IDL spec}
+ */
+export declare class ClearingSendingQueueIsNotSupportedError extends ClearingSendingQueueIsNotSupportedError_base {
+}
+declare const UnavailablePortError_base: Schema.TaggedErrorClass<UnavailablePortError, "UnavailablePortError", {
+    readonly _tag: Schema.tag<"UnavailablePortError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["InvalidAccessError", "NotAllowedError", "InvalidStateError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+}>;
+/**
+ * Thrown when attempt to open the port failed because it is unavailable (e.g.
+ * is already in use by another process and cannot be opened, or is
+ * disconnected).
+ *
+ * Wraps `DOMException { name: 'InvalidAccessError' | 'NotAllowedError' | 'InvalidStateError' }`
+ *
+ * @see Web IDL specs: {@link https://webidl.spec.whatwg.org/#invalidaccesserror|InvalidAccessError}, {@link https://webidl.spec.whatwg.org/#notallowederror|NotAllowedError}, {@link https://webidl.spec.whatwg.org/#invalidstateerror|InvalidStateError}
+ */
+export declare class UnavailablePortError extends UnavailablePortError_base {
+}
+declare const DisconnectedPortError_base: Schema.TaggedErrorClass<DisconnectedPortError, "DisconnectedPortError", {
+    readonly _tag: Schema.tag<"DisconnectedPortError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["InvalidStateError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+}>;
+/**
+ * Thrown when `.send` operation was called on a disconnected port.
+ *
+ * Wraps `DOMException { name: 'InvalidStateError' }`
+ *
+ * @see {@link https://webidl.spec.whatwg.org/#invalidaccesserror|Web IDL spec}
+ */
+export declare class DisconnectedPortError extends DisconnectedPortError_base {
+}
+declare const CantSendSysexMessagesError_base: Schema.TaggedErrorClass<CantSendSysexMessagesError, "CantSendSysexMessagesError", {
+    readonly _tag: Schema.tag<"CantSendSysexMessagesError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["InvalidAccessError", "NotAllowedError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+}>;
+/**
+ * Thrown when trying to send system exclusive message from the access handle,
+ * that doesn't have this permission
+ *
+ * Wraps `DOMException { name: 'InvalidAccessError' | 'NotAllowedError' }`
+ *
+ * @see Web IDL specs: {@link https://webidl.spec.whatwg.org/#invalidaccesserror|InvalidAccessError}, {@link https://webidl.spec.whatwg.org/#notallowederror|NotAllowedError}
+ */
+export declare class CantSendSysexMessagesError extends CantSendSysexMessagesError_base {
+}
+declare const MIDIAccessNotAllowedError_base: Schema.TaggedErrorClass<MIDIAccessNotAllowedError, "MIDIAccessNotAllowedError", {
+    readonly _tag: Schema.tag<"MIDIAccessNotAllowedError">;
+} & {
+    whileAskingForPermissions: Schema.Struct<{
+        sysex: Schema.optional<typeof Schema.Boolean>;
+        software: Schema.optional<typeof Schema.Boolean>;
+    }>;
+    cause: Schema.Struct<{
+        name: Schema.Literal<["NotAllowedError", "SecurityError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+}>;
+/**
+ * Thrown if the user, the system or their security settings denied the
+ * application from creating an {@linkcode EMIDIAccess.EMIDIAccessInstance} object
+ * with the requested {@linkcode EMIDIAccess.RequestMIDIAccessOptions|options}, or if the
+ * document is not allowed to use the feature (for example, because of a
+ * Permission Policy, or because the user previously denied a permission
+ * request).
+ *
+ * Wraps `DOMException { name: 'NotAllowedError' | 'SecurityError' }`
+ *
+ * @see Web IDL specs: {@link https://webidl.spec.whatwg.org/#notallowederror|NotAllowedError}, {@link https://webidl.spec.whatwg.org/#securityerror|SecurityError}
+ */
+export declare class MIDIAccessNotAllowedError extends MIDIAccessNotAllowedError_base {
+}
+declare const MalformedMidiMessageError_base: Schema.TaggedErrorClass<MalformedMidiMessageError, "MalformedMidiMessageError", {
+    readonly _tag: Schema.tag<"MalformedMidiMessageError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["TypeError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+    midiMessage: Schema.Array$<typeof Schema.Int>;
+}>;
+/**
+ * Thrown when data to be sent is not a valid sequence or does not contain a
+ * valid MIDI message
+ *
+ * Wraps `TypeError`
+ */
+export declare class MalformedMidiMessageError extends MalformedMidiMessageError_base {
+}
+declare const PortNotFoundError_base: Schema.TaggedErrorClass<PortNotFoundError, "PortNotFound", {
+    readonly _tag: Schema.tag<"PortNotFound">;
+} & {
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+}>;
+/**
+ * Keep in mind that if port isn't found, it might not mean it's disconnected.
+ * For example, virtual ports created by software won't show up in the list of
+ * available inputs/outputs of MIDI Access handle with disabled
+ * {@linkcode EMIDIAccess.RequestMIDIAccessOptions.software} flag.
+ */
+export declare class PortNotFoundError extends PortNotFoundError_base {
+}
+/**
+ *
+ * @internal
+ */
+export declare const remapErrorByName: <TErrorClassUnion extends new (arg: any) => Error>(map: {
+    [name: string]: TErrorClassUnion;
+}, absurdMessage: string, rest: Omit<Types.UnionToIntersection<TErrorClassUnion extends new (arg: infer P) => any ? P : never>, "cause">) => (cause: unknown) => InstanceType<TErrorClassUnion>;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist-types/src/internal/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/internal/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAE1C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;;;;;;;;;;;;;;;AA6B3C;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,eAE9B;CAAG;;;;;;;;;;;;;;;;;;;AAEL;;;;;;;GAOG;AACH,qBAAa,qBAAsB,SAAQ,0BAM1C;CAAG;;;;;;;;;;;;;;;;;;;AAEJ;;;;;;;GAOG;AACH,qBAAa,2BAA4B,SAAQ,gCAQhD;CAAG;;;;;;;;;;;;;;;;AAEJ;;;;;;;GAOG;AACH,qBAAa,uCAAwC,SAAQ,4CAM5D;CAAG;;;;;;;;;;;;;;;;AAEJ;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,SAAQ,yBAYzC;CAAG;;;;;;;;;;;;;;;;AAEJ;;;;;;GAMG;AACH,qBAAa,qBAAsB,SAAQ,0BAM1C;CAAG;;;;;;;;;;;;;;;;AAEJ;;;;;;;GAOG;AACH,qBAAa,0BAA2B,SAAQ,+BAM/C;CAAG;;;;;;;;;;;;;;;;;;;AAEJ;;;;;;;;;;;GAWG;AACH,qBAAa,yBAA0B,SAAQ,8BAM9C;CAAG;;;;;;;;;;;;;;;;;AAEJ;;;;;GAKG;AACH,qBAAa,yBAA0B,SAAQ,8BAO9C;CAAG;;;;;;AAEJ;;;;;GAKG;AACH,qBAAa,iBAAkB,SAAQ,sBAGtC;CAAG;AAEJ;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAExB,gBAAgB,SAAS,KAAK,GAAG,EAAE,GAAG,KAAK,KAAK,EAC/C,KAAK;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAAE,EACzC,eAAe,MAAM,EACrB,MAAM,IAAI,CACR,KAAK,CAAC,mBAAmB,CAEvB,gBAAgB,SAAS,KAAK,GAAG,EAAE,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,CAC/D,EACD,OAAO,CACR,MAEF,OAAO,OAAO,KAQP,YAAY,CAAC,gBAAgB,CACpC,CAAA"}

package/dist-types/src/internal/getPortByPortId/getPortByPortIdAndAccess.d.ts

@@ -0,0 +1,27 @@
+/** 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 * as Errors from '../errors.ts';
+/**
+ *
+ * If you want to ensure the type of returned port match the type of ID, use
+ * type-specific getters {@linkcode getInputByPortIdAndAccess} and
+ * {@linkcode getOutputByPortIdAndAccess}, because in runtime, these branded
+ * port IDs passed as function arguments, are just strings and cannot ensure
+ * soundness
+ */
+export declare const getPortByPortIdAndAccess: GetPortById<"input" | "output", "input" | "output", never, never, Errors.PortNotFoundError, never>;
+/**
+ *
+ *
+ */
+export declare const getInputByPortIdAndAccess: GetPortById<"input", "input", never, never, Errors.PortNotFoundError, never>;
+/**
+ *
+ *
+ */
+export declare const getOutputByPortIdAndAccess: GetPortById<"output", "output", never, never, Errors.PortNotFoundError, never>;
+export interface GetPortById<TReturnedPortType extends TTypeOfPortId, TTypeOfPortId extends MIDIPortType, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement> extends EMIDIAccess.GetThingByPortId<EMIDIPort.EMIDIPort<TReturnedPortType>, TTypeOfPortId, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError | Errors.PortNotFoundError, TAdditionalRequirement> {
+}
+//# sourceMappingURL=getPortByPortIdAndAccess.d.ts.map

package/dist-types/src/internal/getPortByPortId/getPortByPortIdAndAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPortByPortIdAndAccess.d.ts","sourceRoot":"","sources":["../../../../src/internal/getPortByPortId/getPortByPortIdAndAccess.ts"],"names":[],"mappings":"AAAA;gEACgE;AAIhE,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAGhD,OAAO,KAAK,KAAK,SAAS,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,MAAM,MAAM,cAAc,CAAA;AAuDtC;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,oGAGnC,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,8EAMpC,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,gFAMrC,CAAA;AAEF,MAAM,WAAW,WAAW,CAC1B,iBAAiB,SAAS,aAAa,EACvC,aAAa,SAAS,YAAY,EAClC,2BAA2B,EAC3B,iCAAiC,EACjC,gBAAgB,EAChB,sBAAsB,CACtB,SAAQ,WAAW,CAAC,gBAAgB,CAClC,SAAS,CAAC,SAAS,CAAC,iBAAiB,CAAC,EACtC,aAAa,EACb,2BAA2B,EAC3B,iCAAiC,EACjC,gBAAgB,GAAG,MAAM,CAAC,iBAAiB,EAC3C,sBAAsB,CACvB;CAAG"}

package/dist-types/src/internal/getPortByPortId/getPortByPortIdInContext.d.ts

@@ -0,0 +1,20 @@
+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 getPortByPortIdInContext: (id: EMIDIPort.BothId) => EMIDIAccess.AcquiredThing<EMIDIPort.EMIDIPort<"input" | "output">, never, EMIDIAccess.EMIDIAccess, never, never, import("../errors.ts").PortNotFoundError, never>;
+/**
+ *
+ *
+ */
+export declare const getInputByPortIdInContext: (id: EMIDIInput.Id) => EMIDIAccess.AcquiredThing<EMIDIPort.EMIDIPort<"input">, never, EMIDIAccess.EMIDIAccess, never, never, import("../errors.ts").PortNotFoundError, never>;
+/**
+ *
+ *
+ */
+export declare const getOutputByPortIdInContext: (id: EMIDIOutput.Id) => EMIDIAccess.AcquiredThing<EMIDIPort.EMIDIPort<"output">, never, EMIDIAccess.EMIDIAccess, never, never, import("../errors.ts").PortNotFoundError, never>;
+//# sourceMappingURL=getPortByPortIdInContext.d.ts.map

package/dist-types/src/internal/getPortByPortId/getPortByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPortByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../src/internal/getPortByPortId/getPortByPortIdInContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,KAAK,UAAU,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,WAAW,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,KAAK,SAAS,MAAM,iBAAiB,CAAA;AAGjD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GAAI,IAAI,SAAS,CAAC,MAAM,sKACF,CAAA;AAE3D;;;GAGG;AACH,eAAO,MAAM,yBAAyB,GAAI,IAAI,UAAU,CAAC,EAAE,2JACC,CAAA;AAE5D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GAAI,IAAI,WAAW,CAAC,EAAE,4JACA,CAAA"}

package/dist-types/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPort.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 EMIDIPort from '../EMIDIPort.ts';
+import * as StreamMaker from '../StreamMaker.ts';
+/**
+ * Function to create a stream of remapped {@linkcode MIDIConnectionEvent}s
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIConnectionEvent)
+ */
+export declare const makePortStateChangesStreamByPort: DualMakeStateChangesStream<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: DualMakeStateChangesStream<"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: DualMakeStateChangesStream<"output">;
+/**
+ * A custom type is needed because the port type will be generic, but this is
+ * not possible if using just {@linkcode createStreamMakerFrom}
+ */
+export interface DualMakeStateChangesStream<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 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 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 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;AAsChD;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,0CACI,CAAA;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,qCACI,CAAA;AAElD;;;;;GAKG;AACH,eAAO,MAAM,kCAAkC,sCACI,CAAA;AAEnD;;;GAGG;AACH,MAAM,WAAW,0BAA0B,CACzC,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,4 @@
+export declare const makeInputStateChangesStreamByPortIdAndAccess: () => never;
+export declare const makeOutputStateChangesStreamByPortIdAndAccess: () => never;
+export declare const makePortStateChangesStreamByPortIdAndAccess: () => never;
+//# 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":"AACA,eAAO,MAAM,4CAA4C,aAExD,CAAA;AAGD,eAAO,MAAM,6CAA6C,aAEzD,CAAA;AAGD,eAAO,MAAM,2CAA2C,aAEvD,CAAA"}

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

@@ -0,0 +1,20 @@
+import type * as EMIDIInput from '../../EMIDIInput.ts';
+import type * as EMIDIOutput from '../../EMIDIOutput.ts';
+import type * as EMIDIPort from '../../EMIDIPort.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: <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(id: EMIDIPort.BothId, options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>) => EMIDIPort.StateChangesStream<TOnNullStrategy, "input" | "output", import("../errors.ts").PortNotFoundError, import("../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export declare const makeInputStateChangesStreamByPortIdInContext: <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(id: EMIDIInput.Id, options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>) => EMIDIPort.StateChangesStream<TOnNullStrategy, "input", import("../errors.ts").PortNotFoundError, import("../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export declare const makeOutputStateChangesStreamByPortIdInContext: <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(id: EMIDIOutput.Id, options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>) => EMIDIPort.StateChangesStream<TOnNullStrategy, "output", import("../errors.ts").PortNotFoundError, import("../EMIDIAccess.ts").EMIDIAccess>;
+//# 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,OAAO,KAAK,KAAK,UAAU,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,KAAK,WAAW,MAAM,sBAAsB,CAAA;AACxD,OAAO,KAAK,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAEpD,OAAO,KAAK,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAGrD;;;GAGG;AACH,eAAO,MAAM,2CAA2C,GACtD,KAAK,CAAC,eAAe,SAAS,WAAW,CAAC,cAAc,GAAG,SAAS,EAEpE,IAAI,SAAS,CAAC,MAAM,EACpB,UAAU,WAAW,CAAC,kBAAkB,CAAC,eAAe,CAAC,yJAKxD,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,4CAA4C,GACvD,KAAK,CAAC,eAAe,SAAS,WAAW,CAAC,cAAc,GAAG,SAAS,EAEpE,IAAI,UAAU,CAAC,EAAE,EACjB,UAAU,WAAW,CAAC,kBAAkB,CAAC,eAAe,CAAC,8IAKxD,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,6CAA6C,GACxD,KAAK,CAAC,eAAe,SAAS,WAAW,CAAC,cAAc,GAAG,SAAS,EAEpE,IAAI,WAAW,CAAC,EAAE,EAClB,UAAU,WAAW,CAAC,kBAAkB,CAAC,eAAe,CAAC,+IAKxD,CAAA"}

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":"AACA,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,16 @@
+export declare const isInputConnectionClosedByPortIdInContext: () => never;
+export declare const isInputConnectionOpenByPortIdInContext: () => never;
+export declare const isInputConnectionPendingByPortIdInContext: () => never;
+export declare const isInputDeviceConnectedByPortIdInContext: () => never;
+export declare const isInputDeviceDisconnectedByPortIdInContext: () => never;
+export declare const isOutputConnectionClosedByPortIdInContext: () => never;
+export declare const isOutputConnectionOpenByPortIdInContext: () => never;
+export declare const isOutputConnectionPendingByPortIdInContext: () => never;
+export declare const isOutputDeviceConnectedByPortIdInContext: () => never;
+export declare const isOutputDeviceDisconnectedByPortIdInContext: () => never;
+export declare const isPortConnectionClosedByPortIdInContext: () => never;
+export declare const isPortConnectionOpenByPortIdInContext: () => never;
+export declare const isPortConnectionPendingByPortIdInContext: () => never;
+export declare const isPortDeviceConnectedByPortIdInContext: () => never;
+export declare const isPortDeviceDisconnectedByPortIdInContext: () => never;
+//# 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":"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/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;AACvC,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,22 @@
+import * as Effect from 'effect/Effect';
+import * as EMIDIAccess from '../../EMIDIAccess.ts';
+import type * as EMIDIPort from '../../EMIDIPort.ts';
+import * as Errors from '../../errors.ts';
+import type * as Util from '../../util.ts';
+/**
+ *
+ *
+ */
+export declare const getPortDeviceStateByPortIdAndAccess: <TE = never, TR = never>(polymorphicAccess: Util.PolymorphicEffect<EMIDIAccess.EMIDIAccessInstance, TE, TR>, id: EMIDIPort.BothId) => Effect.Effect<MIDIPortDeviceState, Exclude<TE, {
+    _tag: "PortNotFound";
+}>, TR>;
+/**
+ *
+ *
+ */
+export declare const getPortConnectionStateByPortIdAndAccess: <TE = never, TR = never>(polymorphicAccess: Util.PolymorphicEffect<EMIDIAccess.EMIDIAccessInstance, TE, TR>, id: EMIDIPort.BothId) => Effect.Effect<MIDIPortConnectionState, Errors.PortNotFoundError | TE, TR>;
+export declare const getInputConnectionStateByPortIdAndAccess: () => never;
+export declare const getInputDeviceStateByPortIdAndAccess: () => never;
+export declare const getOutputConnectionStateByPortIdAndAccess: () => never;
+export declare const getOutputDeviceStateByPortIdAndAccess: () => 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;AAIvC,OAAO,KAAK,WAAW,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,KAAK,SAAS,MAAM,oBAAoB,CAAA;AACpD,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAA;AACzC,OAAO,KAAK,KAAK,IAAI,MAAM,eAAe,CAAA;AA0C1C;;;GAGG;AACH,eAAO,MAAM,mCAAmC,GAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EACxE,mBAAmB,IAAI,CAAC,iBAAiB,CACvC,WAAW,CAAC,mBAAmB,EAC/B,EAAE,EACF,EAAE,CACH,EACD,IAAI,SAAS,CAAC,MAAM;;OAWnB,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,uCAAuC,GAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAC5E,mBAAmB,IAAI,CAAC,iBAAiB,CACvC,WAAW,CAAC,mBAAmB,EAC/B,EAAE,EACF,EAAE,CACH,EACD,IAAI,SAAS,CAAC,MAAM,8EAMnB,CAAA;AAGH,eAAO,MAAM,wCAAwC,aAEpD,CAAA;AAGD,eAAO,MAAM,oCAAoC,aAEhD,CAAA;AAGD,eAAO,MAAM,yCAAyC,aAErD,CAAA;AAGD,eAAO,MAAM,qCAAqC,aAEjD,CAAA"}