@reventlessdev/trait-address-geocoding 1.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://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 2019-2026 Martin Lorenz
+
+   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
+
+       http://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,92 @@
+# @reventlessdev/trait-address-geocoding
+
+A **domain trait**: the reusable middle of turning an aggregate's address into a map
+point without corrupting the aggregate's data. The rules are a module the host calls;
+the types are the host's own. What it ships:
+
+| Part | Where |
+|---|---|
+| The decision rules | `src/AddressGeocoding_Guards.res` (staleness, redelivery, the supplied pair) |
+| The slice body | `src/AddressGeocoding_Translate.res` (`translate`, `exhaustedReason`) |
+| The host contract, as a type | `src/AddressGeocoding.res` (`module type Binding`) |
+| The conformance suite | `src/AddressGeocoding_Conformance.res` (`Make(Binding).register()`) |
+| The emitter | `src/AddressGeocoding_Scaffold.res` (`emit(~config, ~into, ~tests)`) |
+
+The rule modules are compiled code a host imports at runtime, so a change to them is a
+behavior change for every host: version it `fix:`/`feat:` accordingly.
+
+Most of this graft is not emitted at all. The four facts and the two `@noApi` report
+commands are real constructors the host **splices** — `...AddressGeocoding.events` and
+`...AddressGeocoding.reportCommands` — so the compiler carries them, annotations and
+schema included. The emitter writes the outbound slice, which the host does not have
+yet, and prints the arms that belong inside the aggregate, its behavior and the
+projection: those interleave with the host's own state machine, and placing an arm in
+an ordered `switch` is an AST operation a text splice gets silently wrong.
+
+The confidence rule — what a geocoder's reply *means* — is core's
+(`Reventless.Geocoding`, `Reventless.Geolocation`). This package owns how that reply is
+grafted onto an aggregate:
+
+- **`resolvedFrom` is a staleness token.** An answer for an address the entity has
+  since changed is dropped, not applied.
+- **Redelivery is a no-op.** The slice re-publishes on every heartbeat sweep until its
+  TODO clears, so an unchanged answer must not append a duplicate event.
+- **An outage is not a verdict.** `Unavailable` retries; `NoMatch` records a fact.
+- **The stand-down.** A client that supplies address and point together is not raced
+  by the geocoder: the pair-supplying event is not in the slice's consumed set.
+- **Two state fields** (`location` + `locationResolvedFrom`), because never-asked,
+  found, and tried-and-found-wanting do not fit in one `option`.
+
+## Grafting a host
+
+1. Run the emitter. Every `--key` is a field of its config, and it validates them, so
+   run it once to be told what it wants:
+
+```sh
+pnpm exec graft-trait @reventlessdev/trait-address-geocoding \
+  --into src/Customer --tests tests/Customer \
+  --entity Customer --entityId customerId --created Registered \
+  --createdFields 'email: string' --createdValues 'email: "alice@x.y"' \
+  --externalSystem AwsLocation
+```
+
+   It writes the slice, its translation body and the conformance binding — whole, so
+   the suite below needs no hand-written file — and prints three patches.
+
+2. Paste the three patches. The aggregate's is two spread lines plus the arms for
+   `commandTransition`; the behavior's is the state fields and the `evolve` / `decide`
+   arms; the projection's is the view's `geolocation` field and its arms.
+
+   Policy is yours and is not config. Which states an address may change in goes in
+   the `commandTransition` switch, over a `type lifecycleState = <YourView>.<enum>`
+   you declare beside it — the compiler resolves the constructors, the switch is
+   exhaustive so it names any spliced command you have not answered for, and every
+   arm has to draw on that one lifecycle. Who may send the commands goes in
+   `commandAuthorization` the same way.
+
+   A host whose subject is not called `address`, or is not a `string`, gets the same
+   graft with the constructors spelled out instead of spliced — pass `--subject`, and
+   the printed patch says which of the two you got.
+
+3. Run the emitted conformance binding — `tests/<…>/AddressGeocodingConformance_GWT.res`
+   registers the suite as it stands, and it goes green once the patches are in. 13
+   assertions, over your constructors, not the trait's.
+
+4. Keep the capability declaration the emitter wrote onto the slice's spec, so the
+   deployment is checked rather than trusted:
+
+```rescript
+let capabilityNeeds = TraitAddressGeocoding.AddressGeocoding.capabilityNeeds
+```
+
+   The declaration reaches the plugin's `capabilities.json`, the platform's
+   generated capability list, and a deploy-time gate that refuses a plugin whose
+   platform provisions no place index. Skip it and the deploy succeeds, the slice
+   exhausts its retries, and every address is recorded as permanently
+   unresolvable — with no error anywhere.
+
+   The platform provisions the capability itself: `Capability_Geocoding_AwsLocation`
+   on AWS, passed as `~geocoderPlaceIndex`; `Capabilities.none` locally, which
+   answers `Unavailable` on purpose.
+
+The specimen host is `examples/online-shop-hybrid/ordering` (`Customer`).

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@reventlessdev/trait-address-geocoding",
+  "version": "1.0.0-alpha.1",
+  "description": "Address-geocoding domain trait: rules, host contract, conformance suite and emitter for grafting geocoding onto an aggregate",
+  "license": "Apache-2.0",
+  "files": [
+    "src/**/*.res",
+    "src/**/*.resi",
+    "src/**/*.res.mjs",
+    "rescript.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "sury": "11.0.0-rc.2",
+    "sury-ppx": "11.0.0-rc.2",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.153",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.199",
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.75",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.125"
+  },
+  "devDependencies": {
+    "rescript": "12.3.0"
+  },
+  "peerDependencies": {
+    "rescript": "12.3.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ReventlessDev/reventless-core.git",
+    "directory": "traits/address-geocoding"
+  },
+  "scripts": {
+    "build": "rescript build",
+    "start": "rescript watch",
+    "clean": "rescript clean",
+    "rebuild": "pnpm run clean && pnpm run build",
+    "test": "echo \"The conformance suite runs in its hosts; see README.md.\""
+  }
+}

package/rescript.json

@@ -0,0 +1,29 @@
+{
+  "name": "@reventlessdev/trait-address-geocoding",
+  "package-specs": {
+    "module": "esmodule",
+    "in-source": true
+  },
+  "namespace": "TraitAddressGeocoding",
+  "ppx-flags": [
+    "@reventlessdev/reventless-ppx/bin",
+    "sury-ppx/bin"
+  ],
+  "warnings": {
+    "error": "-44+101"
+  },
+  "sources": [
+    {
+      "dir": "src",
+      "subdirs": true
+    }
+  ],
+  "dependencies": [
+    "sury",
+    "@reventlessdev/reventless-spec",
+    "@reventlessdev/reventless-infra",
+    "@reventlessdev/reventless-gwt"
+  ],
+  "compiler-flags": [],
+  "suffix": ".res.mjs"
+}

package/src/AddressGeocoding.res

@@ -0,0 +1,177 @@
+/**
+The host contract of the address-geocoding trait: what an aggregate and its
+outbound slice expose so the graft rules can be checked against them. The rules —
+staleness, redelivery, an outage is not a verdict, the stand-down — live in
+`AddressGeocoding_Guards` and `AddressGeocoding_Translate` and are asserted through a
+host by `AddressGeocoding_Conformance`; the confidence rule stays core's
+(`Reventless.Geocoding`). The spec surface is written by `AddressGeocoding_Scaffold`.
+*/
+
+/** Whether the graft reports back into its host. This trait does — the two `@noApi`
+    commands — and the runner accepts nothing else yet; the flag is here so a
+    competency that only observes is not mis-modelled as one that writes. */
+type posture = WritesBack | Observes
+
+/**
+This trait's own account of itself, for a host to name in its `traits` and for the
+plugin structure to record.
+
+The version is read from this package rather than written here, so it cannot drift
+from what was actually installed. A host names this value, so a renamed or removed
+trait is a build error rather than a row that outlives its dependency.
+*/
+let declaration: Reventless.Trait.t = {
+  trait: "@reventlessdev/trait-address-geocoding",
+  version: Reventless.PackageVersion.fromModuleUrl(%raw(`import.meta.url`)),
+  posture: WritesBack,
+}
+
+/**
+The platform capabilities a host of this trait needs, for its outbound slice's
+`capabilityNeeds` to name.
+
+Exported as a value rather than stated in the README because forgetting it is
+silent and terminal: an unprovisioned geocoder answers `Unavailable`, the slice
+retries its budget, `onExhausted` fires, and every address the host ever sees is
+recorded as permanently unresolvable — correct data, a permanent wrong verdict,
+no error. A host that spells this reaches a deploy-time refusal instead.
+*/
+let capabilityNeeds: array<Reventless.CapabilityNeed.t> = [Geocoding]
+
+/**
+The four facts the graft appends, as real constructors a host splices into its own
+event type:
+
+```rescript
+type event =
+  | Registered({email: string, address: string})
+  | ...TraitAddressGeocoding.AddressGeocoding.events
+  | Deactivated
+```
+
+The host's `evolve` then matches `LocationSet`, `AddressUpdated` and the rest
+unqualified, and sury splices the schema flat — the wire format and the generated
+GraphQL are identical to hand-written arms, not nested. This is what a spread
+replaces: four declarations that every host copied and could mistype.
+
+**Concrete, where `Binding` is abstract.** `Binding.subject` is abstract so the
+trait's *rules* hold for any address-shaped thing; these constructors fix
+`address: string` and fix the word "Address", because a spread cannot rename what
+it splices. A host whose subject is not a string, or that calls it something else,
+does not spread — it declares its own arms, which the scaffold's patch prints for
+it. The rules, the contract and the conformance suite are the same either way.
+
+Aggregate state is deliberately not here: it is snapshotted, so a trait-owned
+record inside it would turn every reshaping release into a migration.
+*/
+@schema
+type events =
+  /** A new address invalidates what was resolved, which is what puts the row back
+      in front of the slice. */
+  | AddressUpdated({address: string})
+  /** `resolvedFrom` is provenance, not the address of record; it is what makes "is
+      the pin still current?" decidable rather than assumed. */
+  | LocationSet({location: Reventless.GeoPoint.t, resolvedFrom: string})
+  /** Both halves from a client. Deliberately not `AddressUpdated` + `LocationSet`:
+      the slice collects the former, so emitting it here would spend a request
+      re-geocoding an address a human just pinned, then race the machine's answer
+      against theirs. This event is not in the slice's consumed set — the stand-down. */
+  | AddressLocated({address: string, location: Reventless.GeoPoint.t})
+  /** A fact, not an absence: `location: None` already means "not looked up yet",
+      and one state meaning two things is one nobody can act on. */
+  | AddressUnresolvable({address: string, reason: string})
+
+/**
+The two commands the outbound slice reports its answer through, as constructors a
+host splices into its own command type.
+
+Both are `@noApi`: they are the slice's shape, not a caller's. `SetLocation`
+carries a `resolvedFrom` staleness token that only the slice can supply, and a
+client correcting a row does it through the host's own public command instead.
+
+The exclusion travels with the spread — it is recorded on each member, not only
+on this union — so a host that splices these does not publish them.
+*/
+@schema
+type reportCommands =
+  | @noApi SetLocation({location: Reventless.GeoPoint.t, resolvedFrom: string})
+  | @noApi MarkAddressUnresolvable({address: string, reason: string})
+
+/**
+The two commands a caller changes the address through, as constructors a host
+splices into its own command type.
+
+These are public, and that is what kept them out of the trait until now. Both
+are legal only while the entity is in some state the HOST names, and a
+`@transition` cannot be attached to a constructor a host did not declare — it
+lowers to a dict on the parent union, and a spread splices members. So the pair
+stayed hand-written in every host, which is the whole of what a spreading host
+still had to transcribe.
+
+`commandTransition` is what freed them: the host answers for them in an
+exhaustive switch, in its own lifecycle vocabulary, and the compiler will not let
+it forget. The trait owns the shape; the host owns the policy; nothing crosses as
+a string.
+
+The rule that shapes the pair: **whoever supplies a point supplies the address it
+belongs to.** A caller never sends a bare coordinate — that is `SetLocation`
+above, the slice's shape and internal. `SetAddressLocation` covers the pin-only
+correction too, as the same address with a new point.
+*/
+@schema
+type addressCommands =
+  /** Change the address and let the geocoder find the point. */
+  | UpdateAddress({address: string})
+  /** Change the address *and* say where it is — a client that already has a
+      point, because it geocoded or a human dragged the pin. Suppresses the
+      geocoder for this address, there being nothing left to look up. */
+  | SetAddressLocation({address: string, location: Reventless.GeoPoint.t})
+
+/** One host, bound. Written over an abstract `subject` (the address) so retyping it
+    is a re-instantiation of this module, not a break in the trait. */
+module type Binding = {
+  type subject
+  /** The text handed to the geocoder, and the second half of the TODO key. */
+  let subjectText: subject => string
+  /** Two subjects that differ, for histories in which the address changes. */
+  let subjectA: subject
+  let subjectB: subject
+
+  let posture: posture
+
+  module Spec: ReventlessGwt.Behavior_GWT.AggregateSpec
+  module Behavior: Reventless.Behavior.T with module Spec = Spec
+
+  /** History leaving the entity active at `subject` with nothing resolved. */
+  let created: subject => array<Spec.event>
+  /** The event a subject change appends. It must invalidate what was resolved. */
+  let subjectChanged: subject => Spec.event
+  /** The two facts the graft appends. */
+  let located: (~point: Reventless.GeoPoint.t, ~resolvedFrom: subject) => Spec.event
+  let unresolvable: (~subject: subject, ~reason: string) => Spec.event
+  /** The two commands the slice reports through. */
+  let setLocation: (~point: Reventless.GeoPoint.t, ~resolvedFrom: subject) => Spec.command
+  let markUnresolvable: (~subject: subject, ~reason: string) => Spec.command
+
+  module Slice: ReventlessGwt.OutboundTranslation_GWT.SliceSpec
+  let translate: (
+    string,
+    Slice.outboundItem,
+    ~capabilities: Reventless.Capabilities.t,
+  ) => promise<result<option<(string, Slice.inboundCommand)>, string>>
+  let item: (~entityId: string, ~subject: subject) => Slice.outboundItem
+  /** One consumed event per trigger, carrying `subject`. Every event type the slice
+      consumes must appear here — the consumed set may not be wider than its triggers. */
+  let triggers: subject => array<Slice.consumedEvent>
+  /** The host events that carry address and point together. The slice must not
+      consume them: that is the stand-down.
+
+      Real events rather than their type names. A name is a string the compiler
+      never sees, so a misspelling here does not fail — it names an event that
+      cannot be in any consumed set, and the assertion passes for the wrong
+      reason, which is the one outcome a conformance suite must not have. The
+      runner encodes these itself. */
+  let standsDownOn: array<Spec.event>
+  let isLocation: Slice.inboundCommand => bool
+  let isVerdict: Slice.inboundCommand => bool
+}

package/src/AddressGeocoding.res.mjs

@@ -0,0 +1,77 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
+import * as GeoPoint$Reventless from "@reventlessdev/reventless-spec/src/semantic/GeoPoint.res.mjs";
+import * as PackageVersion$Reventless from "@reventlessdev/reventless-spec/src/PackageVersion.res.mjs";
+
+let declaration_version = PackageVersion$Reventless.fromModuleUrl(import.meta.url);
+
+let declaration = {
+  trait: "@reventlessdev/trait-address-geocoding",
+  version: declaration_version,
+  posture: "WritesBack"
+};
+
+let capabilityNeeds = ["Geocoding"];
+
+let eventsSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "AddressUpdated",
+    address: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "LocationSet",
+    location: s.m(GeoPoint$Reventless.schema),
+    resolvedFrom: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "AddressLocated",
+    address: s.m(Sury.string),
+    location: s.m(GeoPoint$Reventless.schema)
+  })),
+  Sury.$schema(s => ({
+    TAG: "AddressUnresolvable",
+    address: s.m(Sury.string),
+    reason: s.m(Sury.string)
+  }))
+]);
+
+let reportCommandsSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "SetLocation",
+    location: s.m(GeoPoint$Reventless.schema),
+    resolvedFrom: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "MarkAddressUnresolvable",
+    address: s.m(Sury.string),
+    reason: s.m(Sury.string)
+  }))
+]);
+
+let addressCommandsSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "UpdateAddress",
+    address: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "SetAddressLocation",
+    address: s.m(Sury.string),
+    location: s.m(GeoPoint$Reventless.schema)
+  }))
+]);
+
+let reportCommandsSchema$1 = Api$ReventlessInfra.markNoApiVariants(reportCommandsSchema, [
+  "SetLocation",
+  "MarkAddressUnresolvable"
+]);
+
+export {
+  declaration,
+  capabilityNeeds,
+  eventsSchema,
+  addressCommandsSchema,
+  reportCommandsSchema$1 as reportCommandsSchema,
+}
+/* declaration Not a pure module */