@effect-opcua/client 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,367 @@
+# @effect-opcua/client
+
+Effect-native OPC UA client wrapper for `node-opcua`.
+
+This is a first alpha package. The public API is intentionally small and is not
+1.0-stable yet. Breaking changes are expected when they improve correctness,
+ergonomics, performance, or the package boundary.
+
+## Requirements
+
+- Node.js 22 or newer.
+- ESM projects.
+- `effect` v4 beta as a peer dependency.
+
+```sh
+pnpm add @effect-opcua/client effect
+```
+
+## Public import paths
+
+Use only:
+
+- `@effect-opcua/client`
+- `@effect-opcua/client/node-opcua`
+
+Do not import source-module subpaths such as:
+
+- `@effect-opcua/client/Opcua`
+- `@effect-opcua/client/OpcuaClient`
+- `@effect-opcua/client/OpcuaError`
+- `@effect-opcua/client/internal/*`
+
+Those paths are intentionally not public.
+
+```ts
+import {
+  Opcua,
+  OpcuaClient,
+  OpcuaError,
+  OpcuaSession,
+} from "@effect-opcua/client";
+
+import {
+  DataType,
+  StatusCodes,
+  Variant,
+} from "@effect-opcua/client/node-opcua";
+```
+
+The root package is the normal user API. The `node-opcua` subpath is the raw
+escape hatch for OPC UA constants and values that are not wrapped yet.
+
+## Quickstart
+
+```ts
+import { Effect, Layer, Schema } from "effect";
+import { Opcua, OpcuaClient, OpcuaSession } from "@effect-opcua/client";
+
+const Temperature = Opcua.variable({
+  nodeId: "ns=2;s=Machine.Temperature",
+  codec: Opcua.schema(Schema.Number),
+});
+
+const Setpoint = Opcua.variable({
+  nodeId: "ns=2;s=Machine.Setpoint",
+  codec: Opcua.schema(Schema.Number),
+  access: "readWrite",
+});
+
+const Reset = Opcua.method({
+  objectId: "ns=2;s=Machine",
+  methodId: "ns=2;s=Machine.Reset",
+  input: {
+    mode: Opcua.arg({
+      name: "Mode",
+      codec: Opcua.schema(Schema.Literals(["soft", "hard"])),
+    }),
+  },
+  output: {
+    ok: Opcua.arg({
+      name: "Ok",
+      codec: Opcua.schema(Schema.Boolean),
+    }),
+  },
+});
+
+const program = Effect.gen(function* () {
+  const current = yield* OpcuaSession.read(Temperature);
+  const written = yield* OpcuaSession.write(Setpoint, 42);
+  const reset = yield* OpcuaSession.call(Reset, { mode: "soft" });
+
+  return { current, written, reset };
+});
+
+const MainLayer = OpcuaSession.layer().pipe(
+  Layer.provide(
+    OpcuaClient.layer({
+      endpointUrl: "opc.tcp://localhost:4840",
+      clientOptions: { endpointMustExist: false },
+    }),
+  ),
+);
+
+await Effect.runPromise(Effect.scoped(program).pipe(Effect.provide(MainLayer)));
+```
+
+`OpcuaClient.layer` owns the TCP connection. `OpcuaSession.layer` owns the OPC
+UA session. Use `Effect.scoped` so client, session, subscription, and monitor
+finalizers run on exit or interruption.
+
+## Connection Profiles
+
+A connection profile is usually just a small layer factory:
+
+```ts
+import { Layer } from "effect";
+import { OpcuaClient, OpcuaSession } from "@effect-opcua/client";
+
+export const makeOpcuaLayer = (endpointUrl: string) =>
+  OpcuaSession.layer({
+    batching: {
+      read: { maxNodesPerRead: 250, maxConcurrentRequests: 1 },
+      write: { maxNodesPerWrite: 100, maxConcurrentRequests: 1 },
+      call: { maxMethodsPerCall: 50, maxConcurrentRequests: 1 },
+    },
+  }).pipe(
+    Layer.provide(
+      OpcuaClient.layer({
+        endpointUrl,
+        clientOptions: { endpointMustExist: false },
+      }),
+    ),
+  );
+```
+
+Pass `userIdentity` to `OpcuaSession.layer(...)` when the server requires
+session authentication. Pass raw `OPCUAClientOptions` through
+`OpcuaClient.layer({ clientOptions })` for node-opcua connection settings.
+
+## Read, Write, And Call
+
+Reads, writes, and method calls return OPC UA statuses as data. A good read is a
+`Value`; a non-good server status is a `NonGoodStatus`.
+
+```ts
+const program = Effect.gen(function* () {
+  const sample = yield* OpcuaSession.read(Temperature);
+
+  if (sample._tag === "Value") {
+    console.log(sample.value);
+  }
+
+  const written = yield* OpcuaSession.write(Setpoint, 42);
+  const reset = yield* OpcuaSession.call(Reset, { mode: "soft" });
+
+  return { written, reset };
+});
+```
+
+## Batches
+
+Use keyed batches when several nodes or methods should keep typed result keys:
+
+```ts
+const program = Effect.gen(function* () {
+  const snapshot = yield* OpcuaSession.readMany(
+    {
+      temperature: Temperature,
+      setpoint: Setpoint,
+    },
+    { validation: "strict" },
+  );
+
+  const writes = yield* OpcuaSession.writeMany({
+    setpoint: [Setpoint, 42],
+  });
+
+  const calls = yield* OpcuaSession.callMany({
+    reset: [Reset, { mode: "soft" }],
+  });
+
+  return { snapshot, writes, calls };
+});
+```
+
+Per-call service options can override the batching defaults supplied to
+`OpcuaSession.layer(...)`.
+
+## Browse
+
+```ts
+import { makeNodeClassMask } from "@effect-opcua/client/node-opcua";
+
+const program = Effect.gen(function* () {
+  const children = yield* OpcuaSession.browseChildren("ns=2;s=Machine", {
+    nodeClassMask: makeNodeClassMask("Variable"),
+  });
+
+  if (children._tag === "Browsed") {
+    for (const reference of children.references) {
+      console.log(reference.nodeId, reference.browseName);
+    }
+  }
+
+  return children;
+});
+```
+
+Use `OpcuaSession.browse`, `OpcuaSession.browseNext`, and
+`OpcuaSession.releaseBrowseContinuation` directly when you need explicit
+pagination control. `includeRaw: true` opts into raw node-opcua browse values.
+
+## Inspect nodes
+
+`OpcuaSession.inspectNode` reads node metadata and, only when requested, the
+current value and the data type definition:
+
+```ts
+const program = Effect.gen(function* () {
+  // Metadata only — safe for address-space navigation.
+  const node = yield* OpcuaSession.inspectNode("ns=2;s=Machine.State");
+
+  // Opt into the expensive parts on demand.
+  const details = yield* OpcuaSession.inspectNode("ns=2;s=Machine.State", {
+    value: true,
+    dataTypeDefinition: true,
+  });
+
+  return { node, details };
+});
+```
+
+Keep `value` off while browsing: reading the value of a custom-structure
+(`ExtensionObject`) variable forces node-opcua to populate its session-wide
+data type manager on first use, which can take many seconds on large or slow
+servers. With `value: true`, an unreadable node yields
+`{ _tag: "NotReadable" }` and a failed read yields `{ _tag: "ReadFailed" }`
+instead of failing the whole inspection.
+
+## Monitoring
+
+Subscriptions and monitors are scoped resources. Closing or interrupting the
+scope terminates created monitored item groups, shuts down client queues, and
+removes listeners.
+
+```ts
+import { Duration, Effect, Stream } from "effect";
+import { Opcua, OpcuaSession } from "@effect-opcua/client";
+
+const program = Effect.gen(function* () {
+  const subscription = yield* OpcuaSession.makeSubscription({
+    publishingInterval: Duration.millis(100),
+    maxNotificationsPerPublish: 0,
+    priority: 0,
+  });
+
+  const monitor = yield* subscription.monitor(
+    { temperature: Temperature },
+    {
+      startup: "strict",
+      validation: "strict",
+      samplingInterval: Duration.millis(250),
+      queueSize: 1,
+      discardOldest: true,
+      filter: Opcua.MonitorFilter.statusValue(),
+      timestamps: "source",
+      clientBuffer: Opcua.BufferPolicy.latest(),
+    },
+  );
+
+  yield* monitor.samples.pipe(
+    Stream.runForEach((sample) =>
+      Effect.sync(() => {
+        console.log(sample.key, sample._tag);
+      }),
+    ),
+  );
+});
+```
+
+Use `startup: "strict"` when all requested items must be active. Use
+`startup: "bestEffort"` when an HMI should start with accepted items and inspect
+rejections through `monitor.startup.failed`. Client buffering uses
+`Opcua.BufferPolicy.sliding(...)`, `dropping(...)`, or `latest()`.
+
+## ExtensionObject Structures
+
+Use `Opcua.structure(...)` for scalar OPC UA `ExtensionObject` payloads and
+`Opcua.structureArray(...)` for one-dimensional arrays.
+
+```ts
+const ScanSettings = Opcua.structure({
+  name: "ScanSettings",
+  dataTypeId: "ns=1;i=3010",
+  schema: Schema.Struct({
+    duration: Schema.Number,
+    cycles: Schema.Number,
+    dataAvailable: Schema.Boolean,
+  }),
+});
+
+const Settings = Opcua.variable({
+  nodeId: "ns=1;s=MyMachine.ScanSettings",
+  codec: ScanSettings,
+  access: "readWrite",
+});
+
+const program = Effect.gen(function* () {
+  yield* OpcuaSession.write(Settings, {
+    duration: 1000,
+    cycles: 5,
+    dataAvailable: true,
+  });
+});
+```
+
+Structure codecs need server metadata for the declared data type. The runtime
+uses `session.extractNamespaceDataType()` and `session.constructExtensionObject`
+through node-opcua. Scalar structures and one-dimensional arrays are supported;
+structure matrices, missing metadata, and opaque dynamic structures are not
+encoded by explicit structure codecs. Use generated structures when possible,
+or `Opcua.dynamic()` while exploring.
+
+## Errors
+
+Failed Effects represent local configuration errors, transport/service failures,
+access validation failures, encode/decode failures, lifecycle failures, and
+monitor startup/runtime failures. OPC UA service statuses that complete normally
+are returned as result data.
+
+```ts
+try {
+  await Effect.runPromise(
+    Effect.scoped(program).pipe(Effect.provide(MainLayer)),
+  );
+} catch (error) {
+  if (OpcuaError.isOpcuaError(error)) {
+    switch (error.reason._tag) {
+      case "Connect":
+      case "SessionCreate":
+      case "Configuration":
+      case "Service":
+      case "MonitorStartup":
+        console.error(error.reason);
+        break;
+    }
+  }
+}
+```
+
+## Raw Access
+
+Prefer the typed API first. Use raw access only for OPC UA capabilities that are
+not wrapped yet:
+
+- import constants and constructors from `@effect-opcua/client/node-opcua`;
+- read service `unsafeRaw` fields when you intentionally need raw node-opcua
+  objects;
+- pass `includeRaw: true` on operations that document raw result access.
+
+## More Documentation
+
+- [Workspace docs](https://github.com/bastikohn/effect-opcua/tree/main/docs)
+- [Getting started](https://github.com/bastikohn/effect-opcua/blob/main/docs/users/getting-started.md)
+- [Core concepts](https://github.com/bastikohn/effect-opcua/blob/main/docs/users/core-concepts.md)
+- [Recipes](https://github.com/bastikohn/effect-opcua/blob/main/docs/users/recipes.md)
+- [Code generation](https://github.com/bastikohn/effect-opcua/blob/main/docs/users/codegen.md)

package/dist/Opcua.d.mts

@@ -0,0 +1,13 @@
+import { NodeIdOfVariableDef, ReadableVariableDef, ValueOfVariableDef, VariableAccess, VariableDef, WritableVariableDef, make as make$1 } from "./OpcuaVariable.mjs";
+import { AnyStructureDef, StructureArrayDef, StructureDef } from "./internal/structures/model.mjs";
+import { BufferPolicy, MonitorDeadband, MonitorFilter } from "./OpcuaSubscription.mjs";
+import { AnySchema, CodecType, OpcuaCodec, SchemaType, dynamic, schema, structure, structureArray } from "./internal/values/codec.mjs";
+import { InputOfMethodDef, MethodArg, MethodArgSelector, MethodDef, OutputOfMethodDef, arg, make } from "./OpcuaMethod.mjs";
+
+//#region src/Opcua.d.ts
+declare namespace Opcua_d_exports {
+  export { AnySchema, AnyStructureDef, BufferPolicy, CodecType, InputOfMethodDef, MethodArg, MethodArgSelector, MethodDef, MonitorDeadband, MonitorFilter, NodeIdOfVariableDef, OpcuaCodec, OutputOfMethodDef, ReadableVariableDef, SchemaType, StructureArrayDef, StructureDef, ValueOfVariableDef, VariableAccess, VariableDef, WritableVariableDef, arg, dynamic, make as method, schema, structure, structureArray, make$1 as variable };
+}
+//#endregion
+export { type AnySchema, type AnyStructureDef, BufferPolicy, type CodecType, type InputOfMethodDef, type MethodArg, type MethodArgSelector, type MethodDef, MonitorDeadband, MonitorFilter, type NodeIdOfVariableDef, type OpcuaCodec, Opcua_d_exports, type OutputOfMethodDef, type ReadableVariableDef, type SchemaType, type StructureArrayDef, type StructureDef, type ValueOfVariableDef, type VariableAccess, type VariableDef, type WritableVariableDef, arg, dynamic, make as method, schema, structure, structureArray, make$1 as variable };
+//# sourceMappingURL=Opcua.d.mts.map

package/dist/Opcua.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Opcua.d.mts","names":[],"sources":["../src/Opcua.ts"],"sourcesContent":[],"mappings":""}

package/dist/Opcua.mjs

@@ -0,0 +1,23 @@
+import { __export } from "./_virtual/rolldown_runtime.mjs";
+import { dynamic, schema, structure, structureArray } from "./internal/values/codec.mjs";
+import { BufferPolicy, MonitorDeadband, MonitorFilter } from "./OpcuaSubscription.mjs";
+import { make as make$1 } from "./OpcuaVariable.mjs";
+import { arg, make } from "./OpcuaMethod.mjs";
+
+//#region src/Opcua.ts
+var Opcua_exports = /* @__PURE__ */ __export({
+	BufferPolicy: () => BufferPolicy,
+	MonitorDeadband: () => MonitorDeadband,
+	MonitorFilter: () => MonitorFilter,
+	arg: () => arg,
+	dynamic: () => dynamic,
+	method: () => make,
+	schema: () => schema,
+	structure: () => structure,
+	structureArray: () => structureArray,
+	variable: () => make$1
+});
+
+//#endregion
+export { BufferPolicy, MonitorDeadband, MonitorFilter, Opcua_exports, arg, dynamic, make as method, schema, structure, structureArray, make$1 as variable };
+//# sourceMappingURL=Opcua.mjs.map

package/dist/Opcua.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Opcua.mjs","names":[],"sources":["../src/Opcua.ts"],"sourcesContent":["export {\n  dynamic,\n  schema,\n  structure,\n  structureArray,\n  type AnySchema,\n  type CodecType,\n  type OpcuaCodec,\n  type SchemaType,\n} from \"./internal/values/codec.js\";\nexport type {\n  AnyStructureDef,\n  StructureArrayDef,\n  StructureDef,\n} from \"./internal/structures/model.js\";\nexport {\n  BufferPolicy,\n  MonitorDeadband,\n  MonitorFilter,\n} from \"./OpcuaSubscription.js\";\nexport {\n  make as variable,\n  type NodeIdOfVariableDef,\n  type ReadableVariableDef,\n  type ValueOfVariableDef,\n  type VariableAccess,\n  type VariableDef,\n  type WritableVariableDef,\n} from \"./OpcuaVariable.js\";\nexport {\n  arg,\n  make as method,\n  type InputOfMethodDef,\n  type MethodArg,\n  type MethodArgSelector,\n  type MethodDef,\n  type OutputOfMethodDef,\n} from \"./OpcuaMethod.js\";\n"],"mappings":""}

package/dist/OpcuaClient.d.mts

@@ -0,0 +1,27 @@
+import { OpcuaClientEvent } from "./internal/events/model.mjs";
+import { OpcuaConnectError } from "./OpcuaError.mjs";
+import { OPCUAClient, OPCUAClientOptions } from "node-opcua";
+import { Config, Context, Effect, Layer, Stream } from "effect";
+import * as effect_Scope0 from "effect/Scope";
+
+//#region src/OpcuaClient.d.ts
+declare namespace OpcuaClient_d_exports {
+  export { Client, ClientLayerConfig, ClientLayerOptions, ClientService, layer, layerConfig, make };
+}
+interface ClientService {
+  readonly events: Stream.Stream<OpcuaClientEvent>;
+  readonly unsafeRawClient: OPCUAClient;
+}
+declare const Client_base: Context.ServiceClass<Client, "@effect-opcua/client/OpcuaClient", ClientService>;
+declare class Client extends Client_base {}
+declare const make: (options: ClientLayerOptions) => Effect.Effect<ClientService, OpcuaConnectError, effect_Scope0.Scope>;
+type ClientLayerOptions = {
+  readonly endpointUrl: string;
+  readonly clientOptions?: OPCUAClientOptions;
+};
+declare const layer: (options: ClientLayerOptions) => Layer.Layer<Client, OpcuaConnectError, never>;
+type ClientLayerConfig = Config.Config<ClientLayerOptions>;
+declare const layerConfig: (config: ClientLayerConfig) => Layer.Layer<Client, OpcuaConnectError | Config.ConfigError, never>;
+//#endregion
+export { Client, ClientLayerConfig, ClientLayerOptions, ClientService, OpcuaClient_d_exports, layer, layerConfig, make };
+//# sourceMappingURL=OpcuaClient.d.mts.map

package/dist/OpcuaClient.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpcuaClient.d.mts","names":[],"sources":["../src/OpcuaClient.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAQiB,aAAA;mBACE,MAAA,CAAO,OAAO;4BACL;;cAC3B;cACY,MAAA,SAAe,WAAA;cAEf,gBAAiB,uBAAkB,MAAA,CAAA,OAAA,eAAA,iBAAA,EAAA,aAAA,CAAA,KAAA;KAGpC,kBAAA;;2BAEe;;cAGd,iBAAkB,uBAAkB,KAAA,CAAA,MAAA,QAAA,iBAAA;KAGrC,iBAAA,GAAoB,MAAA,CAAO,OAAO;AAjB7B,cAmBJ,WAnBiB,EAAA,CAAA,MAAA,EAmBM,iBAnBN,EAAA,GAmBuB,KAAA,CAAA,KAnBvB,CAmBuB,MAnBvB,EAmBuB,iBAAA,GAAA,MAAA,CAAA,WAnBvB,EAAA,KAAA,CAAA"}

package/dist/OpcuaClient.mjs

@@ -0,0 +1,20 @@
+import { __export } from "./_virtual/rolldown_runtime.mjs";
+import { makeClientService } from "./internal/client/make.mjs";
+import { Context, Effect, Layer } from "effect";
+
+//#region src/OpcuaClient.ts
+var OpcuaClient_exports = /* @__PURE__ */ __export({
+	Client: () => Client,
+	layer: () => layer,
+	layerConfig: () => layerConfig,
+	make: () => make
+});
+const TypeId = "@effect-opcua/client/OpcuaClient";
+var Client = class extends Context.Service()(TypeId) {};
+const make = (options) => Effect.map(makeClientService(options), Client.of);
+const layer = (options) => Layer.effect(Client, make(options));
+const layerConfig = (config) => Layer.effect(Client, Effect.flatMap(config, make));
+
+//#endregion
+export { Client, OpcuaClient_exports, layer, layerConfig, make };
+//# sourceMappingURL=OpcuaClient.mjs.map

package/dist/OpcuaClient.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpcuaClient.mjs","names":[],"sources":["../src/OpcuaClient.ts"],"sourcesContent":["import type { OPCUAClient, OPCUAClientOptions } from \"node-opcua\";\nimport { type Config, Context, Effect, Layer, type Stream } from \"effect\";\n\nimport { makeClientService } from \"./internal/client/make.js\";\nimport type { OpcuaClientEvent } from \"./internal/events/model.js\";\n\nconst TypeId = \"@effect-opcua/client/OpcuaClient\";\n\nexport interface ClientService {\n  readonly events: Stream.Stream<OpcuaClientEvent>;\n  readonly unsafeRawClient: OPCUAClient;\n}\nexport class Client extends Context.Service<Client, ClientService>()(TypeId) {}\n\nexport const make = (options: ClientLayerOptions) =>\n  Effect.map(makeClientService(options), Client.of);\n\nexport type ClientLayerOptions = {\n  readonly endpointUrl: string;\n  readonly clientOptions?: OPCUAClientOptions;\n};\n\nexport const layer = (options: ClientLayerOptions) =>\n  Layer.effect(Client, make(options));\n\nexport type ClientLayerConfig = Config.Config<ClientLayerOptions>;\n\nexport const layerConfig = (config: ClientLayerConfig) =>\n  Layer.effect(Client, Effect.flatMap(config, make));\n"],"mappings":";;;;;;;;;;;AAMA,MAAM,SAAS;AAMf,IAAa,SAAb,cAA4B,QAAQ,SAAgC,CAAC,OAAO,CAAC;AAE7E,MAAa,QAAQ,YACnB,OAAO,IAAI,kBAAkB,QAAQ,EAAE,OAAO,GAAG;AAOnD,MAAa,SAAS,YACpB,MAAM,OAAO,QAAQ,KAAK,QAAQ,CAAC;AAIrC,MAAa,eAAe,WAC1B,MAAM,OAAO,QAAQ,OAAO,QAAQ,QAAQ,KAAK,CAAC"}