@homeflare/alchemy 0.38.0 → 0.40.0

package/dist/unifi/index.js

@@ -9,6 +9,73 @@ class UnifiWriteRefused extends Data.TaggedError("UnifiWriteRefused") {
   }
 }
 var refuseWrite = (type, identity, action) => Effect.fail(new UnifiWriteRefused({ type, identity, action }));
+// src/unifi/resource.ts
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import { CredentialsFromEnv } from "@distilled.cloud/unifi-network/Credentials";
+import * as Effect2 from "effect/Effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+var unifiOperations = (spec) => {
+  const read = (props) => spec.fetchLive(props).pipe(Effect2.map((live) => live === undefined ? undefined : spec.attributes(live, props)));
+  return {
+    read,
+    readHandler: ({ olds, output }) => Effect2.gen(function* () {
+      const attrs = yield* read(olds);
+      if (attrs === undefined)
+        return;
+      return output !== undefined ? attrs : Unowned(attrs);
+    }),
+    diff: (news, output) => Effect2.gen(function* () {
+      if (output === undefined || !isResolved(news))
+        return;
+      const live = yield* read(news);
+      if (live === undefined)
+        return { action: "update" };
+      return spec.matches(live, news) ? { action: "noop" } : { action: "update" };
+    }),
+    reconcile: (news) => Effect2.gen(function* () {
+      const live = yield* read(news);
+      if (live === undefined)
+        return yield* refuseWrite(spec.type, spec.describe(news), "create");
+      if (!spec.matches(live, news)) {
+        return yield* refuseWrite(spec.type, spec.describe(news), "update");
+      }
+      return live;
+    }),
+    destroy: (olds) => refuseWrite(spec.type, spec.describe(olds), "delete")
+  };
+};
+
+class UnifiNonGetRequest extends Error {
+  method;
+  path;
+  constructor(method, path) {
+    super(`UniFi HttpClient guard: refused ${method} ${path} -- ${UNIFI_READ_ONLY_POLICY}. This is a ` + "defect, not a recoverable condition: something under src/unifi tried to send a non-GET " + "request, which policy.ts's per-operation refusal should already have made impossible. " + "Fix the kit code that produced this request.");
+    this.method = method;
+    this.path = path;
+    this.name = "UnifiNonGetRequest";
+  }
+}
+var requestPath = (url) => {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return "<unparseable request url>";
+  }
+};
+var guardGetOnly = (client) => client.pipe(HttpClient.mapRequestEffect((request) => request.method === "GET" ? Effect2.succeed(request) : Effect2.die(new UnifiNonGetRequest(request.method, requestPath(request.url)))));
+var GetOnlyHttpClient = HttpClient.layerMergedContext(Effect2.map(HttpClient.HttpClient, guardGetOnly));
+var unifiHandlers = (spec) => {
+  const ops = unifiOperations(spec);
+  const withCredentials = (effect) => effect.pipe(Effect2.provide(GetOnlyHttpClient), Effect2.provide(CredentialsFromEnv));
+  return {
+    list: () => Effect2.succeed([]),
+    read: (args) => withCredentials(ops.readHandler(args)),
+    diff: (args) => withCredentials(ops.diff(args.news, args.output)),
+    reconcile: (args) => withCredentials(ops.reconcile(args.news)),
+    delete: (args) => withCredentials(ops.destroy(args.olds))
+  };
+};
 // src/unifi/network.ts
 import { Resource } from "alchemy";
 import { adopt } from "alchemy/AdoptPolicy";
@@ -17,7 +84,6 @@ import * as networks from "@distilled.cloud/unifi-network/networks";
 import * as Effect3 from "effect/Effect";
 
 // src/unifi/network-form.ts
-import { deepEqual } from "alchemy/Diff";
 var sortedSet = (values) => [...new Set(values)].sort();
 var normalizeDhcpGuarding = (value) => value == null ? value : { ...value, trustedDhcpServerIpAddresses: sortedSet(value.trustedDhcpServerIpAddresses) };
 var normalizeIpv6Configuration = (value) => value == null ? value : {
@@ -43,15 +109,6 @@ var attributesOf = (live, props) => ({
   zoneId: live.zoneId,
   deviceId: live.deviceId
 });
-var matches = (attributes, props) => attributes.name === props.name && attributes.enabled === props.enabled && attributes.management === props.management && attributes.vlanId === props.vlanId && deepEqual(normalizeDhcpGuarding(attributes.dhcpGuarding), normalizeDhcpGuarding(props.dhcpGuarding), {
-  stripNullish: true
-}) && deepEqual(attributes.cellularBackupEnabled, props.cellularBackupEnabled, {
-  stripNullish: true
-}) && deepEqual(attributes.internetAccessEnabled, props.internetAccessEnabled, {
-  stripNullish: true
-}) && deepEqual(attributes.ipv4Configuration, props.ipv4Configuration, { stripNullish: true }) && deepEqual(normalizeIpv6Configuration(attributes.ipv6Configuration), normalizeIpv6Configuration(props.ipv6Configuration), { stripNullish: true }) && deepEqual(attributes.isolationEnabled, props.isolationEnabled, { stripNullish: true }) && deepEqual(attributes.mdnsForwardingEnabled, props.mdnsForwardingEnabled, {
-  stripNullish: true
-}) && deepEqual(attributes.zoneId, props.zoneId, { stripNullish: true }) && deepEqual(attributes.deviceId, props.deviceId, { stripNullish: true });
 var declareNetwork = (live, siteId) => ({
   siteId,
   networkId: live.id,
@@ -70,52 +127,61 @@ var declareNetwork = (live, siteId) => ({
   deviceId: live.deviceId
 });
 
-// src/unifi/resource.ts
-import { Unowned } from "alchemy/AdoptPolicy";
-import { isResolved } from "alchemy/Diff";
-import { CredentialsFromEnv } from "@distilled.cloud/unifi-network/Credentials";
-import * as Effect2 from "effect/Effect";
-var unifiOperations = (spec) => {
-  const read = (props) => spec.fetchLive(props).pipe(Effect2.map((live) => live === undefined ? undefined : spec.attributes(live, props)));
-  return {
-    read,
-    readHandler: ({ olds, output }) => Effect2.gen(function* () {
-      const attrs = yield* read(olds);
-      if (attrs === undefined)
-        return;
-      return output !== undefined ? attrs : Unowned(attrs);
-    }),
-    diff: (news, output) => Effect2.gen(function* () {
-      if (output === undefined || !isResolved(news))
-        return;
-      const live = yield* read(news);
-      if (live === undefined)
-        return { action: "update" };
-      return spec.matches(live, news) ? { action: "noop" } : { action: "update" };
-    }),
-    reconcile: (news) => Effect2.gen(function* () {
-      const live = yield* read(news);
-      if (live === undefined)
-        return yield* refuseWrite(spec.type, spec.describe(news), "create");
-      if (!spec.matches(live, news)) {
-        return yield* refuseWrite(spec.type, spec.describe(news), "update");
-      }
-      return live;
-    }),
-    destroy: (olds) => refuseWrite(spec.type, spec.describe(olds), "delete")
-  };
-};
-var unifiHandlers = (spec) => {
-  const ops = unifiOperations(spec);
-  const withCredentials = (effect) => Effect2.provide(effect, CredentialsFromEnv);
-  return {
-    list: () => Effect2.succeed([]),
-    read: (args) => withCredentials(ops.readHandler(args)),
-    diff: (args) => withCredentials(ops.diff(args.news, args.output)),
-    reconcile: (args) => withCredentials(ops.reconcile(args.news)),
-    delete: (args) => withCredentials(ops.destroy(args.olds))
-  };
-};
+// src/unifi/drift.ts
+import { deepEqual } from "alchemy/Diff";
+var defaultEqual = (live, declared) => deepEqual(live, declared, { stripNullish: true });
+var makeDriftOf = (fields) => (attributes, props) => fields.flatMap(({ field, live, declared, equal = defaultEqual }) => {
+  const liveValue = live(attributes);
+  const declaredValue = declared(props);
+  return equal(liveValue, declaredValue) ? [] : [{ field, live: liveValue, declared: declaredValue }];
+});
+
+// src/unifi/network-drift.ts
+var fieldDrift = makeDriftOf([
+  { field: "name", live: (a) => a.name, declared: (p) => p.name },
+  { field: "enabled", live: (a) => a.enabled, declared: (p) => p.enabled },
+  { field: "management", live: (a) => a.management, declared: (p) => p.management },
+  { field: "vlanId", live: (a) => a.vlanId, declared: (p) => p.vlanId },
+  {
+    field: "dhcpGuarding",
+    live: (a) => normalizeDhcpGuarding(a.dhcpGuarding),
+    declared: (p) => normalizeDhcpGuarding(p.dhcpGuarding)
+  },
+  {
+    field: "cellularBackupEnabled",
+    live: (a) => a.cellularBackupEnabled,
+    declared: (p) => p.cellularBackupEnabled
+  },
+  {
+    field: "internetAccessEnabled",
+    live: (a) => a.internetAccessEnabled,
+    declared: (p) => p.internetAccessEnabled
+  },
+  {
+    field: "ipv4Configuration",
+    live: (a) => a.ipv4Configuration,
+    declared: (p) => p.ipv4Configuration
+  },
+  {
+    field: "ipv6Configuration",
+    live: (a) => normalizeIpv6Configuration(a.ipv6Configuration),
+    declared: (p) => normalizeIpv6Configuration(p.ipv6Configuration)
+  },
+  {
+    field: "isolationEnabled",
+    live: (a) => a.isolationEnabled,
+    declared: (p) => p.isolationEnabled
+  },
+  {
+    field: "mdnsForwardingEnabled",
+    live: (a) => a.mdnsForwardingEnabled,
+    declared: (p) => p.mdnsForwardingEnabled
+  },
+  { field: "zoneId", live: (a) => a.zoneId, declared: (p) => p.zoneId },
+  { field: "deviceId", live: (a) => a.deviceId, declared: (p) => p.deviceId }
+]);
+var matches = (attributes, props) => fieldDrift(attributes, props).length === 0;
+var driftOf = (live, props) => fieldDrift(attributesOf(live, props), props);
 
 // src/unifi/network.ts
 var UnifiNetwork = Resource("Unifi.Network", {
@@ -147,7 +213,17 @@ var attributesOf2 = (live, props) => ({
   networkIds: sortedSet2(live.networkIds),
   metadataOrigin: live.metadata.origin
 });
-var matches2 = (attributes, props) => attributes.name === props.name && attributes.networkIds.join(",") === sortedSet2(props.networkIds).join(",");
+var fieldDrift2 = makeDriftOf([
+  { field: "name", live: (a) => a.name, declared: (p) => p.name },
+  {
+    field: "networkIds",
+    live: (a) => a.networkIds,
+    declared: (p) => sortedSet2(p.networkIds),
+    equal: (live, declared) => live.join(",") === declared.join(",")
+  }
+]);
+var matches2 = (attributes, props) => fieldDrift2(attributes, props).length === 0;
+var driftOf2 = (live, props) => fieldDrift2(attributesOf2(live, props), props);
 var declareFirewallZone = (live, siteId) => ({
   siteId,
   firewallZoneId: live.id,
@@ -169,22 +245,611 @@ var spec2 = {
 };
 var handlers2 = unifiHandlers(spec2);
 var UnifiFirewallZoneProvider = () => Provider2.effect(UnifiFirewallZone, Effect4.succeed(UnifiFirewallZone.Provider.of(handlers2)));
+// src/unifi/dns-policy.ts
+import { Resource as Resource3 } from "alchemy";
+import { adopt as adopt3 } from "alchemy/AdoptPolicy";
+import * as Provider3 from "alchemy/Provider";
+import * as dnsPolicies from "@distilled.cloud/unifi-network/dns_policies";
+import * as Effect5 from "effect/Effect";
+
+// src/unifi/dns-policy-form.ts
+var attributesOf3 = (live, props) => ({
+  siteId: props.siteId,
+  dnsPolicyId: live.id,
+  enabled: live.enabled,
+  type: live.type,
+  domain: live.domain,
+  ipv6Address: live.ipv6Address,
+  ttlSeconds: live.ttlSeconds,
+  ipv4Address: live.ipv4Address,
+  targetDomain: live.targetDomain,
+  ipAddress: live.ipAddress,
+  mailServerDomain: live.mailServerDomain,
+  priority: live.priority,
+  port: live.port,
+  protocol: live.protocol,
+  serverDomain: live.serverDomain,
+  service: live.service,
+  weight: live.weight,
+  text: live.text,
+  metadataOrigin: live.metadata.origin
+});
+var declareDnsPolicy = (live, siteId) => ({
+  siteId,
+  dnsPolicyId: live.id,
+  enabled: live.enabled,
+  type: live.type,
+  domain: live.domain,
+  ipv6Address: live.ipv6Address,
+  ttlSeconds: live.ttlSeconds,
+  ipv4Address: live.ipv4Address,
+  targetDomain: live.targetDomain,
+  ipAddress: live.ipAddress,
+  mailServerDomain: live.mailServerDomain,
+  priority: live.priority,
+  port: live.port,
+  protocol: live.protocol,
+  serverDomain: live.serverDomain,
+  service: live.service,
+  weight: live.weight,
+  text: live.text
+});
+
+// src/unifi/dns-policy-drift.ts
+var fieldDrift3 = makeDriftOf([
+  { field: "enabled", live: (a) => a.enabled, declared: (p) => p.enabled },
+  { field: "type", live: (a) => a.type, declared: (p) => p.type },
+  { field: "domain", live: (a) => a.domain, declared: (p) => p.domain },
+  { field: "ipv6Address", live: (a) => a.ipv6Address, declared: (p) => p.ipv6Address },
+  { field: "ttlSeconds", live: (a) => a.ttlSeconds, declared: (p) => p.ttlSeconds },
+  { field: "ipv4Address", live: (a) => a.ipv4Address, declared: (p) => p.ipv4Address },
+  { field: "targetDomain", live: (a) => a.targetDomain, declared: (p) => p.targetDomain },
+  { field: "ipAddress", live: (a) => a.ipAddress, declared: (p) => p.ipAddress },
+  {
+    field: "mailServerDomain",
+    live: (a) => a.mailServerDomain,
+    declared: (p) => p.mailServerDomain
+  },
+  { field: "priority", live: (a) => a.priority, declared: (p) => p.priority },
+  { field: "port", live: (a) => a.port, declared: (p) => p.port },
+  { field: "protocol", live: (a) => a.protocol, declared: (p) => p.protocol },
+  { field: "serverDomain", live: (a) => a.serverDomain, declared: (p) => p.serverDomain },
+  { field: "service", live: (a) => a.service, declared: (p) => p.service },
+  { field: "weight", live: (a) => a.weight, declared: (p) => p.weight },
+  { field: "text", live: (a) => a.text, declared: (p) => p.text }
+]);
+var matches3 = (attributes, props) => fieldDrift3(attributes, props).length === 0;
+var driftOf3 = (live, props) => fieldDrift3(attributesOf3(live, props), props);
+
+// src/unifi/dns-policy.ts
+var UnifiDnsPolicy = Resource3("Unifi.DnsPolicy", {
+  defaultRemovalPolicy: "retain"
+});
+var dnsPolicy = (id, props) => UnifiDnsPolicy(id, props).pipe(adopt3(true));
+var spec3 = {
+  type: "Unifi.DnsPolicy",
+  describe: (props) => `sites/${props.siteId}/dns/policies/${props.dnsPolicyId}`,
+  fetchLive: (props) => dnsPolicies.getDnsPolicy({ siteId: props.siteId, dnsPolicyId: props.dnsPolicyId }).pipe(Effect5.catchTag("NotFound", () => Effect5.succeed(undefined))),
+  attributes: attributesOf3,
+  matches: matches3
+};
+var handlers3 = unifiHandlers(spec3);
+var UnifiDnsPolicyProvider = () => Provider3.effect(UnifiDnsPolicy, Effect5.succeed(UnifiDnsPolicy.Provider.of(handlers3)));
+// src/unifi/acl-rule.ts
+import { Resource as Resource4 } from "alchemy";
+import { adopt as adopt4 } from "alchemy/AdoptPolicy";
+import * as Provider4 from "alchemy/Provider";
+import * as aclRules from "@distilled.cloud/unifi-network/access_control_acl_rules";
+import * as Effect6 from "effect/Effect";
+
+// src/unifi/acl-rule-form.ts
+var sortedSet3 = (values) => [...new Set(values)].sort();
+var normalizeDeviceFilter = (value) => value == null ? value : {
+  ...value,
+  ...value.deviceIds !== undefined ? { deviceIds: sortedSet3(value.deviceIds) } : {}
+};
+var normalizeProtocolFilter = (value) => value == null ? undefined : sortedSet3(value);
+var attributesOf4 = (live, props) => ({
+  siteId: props.siteId,
+  aclRuleId: live.id,
+  action: live.action,
+  description: live.description,
+  destinationFilter: live.destinationFilter,
+  enabled: live.enabled,
+  enforcingDeviceFilter: normalizeDeviceFilter(live.enforcingDeviceFilter),
+  index: live.index,
+  name: live.name,
+  sourceFilter: live.sourceFilter,
+  type: live.type,
+  protocolFilter: normalizeProtocolFilter(live.protocolFilter),
+  networkIdFilter: live.networkIdFilter,
+  metadataOrigin: live.metadata.origin
+});
+var declareAclRule = (live, siteId) => ({
+  siteId,
+  aclRuleId: live.id,
+  action: live.action,
+  description: live.description,
+  destinationFilter: live.destinationFilter,
+  enabled: live.enabled,
+  enforcingDeviceFilter: normalizeDeviceFilter(live.enforcingDeviceFilter),
+  name: live.name,
+  sourceFilter: live.sourceFilter,
+  type: live.type,
+  protocolFilter: normalizeProtocolFilter(live.protocolFilter),
+  networkIdFilter: live.networkIdFilter
+});
+
+// src/unifi/acl-rule-drift.ts
+var fieldDrift4 = makeDriftOf([
+  { field: "action", live: (a) => a.action, declared: (p) => p.action },
+  { field: "description", live: (a) => a.description, declared: (p) => p.description },
+  {
+    field: "destinationFilter",
+    live: (a) => a.destinationFilter,
+    declared: (p) => p.destinationFilter
+  },
+  { field: "enabled", live: (a) => a.enabled, declared: (p) => p.enabled },
+  {
+    field: "enforcingDeviceFilter",
+    live: (a) => normalizeDeviceFilter(a.enforcingDeviceFilter),
+    declared: (p) => normalizeDeviceFilter(p.enforcingDeviceFilter)
+  },
+  { field: "name", live: (a) => a.name, declared: (p) => p.name },
+  { field: "sourceFilter", live: (a) => a.sourceFilter, declared: (p) => p.sourceFilter },
+  { field: "type", live: (a) => a.type, declared: (p) => p.type },
+  {
+    field: "protocolFilter",
+    live: (a) => normalizeProtocolFilter(a.protocolFilter),
+    declared: (p) => normalizeProtocolFilter(p.protocolFilter)
+  },
+  { field: "networkIdFilter", live: (a) => a.networkIdFilter, declared: (p) => p.networkIdFilter }
+]);
+var matches4 = (attributes, props) => fieldDrift4(attributes, props).length === 0;
+var driftOf4 = (live, props) => fieldDrift4(attributesOf4(live, props), props);
+
+// src/unifi/acl-rule.ts
+var UnifiAclRule = Resource4("Unifi.AclRule", {
+  defaultRemovalPolicy: "retain"
+});
+var aclRule = (id, props) => UnifiAclRule(id, props).pipe(adopt4(true));
+var spec4 = {
+  type: "Unifi.AclRule",
+  describe: (props) => `sites/${props.siteId}/acl-rules/${props.aclRuleId}`,
+  fetchLive: (props) => aclRules.getAclRule({ siteId: props.siteId, aclRuleId: props.aclRuleId }).pipe(Effect6.catchTag("NotFound", () => Effect6.succeed(undefined))),
+  attributes: attributesOf4,
+  matches: matches4
+};
+var handlers4 = unifiHandlers(spec4);
+var UnifiAclRuleProvider = () => Provider4.effect(UnifiAclRule, Effect6.succeed(UnifiAclRule.Provider.of(handlers4)));
+// src/unifi/acl-rule-ordering.ts
+import { Resource as Resource5 } from "alchemy";
+import { adopt as adopt5 } from "alchemy/AdoptPolicy";
+import * as Provider5 from "alchemy/Provider";
+import * as aclRules2 from "@distilled.cloud/unifi-network/access_control_acl_rules";
+import * as Effect7 from "effect/Effect";
+
+// src/unifi/acl-rule-ordering-form.ts
+var attributesOf5 = (live, props) => ({
+  siteId: props.siteId,
+  orderedAclRuleIds: live.orderedAclRuleIds
+});
+var declareAclRuleOrdering = (live, siteId) => ({
+  siteId,
+  orderedAclRuleIds: live.orderedAclRuleIds
+});
+var fieldDrift5 = makeDriftOf([
+  {
+    field: "orderedAclRuleIds",
+    live: (a) => a.orderedAclRuleIds,
+    declared: (p) => p.orderedAclRuleIds
+  }
+]);
+var matches5 = (attributes, props) => fieldDrift5(attributes, props).length === 0;
+var driftOf5 = (live, props) => fieldDrift5(attributesOf5(live, props), props);
+
+// src/unifi/acl-rule-ordering.ts
+var UnifiAclRuleOrdering = Resource5("Unifi.AclRuleOrdering", {
+  defaultRemovalPolicy: "retain"
+});
+var aclRuleOrdering = (id, props) => UnifiAclRuleOrdering(id, props).pipe(adopt5(true));
+var spec5 = {
+  type: "Unifi.AclRuleOrdering",
+  describe: (props) => `sites/${props.siteId}/acl-rules/ordering`,
+  fetchLive: (props) => aclRules2.getAclRuleOrdering({ siteId: props.siteId }).pipe(Effect7.catchTag("NotFound", () => Effect7.succeed(undefined))),
+  attributes: attributesOf5,
+  matches: matches5
+};
+var handlers5 = unifiHandlers(spec5);
+var UnifiAclRuleOrderingProvider = () => Provider5.effect(UnifiAclRuleOrdering, Effect7.succeed(UnifiAclRuleOrdering.Provider.of(handlers5)));
+// src/unifi/wifi-broadcast.ts
+import { Resource as Resource6 } from "alchemy";
+import { adopt as adopt6 } from "alchemy/AdoptPolicy";
+import * as Provider6 from "alchemy/Provider";
+import * as wifiBroadcasts from "@distilled.cloud/unifi-network/wifi_broadcasts";
+import * as Effect9 from "effect/Effect";
+
+// src/unifi/wifi-broadcast-form.ts
+var sortedStrings = (values) => [...new Set(values)].sort();
+var sortedFrequencies = (values) => [...new Set(values)].sort((a, b) => a - b);
+var refKey = (ref) => `${ref.type}:${ref.networkId ?? ""}`;
+var normalizeRef = (ref) => ref === undefined ? undefined : { type: ref.type, ...ref.networkId !== undefined ? { networkId: ref.networkId } : {} };
+var sortedRefs = (values) => {
+  const byKey = new Map(values.map((ref) => [refKey(ref), normalizeRef(ref)]));
+  return [...byKey.values()].sort((a, b) => refKey(a).localeCompare(refKey(b)));
+};
+var normalizeHotspot = (value) => value === undefined ? undefined : { type: value.type };
+var normalizeDeviceFilter2 = (value) => value == null ? value : {
+  type: value.type,
+  ...value.deviceIds !== undefined ? { deviceIds: sortedStrings(value.deviceIds) } : {},
+  ...value.deviceTagIds !== undefined ? { deviceTagIds: sortedStrings(value.deviceTagIds) } : {}
+};
+var normalizeFrequencies = (value) => value === undefined ? value : sortedFrequencies(value);
+var normalizeSecurityConfiguration = (value) => ({
+  type: value.type,
+  ...value.presharedKeyNetworkIds !== undefined ? { presharedKeyNetworkIds: sortedRefs(value.presharedKeyNetworkIds) } : {}
+});
+var attributesOf6 = (live, props) => ({
+  siteId: props.siteId,
+  wifiBroadcastId: live.id,
+  name: live.name,
+  enabled: live.enabled,
+  type: live.type,
+  network: normalizeRef(live.network),
+  broadcastingDeviceFilter: normalizeDeviceFilter2(live.broadcastingDeviceFilter),
+  broadcastingFrequenciesGHz: normalizeFrequencies(live.broadcastingFrequenciesGHz),
+  hotspotConfiguration: normalizeHotspot(live.hotspotConfiguration),
+  securityConfiguration: normalizeSecurityConfiguration(live.securityConfiguration),
+  metadataOrigin: live.metadata.origin
+});
+var declareWifiBroadcast = (live, siteId) => ({
+  siteId,
+  wifiBroadcastId: live.id,
+  name: live.name,
+  enabled: live.enabled,
+  type: live.type,
+  network: normalizeRef(live.network),
+  broadcastingDeviceFilter: normalizeDeviceFilter2(live.broadcastingDeviceFilter),
+  broadcastingFrequenciesGHz: normalizeFrequencies(live.broadcastingFrequenciesGHz),
+  hotspotConfiguration: normalizeHotspot(live.hotspotConfiguration),
+  securityConfiguration: normalizeSecurityConfiguration(live.securityConfiguration)
+});
+
+// src/unifi/wifi-broadcast-drift.ts
+var fieldDrift6 = makeDriftOf([
+  { field: "name", live: (a) => a.name, declared: (p) => p.name },
+  { field: "enabled", live: (a) => a.enabled, declared: (p) => p.enabled },
+  { field: "type", live: (a) => a.type, declared: (p) => p.type },
+  {
+    field: "network",
+    live: (a) => a.network,
+    declared: (p) => normalizeRef(p.network)
+  },
+  {
+    field: "broadcastingDeviceFilter",
+    live: (a) => a.broadcastingDeviceFilter,
+    declared: (p) => normalizeDeviceFilter2(p.broadcastingDeviceFilter)
+  },
+  {
+    field: "broadcastingFrequenciesGHz",
+    live: (a) => a.broadcastingFrequenciesGHz,
+    declared: (p) => normalizeFrequencies(p.broadcastingFrequenciesGHz)
+  },
+  {
+    field: "hotspotConfiguration",
+    live: (a) => a.hotspotConfiguration,
+    declared: (p) => normalizeHotspot(p.hotspotConfiguration)
+  },
+  {
+    field: "securityConfiguration",
+    live: (a) => a.securityConfiguration,
+    declared: (p) => normalizeSecurityConfiguration(p.securityConfiguration)
+  }
+]);
+var matches6 = (attributes, props) => fieldDrift6(attributes, props).length === 0;
+var driftOf6 = (live, props) => fieldDrift6(attributesOf6(live, props), props);
+
+// src/unifi/paginate.ts
+import * as Data2 from "effect/Data";
+import * as Effect8 from "effect/Effect";
+var MAX_PAGES = 1000;
+
+class UnifiPaginationInconsistent extends Data2.TaggedError("UnifiPaginationInconsistent") {
+  get message() {
+    return `UniFi pager: ${this.reason} -- ${this.detail}. The paged response contradicted itself (or ` + "the walk ran implausibly long); the rows collected so far cannot be trusted and are not returned.";
+  }
+}
+var numOrPlaceholder = (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : "<non-numeric>";
+var pageAll = (fetchPage, request) => Effect8.gen(function* () {
+  const rows = [];
+  const startOffset = request.offset ?? 0;
+  let offset = startOffset;
+  let totalCount;
+  for (let pageCount = 1;; pageCount++) {
+    if (pageCount > MAX_PAGES) {
+      return yield* new UnifiPaginationInconsistent({
+        reason: "page-ceiling",
+        detail: `stopped after ${MAX_PAGES} pages at offset ${offset} without reaching totalCount`
+      });
+    }
+    const page = yield* fetchPage({ ...request, offset });
+    if (page.offset !== offset) {
+      return yield* new UnifiPaginationInconsistent({
+        reason: "offset-mismatch",
+        detail: `requested offset ${offset}, page echoed ${numOrPlaceholder(page.offset)} -- rows may be duplicated or skipped`
+      });
+    }
+    if (totalCount !== undefined && page.totalCount !== totalCount) {
+      return yield* new UnifiPaginationInconsistent({
+        reason: "total-count-changed",
+        detail: `totalCount changed from ${numOrPlaceholder(totalCount)} to ${numOrPlaceholder(page.totalCount)} between page calls`
+      });
+    }
+    totalCount = page.totalCount;
+    rows.push(...page.data);
+    if (page.data.length === 0)
+      break;
+    offset += page.data.length;
+    if (offset >= totalCount)
+      break;
+  }
+  const expected = totalCount - startOffset;
+  if (rows.length !== expected) {
+    return yield* new UnifiPaginationInconsistent({
+      reason: "row-count-mismatch",
+      detail: `collected ${rows.length} rows but totalCount(${numOrPlaceholder(totalCount)}) - startOffset(${startOffset}) = ${numOrPlaceholder(expected)}`
+    });
+  }
+  return rows;
+});
+
+// src/unifi/wifi-broadcast.ts
+var UnifiWifiBroadcast = Resource6("Unifi.WifiBroadcast", {
+  defaultRemovalPolicy: "retain"
+});
+var wifiBroadcast = (id, props) => UnifiWifiBroadcast(id, props).pipe(adopt6(true));
+var spec6 = {
+  type: "Unifi.WifiBroadcast",
+  describe: (props) => `sites/${props.siteId}/wifi/broadcasts/${props.wifiBroadcastId}`,
+  fetchLive: (props) => pageAll(wifiBroadcasts.getWifiBroadcastPage, { siteId: props.siteId }).pipe(Effect9.catchTag("NotFound", () => Effect9.succeed(undefined)), Effect9.map((rows) => rows?.find((row) => row.id === props.wifiBroadcastId))),
+  attributes: attributesOf6,
+  matches: matches6
+};
+var handlers6 = unifiHandlers(spec6);
+var UnifiWifiBroadcastProvider = () => Provider6.effect(UnifiWifiBroadcast, Effect9.succeed(UnifiWifiBroadcast.Provider.of(handlers6)));
+// src/unifi/firewall-policy.ts
+import { Resource as Resource7 } from "alchemy";
+import { adopt as adopt7 } from "alchemy/AdoptPolicy";
+import * as Provider7 from "alchemy/Provider";
+import * as firewall2 from "@distilled.cloud/unifi-network/firewall";
+import * as Effect10 from "effect/Effect";
+
+// src/unifi/firewall-policy-form.ts
+var sortedSet4 = (values) => [...new Set(values)].sort();
+var normalizeConnectionStateFilter = (value) => value == null ? undefined : sortedSet4(value);
+var attributesOf7 = (live, props) => ({
+  siteId: props.siteId,
+  firewallPolicyId: live.id,
+  action: live.action,
+  connectionStateFilter: normalizeConnectionStateFilter(live.connectionStateFilter),
+  description: live.description,
+  destination: live.destination,
+  enabled: live.enabled,
+  index: live.index,
+  ipProtocolScope: live.ipProtocolScope,
+  ipsecFilter: live.ipsecFilter,
+  loggingEnabled: live.loggingEnabled,
+  name: live.name,
+  schedule: live.schedule,
+  source: live.source,
+  metadataOrigin: live.metadata.origin
+});
+var declareFirewallPolicy = (live, siteId) => ({
+  siteId,
+  firewallPolicyId: live.id,
+  action: live.action,
+  connectionStateFilter: normalizeConnectionStateFilter(live.connectionStateFilter),
+  description: live.description,
+  destination: live.destination,
+  enabled: live.enabled,
+  ipProtocolScope: live.ipProtocolScope,
+  ipsecFilter: live.ipsecFilter,
+  loggingEnabled: live.loggingEnabled,
+  name: live.name,
+  schedule: live.schedule,
+  source: live.source
+});
+
+// src/unifi/firewall-policy-drift.ts
+var fieldDrift7 = makeDriftOf([
+  { field: "action", live: (a) => a.action, declared: (p) => p.action },
+  {
+    field: "connectionStateFilter",
+    live: (a) => normalizeConnectionStateFilter(a.connectionStateFilter),
+    declared: (p) => normalizeConnectionStateFilter(p.connectionStateFilter)
+  },
+  { field: "description", live: (a) => a.description, declared: (p) => p.description },
+  { field: "destination", live: (a) => a.destination, declared: (p) => p.destination },
+  { field: "enabled", live: (a) => a.enabled, declared: (p) => p.enabled },
+  { field: "ipProtocolScope", live: (a) => a.ipProtocolScope, declared: (p) => p.ipProtocolScope },
+  { field: "ipsecFilter", live: (a) => a.ipsecFilter, declared: (p) => p.ipsecFilter },
+  { field: "loggingEnabled", live: (a) => a.loggingEnabled, declared: (p) => p.loggingEnabled },
+  { field: "name", live: (a) => a.name, declared: (p) => p.name },
+  { field: "schedule", live: (a) => a.schedule, declared: (p) => p.schedule },
+  { field: "source", live: (a) => a.source, declared: (p) => p.source }
+]);
+var matches7 = (attributes, props) => fieldDrift7(attributes, props).length === 0;
+var driftOf7 = (live, props) => fieldDrift7(attributesOf7(live, props), props);
+
+// src/unifi/firewall-policy.ts
+var UnifiFirewallPolicy = Resource7("Unifi.FirewallPolicy", {
+  defaultRemovalPolicy: "retain"
+});
+var firewallPolicy = (id, props) => UnifiFirewallPolicy(id, props).pipe(adopt7(true));
+var spec7 = {
+  type: "Unifi.FirewallPolicy",
+  describe: (props) => `sites/${props.siteId}/firewall/policies/${props.firewallPolicyId}`,
+  fetchLive: (props) => firewall2.getFirewallPolicy({ siteId: props.siteId, firewallPolicyId: props.firewallPolicyId }).pipe(Effect10.catchTag("NotFound", () => Effect10.succeed(undefined))),
+  attributes: attributesOf7,
+  matches: matches7
+};
+var handlers7 = unifiHandlers(spec7);
+var UnifiFirewallPolicyProvider = () => Provider7.effect(UnifiFirewallPolicy, Effect10.succeed(UnifiFirewallPolicy.Provider.of(handlers7)));
+// src/unifi/firewall-policy-ordering.ts
+import { Resource as Resource8 } from "alchemy";
+import { adopt as adopt8 } from "alchemy/AdoptPolicy";
+import * as Provider8 from "alchemy/Provider";
+import * as firewall3 from "@distilled.cloud/unifi-network/firewall";
+import * as Effect11 from "effect/Effect";
+
+// src/unifi/firewall-policy-ordering-form.ts
+var attributesOf8 = (live, props) => ({
+  siteId: props.siteId,
+  sourceFirewallZoneId: props.sourceFirewallZoneId,
+  destinationFirewallZoneId: props.destinationFirewallZoneId,
+  beforeSystemDefined: live.orderedFirewallPolicyIds.beforeSystemDefined,
+  afterSystemDefined: live.orderedFirewallPolicyIds.afterSystemDefined
+});
+var declareFirewallPolicyOrdering = (live, siteId, sourceFirewallZoneId, destinationFirewallZoneId) => ({
+  siteId,
+  sourceFirewallZoneId,
+  destinationFirewallZoneId,
+  beforeSystemDefined: live.orderedFirewallPolicyIds.beforeSystemDefined,
+  afterSystemDefined: live.orderedFirewallPolicyIds.afterSystemDefined
+});
+var fieldDrift8 = makeDriftOf([
+  {
+    field: "beforeSystemDefined",
+    live: (a) => a.beforeSystemDefined,
+    declared: (p) => p.beforeSystemDefined
+  },
+  {
+    field: "afterSystemDefined",
+    live: (a) => a.afterSystemDefined,
+    declared: (p) => p.afterSystemDefined
+  }
+]);
+var matches8 = (attributes, props) => fieldDrift8(attributes, props).length === 0;
+var driftOf8 = (live, props) => fieldDrift8(attributesOf8(live, props), props);
+
+// src/unifi/firewall-policy-ordering.ts
+var UnifiFirewallPolicyOrdering = Resource8("Unifi.FirewallPolicyOrdering", { defaultRemovalPolicy: "retain" });
+var firewallPolicyOrdering = (id, props) => UnifiFirewallPolicyOrdering(id, props).pipe(adopt8(true));
+var spec8 = {
+  type: "Unifi.FirewallPolicyOrdering",
+  describe: (props) => `sites/${props.siteId}/firewall/policies/ordering` + `?sourceFirewallZoneId=${props.sourceFirewallZoneId}` + `&destinationFirewallZoneId=${props.destinationFirewallZoneId}`,
+  fetchLive: (props) => firewall3.getFirewallPolicyOrdering({
+    siteId: props.siteId,
+    sourceFirewallZoneId: props.sourceFirewallZoneId,
+    destinationFirewallZoneId: props.destinationFirewallZoneId
+  }).pipe(Effect11.catchTag("NotFound", () => Effect11.succeed(undefined))),
+  attributes: attributesOf8,
+  matches: matches8
+};
+var handlers8 = unifiHandlers(spec8);
+var UnifiFirewallPolicyOrderingProvider = () => Provider8.effect(UnifiFirewallPolicyOrdering, Effect11.succeed(UnifiFirewallPolicyOrdering.Provider.of(handlers8)));
+// src/unifi/traffic-matching-list.ts
+import { Resource as Resource9 } from "alchemy";
+import { adopt as adopt9 } from "alchemy/AdoptPolicy";
+import * as Provider9 from "alchemy/Provider";
+import * as trafficMatchingLists from "@distilled.cloud/unifi-network/traffic_matching_lists";
+import * as Effect12 from "effect/Effect";
+
+// src/unifi/traffic-matching-list-form.ts
+var attributesOf9 = (live, props) => ({
+  siteId: props.siteId,
+  trafficMatchingListId: live.id,
+  name: live.name,
+  type: live.type,
+  items: live.items
+});
+var declareTrafficMatchingList = (live, siteId) => ({
+  siteId,
+  trafficMatchingListId: live.id,
+  name: live.name,
+  type: live.type,
+  items: live.items
+});
+
+// src/unifi/traffic-matching-list-drift.ts
+var fieldDrift9 = makeDriftOf([
+  { field: "name", live: (a) => a.name, declared: (p) => p.name },
+  { field: "type", live: (a) => a.type, declared: (p) => p.type },
+  { field: "items", live: (a) => a.items, declared: (p) => p.items }
+]);
+var matches9 = (attributes, props) => fieldDrift9(attributes, props).length === 0;
+var driftOf9 = (live, props) => fieldDrift9(attributesOf9(live, props), props);
+
+// src/unifi/traffic-matching-list.ts
+var UnifiTrafficMatchingList = Resource9("Unifi.TrafficMatchingList", { defaultRemovalPolicy: "retain" });
+var trafficMatchingList = (id, props) => UnifiTrafficMatchingList(id, props).pipe(adopt9(true));
+var spec9 = {
+  type: "Unifi.TrafficMatchingList",
+  describe: (props) => `sites/${props.siteId}/traffic-matching-lists/${props.trafficMatchingListId}`,
+  fetchLive: (props) => trafficMatchingLists.getTrafficMatchingList({
+    siteId: props.siteId,
+    trafficMatchingListId: props.trafficMatchingListId
+  }).pipe(Effect12.catchTag("NotFound", () => Effect12.succeed(undefined))),
+  attributes: attributesOf9,
+  matches: matches9
+};
+var handlers9 = unifiHandlers(spec9);
+var UnifiTrafficMatchingListProvider = () => Provider9.effect(UnifiTrafficMatchingList, Effect12.succeed(UnifiTrafficMatchingList.Provider.of(handlers9)));
 // src/unifi/providers.ts
 import * as Layer from "effect/Layer";
-var providers = () => Layer.mergeAll(UnifiNetworkProvider(), UnifiFirewallZoneProvider());
+var providers = () => Layer.mergeAll(UnifiNetworkProvider(), UnifiFirewallZoneProvider(), UnifiDnsPolicyProvider(), UnifiAclRuleProvider(), UnifiAclRuleOrderingProvider(), UnifiWifiBroadcastProvider(), UnifiFirewallPolicyProvider(), UnifiFirewallPolicyOrderingProvider(), UnifiTrafficMatchingListProvider());
 export {
+  GetOnlyHttpClient,
   UNIFI_READ_ONLY_POLICY,
+  UnifiAclRule,
+  UnifiAclRuleOrdering,
+  UnifiAclRuleOrderingProvider,
+  UnifiAclRuleProvider,
+  UnifiDnsPolicy,
+  UnifiDnsPolicyProvider,
+  UnifiFirewallPolicy,
+  UnifiFirewallPolicyOrdering,
+  UnifiFirewallPolicyOrderingProvider,
+  UnifiFirewallPolicyProvider,
   UnifiFirewallZone,
   UnifiFirewallZoneProvider,
   UnifiNetwork,
   UnifiNetworkProvider,
+  UnifiNonGetRequest,
+  UnifiTrafficMatchingList,
+  UnifiTrafficMatchingListProvider,
+  UnifiWifiBroadcast,
+  UnifiWifiBroadcastProvider,
   UnifiWriteRefused,
+  aclRule,
+  driftOf4 as aclRuleDriftOf,
+  aclRuleOrdering,
+  driftOf5 as aclRuleOrderingDriftOf,
+  declareAclRule,
+  declareAclRuleOrdering,
+  declareDnsPolicy,
+  declareFirewallPolicy,
+  declareFirewallPolicyOrdering,
   declareFirewallZone,
   declareNetwork,
+  declareTrafficMatchingList,
+  declareWifiBroadcast,
+  dnsPolicy,
+  driftOf3 as dnsPolicyDriftOf,
+  firewallPolicy,
+  driftOf7 as firewallPolicyDriftOf,
+  firewallPolicyOrdering,
+  driftOf8 as firewallPolicyOrderingDriftOf,
   firewallZone,
+  driftOf2 as firewallZoneDriftOf,
   network,
-  providers
+  driftOf as networkDriftOf,
+  providers,
+  trafficMatchingList,
+  driftOf9 as trafficMatchingListDriftOf,
+  wifiBroadcast,
+  driftOf6 as wifiBroadcastDriftOf
 };
 
-//# debugId=033CFC419E398B0664756E2164756E21
+//# debugId=8F60CB2F43A8D0E164756E2164756E21
 //# sourceMappingURL=index.js.map