@voltro/datetime 0.29.0

package/LICENSE

@@ -0,0 +1,57 @@
+Voltro — Proprietary Software License
+
+Copyright (c) 2026 Voltro UG. All rights reserved.
+
+This software and all associated source code, documentation, and other
+materials (the "Software") are the proprietary property of Voltro UG
+("Voltro"). This is NOT open-source software.
+
+Your access to and use of the Software is governed exclusively by the Voltro
+Terms of Service at:
+
+    https://voltro.cloud/legal/terms
+
+By downloading, installing, or using the Software you agree to those Terms.
+Subject to and conditioned on your continued compliance with them, Voltro
+grants you a limited, non-exclusive, non-transferable, non-sublicensable,
+revocable license to use the Software. All rights not expressly granted in the
+Terms are reserved by Voltro. If you do not agree to the Terms, you have no
+license and may not use the Software.
+
+The Terms of Service — including the scope of permitted use, plan
+entitlements, fees, and pricing — may change from time to time. The version in
+force is the one published at the URL above. Commercial terms and pricing are
+NOT part of this notice and are not fixed by, or granted in perpetuity by, the
+version of the Software in which this file appears.
+
+Permitted use — your own software. Voltro is a development framework. You may
+use the Software to build, run, and commercially distribute your own
+applications and services, and to charge your own customers for them, without
+owing Voltro any share of that revenue or any further permission beyond the
+Terms. Applications you build with the Software are yours.
+
+Prohibited use — reselling Voltro. You may NOT redistribute, resell,
+sublicense, publish, or otherwise provide the Software itself — in whole or in
+part, in source or compiled form — to third parties as a library, framework,
+SDK, template, starter, or development tool for them to build upon, whether
+standalone or repackaged. Shipping the Software as a non-separable, bundled
+dependency inside an application you deliver (for example, compiled into your
+deployed app) is permitted; extracting or re-exposing it as a reusable
+component for others is not.
+
+Except as expressly permitted above or by the Terms, you may not copy, modify,
+merge, publish, sublicense, sell, distribute, or create derivative works of the
+Software, in whole or in part.
+
+Third-party open-source components distributed alongside the Software are the
+property of their respective owners and are licensed under their own terms; see
+THIRD-PARTY-NOTICES.md where provided. Nothing in this notice limits your
+rights, or extends Voltro's, in those components.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL
+VOLTRO BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM,
+OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR ITS USE.
+
+For licensing inquiries, contact Voltro UG.

package/README.md

@@ -0,0 +1,26 @@
+<div align="center">
+
+# @voltro/datetime
+
+**The framework's opinion on time: UTC instants in storage, rendering in the viewer's timezone, and zone-aware arithmetic/formatting on the TC39 Temporal standard (via polyfill). Ships the request-scoped timezone-context seam plus pure, browser-safe date helpers.**
+
+[📖 Documentation](https://docs.voltro.dev/docs/intro/getting-started) · [voltro.dev](https://voltro.dev) · [Voltro Cloud](https://voltro.cloud)
+
+</div>
+
+---
+
+```sh
+npm install @voltro/datetime
+```
+
+> ### [→ Read the documentation for @voltro/datetime](https://docs.voltro.dev/docs/intro/getting-started)
+
+Installation, guides, the full API reference, and examples all live in the
+**[Voltro documentation](https://docs.voltro.dev/docs/intro/getting-started)** — the single source of truth. This README is
+deliberately short so there is nothing here to drift out of date.
+
+## License
+
+Proprietary. © 2026 Voltro UG. Your use is governed by the
+[Terms of Service](https://voltro.cloud/legal/terms). See the bundled `LICENSE`.

package/SECURITY.md

@@ -0,0 +1,56 @@
+# Security Policy
+
+We take the security of Voltro and the applications built on it seriously. This
+document explains how to report a vulnerability and what to expect in return.
+
+## Reporting a vulnerability
+
+**Please do not open public issues or discuss suspected vulnerabilities in
+public channels.** Report them privately by email:
+
+**security contact: [support@voltro.dev](mailto:support@voltro.dev)**
+(subject line: `SECURITY`).
+
+Include, where you can:
+
+- the affected package(s) and version(s) (e.g. `@voltro/runtime@x.y.z`);
+- a description of the issue and its impact;
+- a minimal reproduction or proof of concept;
+- any suggested remediation.
+
+If you'd like to encrypt your report, ask in a first plain email and we'll
+arrange a key.
+
+## What to expect
+
+- **Acknowledgement** of your report within **3 business days**.
+- An initial assessment (severity, affected surface) and a remediation plan as
+  soon as we've reproduced the issue.
+- **Coordinated disclosure:** we'll agree a disclosure timeline with you and
+  credit you in the release notes if you wish. Please give us reasonable time to
+  ship a fix before any public disclosure.
+
+We do not currently run a paid bug-bounty program, but we genuinely appreciate
+responsible disclosure and will credit reporters.
+
+## Software Bill of Materials (SBOM)
+
+A CycloneDX SBOM of the third-party runtime dependency graph is generated for the
+published packages (`pnpm gen:sbom` → `sbom.cdx.json`). If your procurement or
+security team needs it, request it at
+[support@voltro.dev](mailto:support@voltro.dev).
+
+## Supported versions
+
+Voltro is pre-1.0 and ships in lockstep: **only the latest published minor of
+each `@voltro/*` package receives security fixes.** Please upgrade to the latest
+release before reporting, and pin exact versions in production.
+
+## Scope
+
+In scope: the published `@voltro/*` packages and the framework's own code.
+
+Out of scope: vulnerabilities in third-party dependencies that are already
+tracked upstream (we monitor these via a production-dependency audit gate in
+CI), and issues that require a non-default, explicitly-unsafe configuration. If
+you're unsure, report it anyway — we'd rather hear about it.

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,59 @@
+# Third-Party Notices — @voltro/datetime
+
+This package depends on the open-source software listed below. Each is the
+property of its respective copyright holders and is used under the terms of
+its license. This file is provided for attribution; it grants no rights in
+@voltro/datetime itself, which is proprietary (see LICENSE).
+
+Generated from the resolved runtime dependency closure (2 packages).
+
+---
+
+## temporal-polyfill@0.3.2
+
+License: MIT
+
+```
+MIT License
+
+Copyright (c) 2024 Adam Shaw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## temporal-spec@0.3.1
+
+License: ISC
+
+```
+Copyright 2017, 2018, 2019, 2020 ECMA International
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+```
+

package/dist/context.d.ts

@@ -0,0 +1,45 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Layer } from 'effect';
+
+/**
+ * The effective timezone in the current context, or `UTC` when none was
+ * provided. Never fails — an absent context is the documented UTC default,
+ * so call sites don't have to handle a missing-service error.
+ */
+export declare const currentTimezone: Effect.Effect<string>;
+
+/**
+ * A layer that RESOLVES the timezone from the request signals (user
+ * profile → tenant → browser → UTC) and provides it. This is what the
+ * runtime wires per request.
+ */
+export declare const resolvedTimezoneLayer: (args: ResolveTimezoneArgs) => Layer.Layer<TimezoneContext>;
+
+declare interface ResolveTimezoneArgs {
+    /** The viewing user's stored profile timezone, if any. */
+    readonly userTimeZone?: string | null;
+    /** The tenant / org default timezone, if any. */
+    readonly tenantTimeZone?: string | null;
+    /** The browser-reported timezone (from the client), if any. */
+    readonly browserTimeZone?: string | null;
+}
+
+/** The carried value: the effective IANA timezone for the current request. */
+export declare interface Timezone {
+    readonly timeZone: string;
+}
+
+/** Context tag holding the request's resolved timezone. */
+export declare class TimezoneContext extends TimezoneContext_base {
+}
+
+declare const TimezoneContext_base: Context.TagClass<TimezoneContext, "@voltro/datetime/TimezoneContext", Timezone>;
+
+/** A layer providing a fixed timezone. */
+export declare const TimezoneContextLive: (timeZone: string) => Layer.Layer<TimezoneContext>;
+
+/** Run `effect` with an explicit timezone in context. */
+export declare const withTimezone: (timeZone: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, TimezoneContext>>;
+
+export { }

package/dist/context.js

@@ -0,0 +1,9 @@
+import { n as e } from "./resolveTimezone-B67Y7K6d.js";
+import { Context as t, Effect as n, Layer as r, Option as i } from "effect";
+//#region src/context.ts
+var a = class extends t.Tag("@voltro/datetime/TimezoneContext")() {}, o = n.map(n.serviceOption(a), (e) => i.match(e, {
+	onNone: () => "UTC",
+	onSome: (e) => e.timeZone
+})), s = (e) => (t) => n.provideService(t, a, { timeZone: e }), c = (e) => r.succeed(a, { timeZone: e }), l = (t) => r.succeed(a, { timeZone: e(t) });
+//#endregion
+export { a as TimezoneContext, c as TimezoneContextLive, o as currentTimezone, l as resolvedTimezoneLayer, s as withTimezone };

package/dist/index.d.ts

@@ -0,0 +1,138 @@
+import { Temporal } from 'temporal-polyfill';
+
+/** DST-aware: same wall-clock time, `n` calendar days later in `timeZone`. */
+export declare const addDays: (value: InstantInput, n: number, timeZone: string) => Temporal.Instant;
+
+/** DST-UNAWARE: exactly `n × 3600` seconds later. No zone — an instant offset. */
+export declare const addHours: (value: InstantInput, n: number) => Temporal.Instant;
+
+/** DST-aware: same wall-clock time, `n` calendar months later in `timeZone`
+ *  (clamps to the last day of a shorter month per Temporal's default). */
+export declare const addMonths: (value: InstantInput, n: number, timeZone: string) => Temporal.Instant;
+
+/** Throw unless `timeZone` is a valid IANA name. Storage rule: validate on
+ *  input, never store an unverified zone string. */
+export declare const assertTimeZone: (timeZone: string) => string;
+
+/** The last-resort fallback. UTC is always valid and never surprising. */
+export declare const DEFAULT_TIME_ZONE = "UTC";
+
+/** Last instant (23:59:59.999999999) of the local day in `timeZone`. */
+export declare const endOfDay: (value: InstantInput, timeZone: string) => Temporal.Instant;
+
+/** Date only, in `timeZone`. Default `dateStyle: 'medium'`. */
+export declare const formatDate: (value: InstantInput, timeZone: string, options?: FormatOptions) => string;
+
+/** Date + time, in `timeZone`. Default `dateStyle`/`timeStyle: 'medium'`. */
+export declare const formatDateTime: (value: InstantInput, timeZone: string, options?: FormatOptions) => string;
+
+/** Options common to the absolute formatters: an explicit `locale` plus any
+ *  `Intl.DateTimeFormatOptions` override (a `timeZone` in here wins over the
+ *  positional `timeZone` argument). */
+export declare type FormatOptions = {
+    readonly locale?: string;
+} & Intl.DateTimeFormatOptions;
+
+/**
+ * "3 hours ago", "in 2 days". Picks the largest unit that fits the signed
+ * distance between `value` and `now` (default: the current instant). This
+ * is zone-independent: it measures elapsed real time, not wall-clock days.
+ */
+export declare const formatRelativeTime: (value: InstantInput, options?: RelativeTimeOptions) => string;
+
+/** Time only, in `timeZone`. Default `timeStyle: 'medium'`. */
+export declare const formatTime: (value: InstantInput, timeZone: string, options?: FormatOptions) => string;
+
+/** Bridge a JS `Date` (DB read) to a `Temporal.Instant`. */
+export declare const fromDate: (date: Date) => Temporal.Instant;
+
+/** Parse an ISO-8601 instant (offset / `Z` required). Alias: `parseISO`. */
+export declare const instant: (iso: string) => Temporal.Instant;
+
+/** Anything that unambiguously denotes a UTC instant: a Temporal.Instant,
+ *  a JS `Date` (what the DB layer produces), or an ISO-8601 string with an
+ *  explicit offset / `Z`. */
+export declare type InstantInput = Temporal.Instant | Date | string;
+
+/** Is `a` strictly after `b`? Zone-independent (compares absolute instants). */
+export declare const isAfter: (a: InstantInput, b: InstantInput) => boolean;
+
+/** Is `a` strictly before `b`? Zone-independent (compares absolute instants). */
+export declare const isBefore: (a: InstantInput, b: InstantInput) => boolean;
+
+/** Do `a` and `b` fall on the same calendar day in `timeZone`? */
+export declare const isSameDay: (a: InstantInput, b: InstantInput, timeZone: string) => boolean;
+
+/** Is `timeZone` a valid IANA name this runtime knows? Uses `Intl`, which
+ *  is the authority both Temporal and formatting defer to. */
+export declare const isValidTimeZone: (timeZone: string) => boolean;
+
+/** The current UTC instant. */
+export declare const now: () => Temporal.Instant;
+
+/** Parse a `YYYY-MM-DD` calendar date. */
+export declare const parseDate: (iso: string) => Temporal.PlainDate;
+
+/** Parse an ISO-8601 instant. Same as `instant`, named for parse sites. */
+export declare const parseISO: (iso: string) => Temporal.Instant;
+
+/** A calendar date with no time and no zone (birthdays, holidays, due dates). */
+export declare const plainDate: (year: number, month: number, day: number) => Temporal.PlainDate;
+
+/** Options for `formatRelativeTime`. */
+export declare interface RelativeTimeOptions {
+    readonly locale?: string;
+    /** The instant to measure against. Defaults to "now". */
+    readonly now?: InstantInput;
+    readonly numeric?: Intl.RelativeTimeFormatNumeric;
+    readonly style?: Intl.RelativeTimeFormatStyle;
+}
+
+/**
+ * Resolve the effective IANA timezone for a request, in priority order.
+ * Returns a validated IANA name, never an unchecked string; falls back to
+ * `UTC` when no signal yields a known zone.
+ */
+export declare const resolveTimezone: (args: ResolveTimezoneArgs) => string;
+
+export declare interface ResolveTimezoneArgs {
+    /** The viewing user's stored profile timezone, if any. */
+    readonly userTimeZone?: string | null;
+    /** The tenant / org default timezone, if any. */
+    readonly tenantTimeZone?: string | null;
+    /** The browser-reported timezone (from the client), if any. */
+    readonly browserTimeZone?: string | null;
+}
+
+/** First instant of the local day containing `value` in `timeZone`. */
+export declare const startOfDay: (value: InstantInput, timeZone: string) => Temporal.Instant;
+
+/** First instant of the local month containing `value` in `timeZone`. */
+export declare const startOfMonth: (value: InstantInput, timeZone: string) => Temporal.Instant;
+
+export { Temporal }
+
+/** Bridge a `Temporal.Instant` back to a JS `Date` for storage / interop. */
+export declare const toDate: (instant: Temporal.Instant) => Date;
+
+/** Today's calendar date in `timeZone` (no clock, no zone on the result). */
+export declare const today: (timeZone: string) => Temporal.PlainDate;
+
+/**
+ * Coerce a permissive instant input to a `Temporal.Instant`. This is the
+ * single funnel every helper runs its input through, so callers can pass
+ * the `Date` a query returned without a manual conversion.
+ *
+ * A string MUST carry an explicit offset or `Z` — a naive `2026-01-01T12:00`
+ * has no instant and throws, by design (the whole point is no silent
+ * zone-guessing).
+ */
+export declare const toInstant: (value: InstantInput) => Temporal.Instant;
+
+/** Project a UTC instant into a wall-clock `ZonedDateTime` in `timeZone`. */
+export declare const toTimezone: (value: InstantInput, timeZone: string) => Temporal.ZonedDateTime;
+
+/** The canonical wire / storage form: ISO-8601 in UTC (`…Z`). */
+export declare const toUTCString: (value: InstantInput) => string;
+
+export { }

package/dist/index.js

@@ -0,0 +1,37 @@
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./resolveTimezone-B67Y7K6d.js";
+//#region src/helpers.ts
+var l = () => r.Now.instant(), u = (e) => r.Now.plainDateISO(e), d = (e) => r.Instant.from(e), f = (e) => r.Instant.from(e), p = (e, t, n) => r.PlainDate.from({
+	year: e,
+	month: t,
+	day: n
+}), m = (e) => r.PlainDate.from(e), h = (e, t) => s(e).toZonedDateTimeISO(t), g = (e, t, n) => s(e).toZonedDateTimeISO(n).add({ days: t }).toInstant(), _ = (e, t, n) => s(e).toZonedDateTimeISO(n).add({ months: t }).toInstant(), v = (e, t) => s(e).add({ hours: t }), y = (e, t) => s(e).toZonedDateTimeISO(t).startOfDay().toInstant(), b = (e, t) => s(e).toZonedDateTimeISO(t).add({ days: 1 }).startOfDay().subtract({ nanoseconds: 1 }).toInstant(), x = (e, t) => s(e).toZonedDateTimeISO(t).with({ day: 1 }).startOfDay().toInstant(), S = (e, t, n) => s(e).toZonedDateTimeISO(n).toPlainDate().equals(s(t).toZonedDateTimeISO(n).toPlainDate()), C = (e, t) => r.Instant.compare(s(e), s(t)) > 0, w = (e, t) => r.Instant.compare(s(e), s(t)) < 0, T = (e, t, n, r) => {
+	let { locale: i, ...o } = r ?? {};
+	return new Intl.DateTimeFormat(i, {
+		timeZone: t,
+		...n,
+		...o
+	}).format(a(s(e)));
+}, E = (e, t, n) => T(e, t, { dateStyle: "medium" }, n), D = (e, t, n) => T(e, t, { timeStyle: "medium" }, n), O = (e, t, n) => T(e, t, {
+	dateStyle: "medium",
+	timeStyle: "medium"
+}, n), k = [
+	["year", 3600 * 24 * 365],
+	["month", 3600 * 24 * 30],
+	["week", 3600 * 24 * 7],
+	["day", 3600 * 24],
+	["hour", 3600],
+	["minute", 60],
+	["second", 1]
+], A = (e, t) => {
+	let { locale: n, now: r, numeric: i = "auto", style: a } = t ?? {}, o = s(e), c = r === void 0 ? Date.now() : s(r).epochMilliseconds, l = (o.epochMilliseconds - c) / 1e3, u = new Intl.RelativeTimeFormat(n, {
+		numeric: i,
+		...a ? { style: a } : {}
+	}), d = Math.abs(l);
+	for (let [e, t] of k) if (d >= t || e === "second") {
+		let n = Math.round(l / t);
+		return u.format(n, e);
+	}
+	return u.format(Math.round(l), "second");
+};
+//#endregion
+export { c as DEFAULT_TIME_ZONE, r as Temporal, g as addDays, v as addHours, _ as addMonths, o as assertTimeZone, b as endOfDay, E as formatDate, O as formatDateTime, A as formatRelativeTime, D as formatTime, n as fromDate, d as instant, C as isAfter, w as isBefore, S as isSameDay, e as isValidTimeZone, l as now, m as parseDate, f as parseISO, p as plainDate, i as resolveTimezone, y as startOfDay, x as startOfMonth, a as toDate, s as toInstant, h as toTimezone, t as toUTCString, u as today };

package/dist/resolveTimezone-B67Y7K6d.js

@@ -0,0 +1,22 @@
+import { Temporal as e } from "temporal-polyfill";
+//#region src/storage.ts
+var t = (t) => t instanceof e.Instant ? t : t instanceof Date ? e.Instant.fromEpochMilliseconds(t.getTime()) : e.Instant.from(t), n = (t) => e.Instant.fromEpochMilliseconds(t.getTime()), r = (e) => new Date(e.epochMilliseconds), i = (e) => t(e).toString(), a = (e) => {
+	if (!e) return !1;
+	try {
+		return new Intl.DateTimeFormat("en-US", { timeZone: e }), !0;
+	} catch {
+		return !1;
+	}
+}, o = (e) => {
+	if (!a(e)) throw RangeError(`Invalid IANA time zone: ${JSON.stringify(e)}`);
+	return e;
+}, s = "UTC", c = (e) => {
+	for (let t of [
+		e.userTimeZone,
+		e.tenantTimeZone,
+		e.browserTimeZone
+	]) if (t && a(t)) return t;
+	return "UTC";
+};
+//#endregion
+export { a, i as c, n as i, e as l, c as n, r as o, o as r, t as s, s as t };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@voltro/datetime",
+  "version": "0.29.0",
+  "description": "The framework's opinion on time: UTC instants in storage, rendering in the viewer's timezone, and zone-aware arithmetic/formatting on the TC39 Temporal standard (via polyfill). Ships the request-scoped timezone-context seam plus pure, browser-safe date helpers.",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./context": {
+      "types": "./dist/context.d.ts",
+      "import": "./dist/context.js",
+      "default": "./dist/context.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "temporal-polyfill": "^0.3.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.22.0"
+  },
+  "peerDependenciesMeta": {
+    "effect": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}