domainkit 0.7.0 → 0.8.0

package/README.md

@@ -21,16 +21,15 @@ import { Digest, DnsRecord, DomainName, Provisioning } from "domainkit";
 import { InMemoryDnsProvider } from "domainkit/testing";
 import { Effect, Layer } from "effect";
 
-const requirement = DnsRecord.parse({
-  _tag: "CNAME",
+const requirement = DnsRecord.Cname({
   metadata: {
     ownership: "customer",
     provenance: "product-onboarding",
     purpose: "tracking",
   },
-  name: "track.example.com",
+  name: DomainName.parse("track.example.com"),
   policy: "exclusive",
-  target: "tracking.example.net",
+  target: DomainName.parse("tracking.example.net"),
   ttl: 300,
 });
 
@@ -49,6 +48,10 @@ const program = Effect.gen(function* () {
 Planning is additive and fail-closed: exact records become no-ops, missing records become creates,
 and incompatible state becomes a conflict. DomainKit never silently overwrites DNS.
 
+Tagged values use callable case constructors such as `DnsRecord.Txt({...})` and
+`DnsPlan.Operation.create({...})`; use the exported schemas when decoding persisted or provider
+data.
+
 ## Public entry points
 
 - `domainkit` — Effect services, schemas, plans, providers, and verification;

package/dist/{connect-10vHuShV.d.mts → connect-D-X8T9W8.d.mts}

@@ -8,17 +8,17 @@ declare const Error_base$3: Schema.Class<Error$3, Schema.TaggedStruct<"InvalidIn
 }>, import("effect/Cause").YieldableError>;
 declare class Error$3 extends Error_base$3 {}
 declare namespace domain_name_d_exports {
-  export { DomainName, Schema$4 as Schema, decode$5 as decode, parse$1 as parse };
+  export { DomainName, Schema$3 as Schema, decode$5 as decode, parse$1 as parse };
 }
 declare const Type$1: Schema.brand<Schema.String, "DomainName">;
 /** A lower-case, fully qualified DNS name without a trailing dot. */
 type DomainName = typeof Type$1.Type;
 /** Decodes user and wire strings into canonical domain names. */
-declare const Schema$4: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+declare const Schema$3: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
 declare const decode$5: (input: unknown) => Effect.Effect<string & import("effect/Brand").Brand<"DomainName">, Error$3, never>;
 declare function parse$1(input: unknown): DomainName;
 declare namespace dns_record_d_exports {
-  export { A, Aaaa, Caa, Cname, DnsRecord, Encoded, Mx, Ns, Observed, Opaque, RequirementMetadata, Schema$3 as Schema, Srv, Txt, Type, data, decode$4 as decode, equals, parse };
+  export { A, Aaaa, Caa, Cname, DnsRecord, Encoded, Mx, Ns, Observed, Opaque, RequirementMetadata, RecordSchema as Schema, Srv, Txt, Type, data, decode$4 as decode, equals, parse };
 }
 declare const Type: Schema.Literals<readonly ["A", "AAAA", "CNAME", "TXT", "MX", "CAA", "NS", "SRV"]>;
 type Type = typeof Type.Type;
@@ -28,7 +28,7 @@ declare const RequirementMetadata: Schema.Struct<{
   readonly purpose: Schema.String;
 }>;
 interface RequirementMetadata extends Schema.Schema.Type<typeof RequirementMetadata> {}
-declare const Schema$3: Schema.TaggedUnion<{
+declare const RecordSchema: Schema.TaggedUnion<{
   readonly A: Schema.TaggedStruct<"A", {
     readonly metadata: Schema.Struct<{
       readonly ownership: Schema.String;
@@ -124,102 +124,249 @@ declare const Schema$3: Schema.TaggedUnion<{
     readonly value: Schema.String;
   }>;
 }>;
-declare const A: Schema.TaggedStruct<"A", {
-  readonly metadata: Schema.Struct<{
-    readonly ownership: Schema.String;
-    readonly provenance: Schema.String;
-    readonly purpose: Schema.String;
+/** Constructs an A record requirement from trusted application data. */
+declare function A(input: Parameters<typeof RecordSchema.cases.A.make>[0]): {
+  readonly _tag: "A";
+  readonly metadata: {
+    readonly ownership: string;
+    readonly provenance: string;
+    readonly purpose: string;
+  };
+  readonly name: string & import("effect/Brand").Brand<"DomainName">;
+  readonly policy: "append" | "exclusive";
+  readonly ttl: number | null;
+  readonly address: string;
+};
+declare namespace A {
+  const Schema: Schema.TaggedStruct<"A", {
+    readonly metadata: Schema.Struct<{
+      readonly ownership: Schema.String;
+      readonly provenance: Schema.String;
+      readonly purpose: Schema.String;
+    }>;
+    readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
+    readonly ttl: Schema.NullOr<Schema.Int>;
+    readonly address: Schema.String;
   }>;
-  readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-  readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
-  readonly ttl: Schema.NullOr<Schema.Int>;
-  readonly address: Schema.String;
-}>, Aaaa: Schema.TaggedStruct<"AAAA", {
-  readonly metadata: Schema.Struct<{
-    readonly ownership: Schema.String;
-    readonly provenance: Schema.String;
-    readonly purpose: Schema.String;
+}
+/** Constructs an AAAA record requirement from trusted application data. */
+declare function Aaaa(input: Parameters<typeof RecordSchema.cases.AAAA.make>[0]): {
+  readonly _tag: "AAAA";
+  readonly metadata: {
+    readonly ownership: string;
+    readonly provenance: string;
+    readonly purpose: string;
+  };
+  readonly name: string & import("effect/Brand").Brand<"DomainName">;
+  readonly policy: "append" | "exclusive";
+  readonly ttl: number | null;
+  readonly address: string;
+};
+declare namespace Aaaa {
+  const Schema: Schema.TaggedStruct<"AAAA", {
+    readonly metadata: Schema.Struct<{
+      readonly ownership: Schema.String;
+      readonly provenance: Schema.String;
+      readonly purpose: Schema.String;
+    }>;
+    readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
+    readonly ttl: Schema.NullOr<Schema.Int>;
+    readonly address: Schema.String;
   }>;
-  readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-  readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
-  readonly ttl: Schema.NullOr<Schema.Int>;
-  readonly address: Schema.String;
-}>, Caa: Schema.TaggedStruct<"CAA", {
-  readonly metadata: Schema.Struct<{
-    readonly ownership: Schema.String;
-    readonly provenance: Schema.String;
-    readonly purpose: Schema.String;
+}
+/** Constructs a CAA record requirement from trusted application data. */
+declare function Caa(input: Parameters<typeof RecordSchema.cases.CAA.make>[0]): {
+  readonly _tag: "CAA";
+  readonly metadata: {
+    readonly ownership: string;
+    readonly provenance: string;
+    readonly purpose: string;
+  };
+  readonly name: string & import("effect/Brand").Brand<"DomainName">;
+  readonly policy: "append" | "exclusive";
+  readonly ttl: number | null;
+  readonly flags: number;
+  readonly tag: "iodef" | "issue" | "issuewild";
+  readonly value: string;
+};
+declare namespace Caa {
+  const Schema: Schema.TaggedStruct<"CAA", {
+    readonly metadata: Schema.Struct<{
+      readonly ownership: Schema.String;
+      readonly provenance: Schema.String;
+      readonly purpose: Schema.String;
+    }>;
+    readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
+    readonly ttl: Schema.NullOr<Schema.Int>;
+    readonly flags: Schema.Int;
+    readonly tag: Schema.Literals<readonly ["issue", "issuewild", "iodef"]>;
+    readonly value: Schema.String;
   }>;
-  readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-  readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
-  readonly ttl: Schema.NullOr<Schema.Int>;
-  readonly flags: Schema.Int;
-  readonly tag: Schema.Literals<readonly ["issue", "issuewild", "iodef"]>;
-  readonly value: Schema.String;
-}>, Cname: Schema.TaggedStruct<"CNAME", {
-  readonly metadata: Schema.Struct<{
-    readonly ownership: Schema.String;
-    readonly provenance: Schema.String;
-    readonly purpose: Schema.String;
+}
+/** Constructs a CNAME record requirement from trusted application data. */
+declare function Cname(input: Parameters<typeof RecordSchema.cases.CNAME.make>[0]): {
+  readonly _tag: "CNAME";
+  readonly metadata: {
+    readonly ownership: string;
+    readonly provenance: string;
+    readonly purpose: string;
+  };
+  readonly name: string & import("effect/Brand").Brand<"DomainName">;
+  readonly ttl: number | null;
+  readonly policy: "exclusive";
+  readonly target: string & import("effect/Brand").Brand<"DomainName">;
+};
+declare namespace Cname {
+  const Schema: Schema.TaggedStruct<"CNAME", {
+    readonly metadata: Schema.Struct<{
+      readonly ownership: Schema.String;
+      readonly provenance: Schema.String;
+      readonly purpose: Schema.String;
+    }>;
+    readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    readonly ttl: Schema.NullOr<Schema.Int>;
+    readonly policy: Schema.Literal<"exclusive">;
+    readonly target: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
   }>;
-  readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-  readonly ttl: Schema.NullOr<Schema.Int>;
-  readonly policy: Schema.Literal<"exclusive">;
-  readonly target: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-}>, Mx: Schema.TaggedStruct<"MX", {
-  readonly metadata: Schema.Struct<{
-    readonly ownership: Schema.String;
-    readonly provenance: Schema.String;
-    readonly purpose: Schema.String;
+}
+/** Constructs an MX record requirement from trusted application data. */
+declare function Mx(input: Parameters<typeof RecordSchema.cases.MX.make>[0]): {
+  readonly _tag: "MX";
+  readonly metadata: {
+    readonly ownership: string;
+    readonly provenance: string;
+    readonly purpose: string;
+  };
+  readonly name: string & import("effect/Brand").Brand<"DomainName">;
+  readonly policy: "append" | "exclusive";
+  readonly ttl: number | null;
+  readonly exchange: string & import("effect/Brand").Brand<"DomainName">;
+  readonly priority: number;
+};
+declare namespace Mx {
+  const Schema: Schema.TaggedStruct<"MX", {
+    readonly metadata: Schema.Struct<{
+      readonly ownership: Schema.String;
+      readonly provenance: Schema.String;
+      readonly purpose: Schema.String;
+    }>;
+    readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
+    readonly ttl: Schema.NullOr<Schema.Int>;
+    readonly exchange: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    readonly priority: Schema.Int;
   }>;
-  readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-  readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
-  readonly ttl: Schema.NullOr<Schema.Int>;
-  readonly exchange: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-  readonly priority: Schema.Int;
-}>, Ns: Schema.TaggedStruct<"NS", {
-  readonly metadata: Schema.Struct<{
-    readonly ownership: Schema.String;
-    readonly provenance: Schema.String;
-    readonly purpose: Schema.String;
+}
+/** Constructs an NS record requirement from trusted application data. */
+declare function Ns(input: Parameters<typeof RecordSchema.cases.NS.make>[0]): {
+  readonly _tag: "NS";
+  readonly metadata: {
+    readonly ownership: string;
+    readonly provenance: string;
+    readonly purpose: string;
+  };
+  readonly name: string & import("effect/Brand").Brand<"DomainName">;
+  readonly policy: "append" | "exclusive";
+  readonly ttl: number | null;
+  readonly target: string & import("effect/Brand").Brand<"DomainName">;
+};
+declare namespace Ns {
+  const Schema: Schema.TaggedStruct<"NS", {
+    readonly metadata: Schema.Struct<{
+      readonly ownership: Schema.String;
+      readonly provenance: Schema.String;
+      readonly purpose: Schema.String;
+    }>;
+    readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
+    readonly ttl: Schema.NullOr<Schema.Int>;
+    readonly target: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
   }>;
-  readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-  readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
-  readonly ttl: Schema.NullOr<Schema.Int>;
-  readonly target: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-}>, Srv: Schema.TaggedStruct<"SRV", {
-  readonly metadata: Schema.Struct<{
-    readonly ownership: Schema.String;
-    readonly provenance: Schema.String;
-    readonly purpose: Schema.String;
+}
+/** Constructs an SRV record requirement from trusted application data. */
+declare function Srv(input: Parameters<typeof RecordSchema.cases.SRV.make>[0]): {
+  readonly _tag: "SRV";
+  readonly metadata: {
+    readonly ownership: string;
+    readonly provenance: string;
+    readonly purpose: string;
+  };
+  readonly name: string & import("effect/Brand").Brand<"DomainName">;
+  readonly policy: "append" | "exclusive";
+  readonly ttl: number | null;
+  readonly port: number;
+  readonly priority: number;
+  readonly target: string & import("effect/Brand").Brand<"DomainName">;
+  readonly weight: number;
+};
+declare namespace Srv {
+  const Schema: Schema.TaggedStruct<"SRV", {
+    readonly metadata: Schema.Struct<{
+      readonly ownership: Schema.String;
+      readonly provenance: Schema.String;
+      readonly purpose: Schema.String;
+    }>;
+    readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
+    readonly ttl: Schema.NullOr<Schema.Int>;
+    readonly port: Schema.Int;
+    readonly priority: Schema.Int;
+    readonly target: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    readonly weight: Schema.Int;
   }>;
-  readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-  readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
-  readonly ttl: Schema.NullOr<Schema.Int>;
-  readonly port: Schema.Int;
-  readonly priority: Schema.Int;
-  readonly target: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-  readonly weight: Schema.Int;
-}>, Txt: Schema.TaggedStruct<"TXT", {
-  readonly metadata: Schema.Struct<{
-    readonly ownership: Schema.String;
-    readonly provenance: Schema.String;
-    readonly purpose: Schema.String;
+}
+/** Constructs a TXT record requirement from trusted application data. */
+declare function Txt(input: Parameters<typeof RecordSchema.cases.TXT.make>[0]): {
+  readonly _tag: "TXT";
+  readonly metadata: {
+    readonly ownership: string;
+    readonly provenance: string;
+    readonly purpose: string;
+  };
+  readonly name: string & import("effect/Brand").Brand<"DomainName">;
+  readonly policy: "append" | "exclusive";
+  readonly ttl: number | null;
+  readonly value: string;
+};
+declare namespace Txt {
+  const Schema: Schema.TaggedStruct<"TXT", {
+    readonly metadata: Schema.Struct<{
+      readonly ownership: Schema.String;
+      readonly provenance: Schema.String;
+      readonly purpose: Schema.String;
+    }>;
+    readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
+    readonly ttl: Schema.NullOr<Schema.Int>;
+    readonly value: Schema.String;
   }>;
-  readonly name: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
-  readonly policy: Schema.Literals<readonly ["exclusive", "append"]>;
-  readonly ttl: Schema.NullOr<Schema.Int>;
-  readonly value: Schema.String;
-}>;
-type DnsRecord = typeof Schema$3.Type;
-type Encoded = typeof Schema$3.Encoded;
+}
+type DnsRecord = typeof RecordSchema.Type;
+type Encoded = typeof RecordSchema.Encoded;
 /** Provider state that DomainKit cannot create but must retain for safe reconciliation. */
-declare const Opaque: Schema.TaggedStruct<"Opaque", {
+declare const OpaqueSchema: Schema.TaggedStruct<"Opaque", {
   readonly name: Schema.String;
   readonly providerRecordId: Schema.NullOr<Schema.String>;
   readonly providerType: Schema.String;
 }>;
-interface Opaque extends Schema.Schema.Type<typeof Opaque> {}
+/** Constructs an opaque provider record from trusted adapter data. */
+declare function Opaque(input: Parameters<typeof OpaqueSchema.make>[0]): {
+  readonly _tag: "Opaque";
+  readonly name: string;
+  readonly providerRecordId: string | null;
+  readonly providerType: string;
+};
+declare namespace Opaque {
+  const Schema: Schema.TaggedStruct<"Opaque", {
+    readonly name: Schema.String;
+    readonly providerRecordId: Schema.NullOr<Schema.String>;
+    readonly providerType: Schema.String;
+  }>;
+}
+interface Opaque extends Schema.Schema.Type<typeof OpaqueSchema> {}
 /** Any DNS record observed through a provider, including non-portable record types. */
 declare const Observed: Schema.Union<readonly [Schema.TaggedUnion<{
   readonly A: Schema.TaggedStruct<"A", {
@@ -476,7 +623,7 @@ declare const make: typeof Value.from;
 declare namespace manifest_d_exports {
   export { AsyncOAuthSubjectResolver, IntegrationMethod, Manifest, Method$1 as Method, OAuthClientConfiguration, OAuthMethod, OAuthSubjectResolver, Schema$2 as Schema, TokenValidation, decode$3 as decode };
 }
-declare const Method$1: Schema.TaggedUnion<{
+declare const MethodSchema: Schema.TaggedUnion<{
   readonly integration: Schema.TaggedStruct<"integration", {
     readonly capabilities: Schema.$Array<Schema.Literals<readonly ["dns:read", "dns:write"]>>;
     readonly installUrl: Schema.String;
@@ -498,6 +645,55 @@ declare const Method$1: Schema.TaggedUnion<{
     readonly instructionsUrl: Schema.String;
   }>;
 }>;
+/** Provider authentication method schema and constructors for trusted manifests. */
+declare const Method$1: {
+  Schema: Schema.TaggedUnion<{
+    readonly integration: Schema.TaggedStruct<"integration", {
+      readonly capabilities: Schema.$Array<Schema.Literals<readonly ["dns:read", "dns:write"]>>;
+      readonly installUrl: Schema.String;
+      readonly tokenEndpoint: Schema.String;
+    }>;
+    readonly oauth2: Schema.TaggedStruct<"oauth2", {
+      readonly authorizationServer: Schema.Struct<{
+        readonly authorization_endpoint: Schema.String;
+        readonly issuer: Schema.String;
+        readonly revocation_endpoint: Schema.optionalKey<Schema.String>;
+        readonly token_endpoint: Schema.String;
+      }>;
+      readonly capabilities: Schema.$Array<Schema.Literals<readonly ["dns:read", "dns:write"]>>;
+      readonly clientAuth: Schema.Literals<readonly ["none", "client_secret_basic", "client_secret_post"]>;
+      readonly scopes: Schema.$Array<Schema.String>;
+    }>;
+    readonly token: Schema.TaggedStruct<"token", {
+      readonly capabilities: Schema.$Array<Schema.Literals<readonly ["dns:read", "dns:write"]>>;
+      readonly instructionsUrl: Schema.String;
+    }>;
+  }>;
+  integration: (input: Parameters<typeof MethodSchema.cases.integration.make>[0]) => {
+    readonly _tag: "integration";
+    readonly capabilities: readonly ("dns:read" | "dns:write")[];
+    readonly installUrl: string;
+    readonly tokenEndpoint: string;
+  };
+  oauth2: (input: Parameters<typeof MethodSchema.cases.oauth2.make>[0]) => {
+    readonly _tag: "oauth2";
+    readonly authorizationServer: {
+      readonly authorization_endpoint: string;
+      readonly issuer: string;
+      readonly revocation_endpoint?: string;
+      readonly token_endpoint: string;
+    };
+    readonly capabilities: readonly ("dns:read" | "dns:write")[];
+    readonly clientAuth: "client_secret_basic" | "client_secret_post" | "none";
+    readonly scopes: readonly string[];
+  };
+  token: (input: Parameters<typeof MethodSchema.cases.token.make>[0]) => {
+    readonly _tag: "token";
+    readonly capabilities: readonly ("dns:read" | "dns:write")[];
+    readonly instructionsUrl: string;
+  };
+};
+type Method$1 = typeof MethodSchema.Type;
 declare const Schema$2: Schema.Struct<{
   readonly methods: Schema.$Array<Schema.TaggedUnion<{
     readonly integration: Schema.TaggedStruct<"integration", {
@@ -1397,5 +1593,5 @@ declare const start: (input: BaseInput & {
 declare const complete: (input: CompleteInput) => Effect.Effect<ProviderConnection, Error$1 | AuthenticationFailure, Crypto.Crypto | Service>;
 type Failure = AuthenticationFailure | Error$1 | CryptoError;
 //#endregion
-export { Schema$2 as $, ConnectionStatus as A, Schema$4 as At, project as B, ConnectInput as C, Txt as Ct, Interface as D, equals as Dt, Error$1 as E, dns_record_d_exports as Et, StoredConnection as F, authorization_d_exports as G, Capability as H, StoredCredential as I, Manifest as J, AsyncOAuthSubjectResolver as K, authorizationError as L, ProviderConnection as M, parse$1 as Mt, ProviderTarget as N, Error$3 as Nt, Service as O, parse as Ot, ProviderTargetEvidence as P, invalid_input_d_exports as Pt, OAuthSubjectResolver as Q, decode$1 as R, AttachmentResult as S, Srv as St, DisconnectResult as T, data as Tt, CapabilityEvidence as U, validate as V, ProviderAuthorization as W, OAuthClientConfiguration as X, Method$1 as Y, OAuthMethod as Z, provider_context_d_exports as _, Ns as _t, Continuation as a, CreateResult as at, Aggregate as b, RequirementMetadata as bt, Failure as c, Service$1 as ct, Method as d, Aaaa as dt, TokenValidation as et, StartResult as f, Caa as ft, Envelope as g, Mx as gt, Codec as h, Encoded as ht, CompleteInput as i, AsyncInterface as it, DomainAttachment as j, domain_name_d_exports as jt, AuthorizationError as k, DomainName as kt, InteractiveFlow as l, provider_d_exports as lt, start as m, DnsRecord as mt, AuthenticationFailure as n, Value as nt, ContinuationStore as o, Error$2 as ot, complete as p, Cname as pt, IntegrationMethod as q, BaseInput as r, secret_d_exports as rt, Error as s, Interface$1 as st, Authentication as t, manifest_d_exports as tt, InteractiveStart as u, A as ut, CryptoError as v, Observed as vt, DetachResult as w, Type as wt, AggregateSchema as x, Schema$3 as xt, canonical_json_d_exports as y, Opaque as yt, encode$1 as z };
-//# sourceMappingURL=connect-10vHuShV.d.mts.map
+export { Schema$2 as $, ConnectionStatus as A, Schema$3 as At, project as B, ConnectInput as C, Txt as Ct, Interface as D, equals as Dt, Error$1 as E, dns_record_d_exports as Et, StoredConnection as F, authorization_d_exports as G, Capability as H, StoredCredential as I, Manifest as J, AsyncOAuthSubjectResolver as K, authorizationError as L, ProviderConnection as M, parse$1 as Mt, ProviderTarget as N, Error$3 as Nt, Service as O, parse as Ot, ProviderTargetEvidence as P, invalid_input_d_exports as Pt, OAuthSubjectResolver as Q, decode$1 as R, AttachmentResult as S, Srv as St, DisconnectResult as T, data as Tt, CapabilityEvidence as U, validate as V, ProviderAuthorization as W, OAuthClientConfiguration as X, Method$1 as Y, OAuthMethod as Z, provider_context_d_exports as _, Ns as _t, Continuation as a, CreateResult as at, Aggregate as b, RecordSchema as bt, Failure as c, Service$1 as ct, Method as d, Aaaa as dt, TokenValidation as et, StartResult as f, Caa as ft, Envelope as g, Mx as gt, Codec as h, Encoded as ht, CompleteInput as i, AsyncInterface as it, DomainAttachment as j, domain_name_d_exports as jt, AuthorizationError as k, DomainName as kt, InteractiveFlow as l, provider_d_exports as lt, start as m, DnsRecord as mt, AuthenticationFailure as n, Value as nt, ContinuationStore as o, Error$2 as ot, complete as p, Cname as pt, IntegrationMethod as q, BaseInput as r, secret_d_exports as rt, Error as s, Interface$1 as st, Authentication as t, manifest_d_exports as tt, InteractiveStart as u, A as ut, CryptoError as v, Observed as vt, DetachResult as w, Type as wt, AggregateSchema as x, RequirementMetadata as xt, canonical_json_d_exports as y, Opaque as yt, encode$1 as z };
+//# sourceMappingURL=connect-D-X8T9W8.d.mts.map

package/dist/{connection-C0xsU41C.d.mts → connection-Dp6ZdSo8.d.mts}

@@ -1,4 +1,4 @@
-import { A as ConnectionStatus, C as ConnectInput, D as Interface, E as Error, F as StoredConnection, H as Capability, I as StoredCredential, L as authorizationError, M as ProviderConnection, N as ProviderTarget, O as Service, P as ProviderTargetEvidence, S as AttachmentResult, T as DisconnectResult, U as CapabilityEvidence, V as validate, W as ProviderAuthorization, a as Continuation, b as Aggregate, c as Failure, d as Method$1, f as StartResult, i as CompleteInput, j as DomainAttachment, k as AuthorizationError, l as InteractiveFlow$1, n as AuthenticationFailure, nt as Value, r as BaseInput, s as Error$1, t as Authentication, u as InteractiveStart, w as DetachResult, z as encode } from "./connect-10vHuShV.mjs";
+import { A as ConnectionStatus, C as ConnectInput, D as Interface, E as Error, F as StoredConnection, H as Capability, I as StoredCredential, L as authorizationError, M as ProviderConnection, N as ProviderTarget, O as Service, P as ProviderTargetEvidence, S as AttachmentResult, T as DisconnectResult, U as CapabilityEvidence, V as validate, W as ProviderAuthorization, a as Continuation, b as Aggregate, c as Failure, d as Method$1, f as StartResult, i as CompleteInput, j as DomainAttachment, k as AuthorizationError, l as InteractiveFlow$1, n as AuthenticationFailure, nt as Value, r as BaseInput, s as Error$1, t as Authentication, u as InteractiveStart, w as DetachResult, z as encode } from "./connect-D-X8T9W8.mjs";
 import { Data, Layer } from "effect";
 declare namespace managed_dns_connections_d_exports {
   export { AsyncInterface, AttachmentResult, DetachResult, DisconnectResult, Error, from, layerFromAsync, toAsync };
@@ -183,4 +183,4 @@ declare function disconnect(input: {
 }): Promise<DisconnectResult>;
 //#endregion
 export { managed_dns_connections_d_exports as a, AsyncInterface as i, Method as n, connection_d_exports as r, InteractiveFlow as t };
-//# sourceMappingURL=connection-C0xsU41C.d.mts.map
+//# sourceMappingURL=connection-Dp6ZdSo8.d.mts.map

package/dist/{connection-api-DW7xUJdj.d.mts → connection-api-lqG1nBtD.d.mts}

@@ -1,4 +1,4 @@
-import { A as ConnectionStatus, B as project, E as Error, L as authorizationError, M as ProviderConnection, N as ProviderTarget, O as Service, P as ProviderTargetEvidence, R as decode, S as AttachmentResult, T as DisconnectResult, V as validate, W as ProviderAuthorization, a as Continuation, c as Failure, d as Method, f as StartResult, i as CompleteInput, j as DomainAttachment, k as AuthorizationError, l as InteractiveFlow, m as start, n as AuthenticationFailure, o as ContinuationStore, p as complete, r as BaseInput, s as Error$1, t as Authentication, u as InteractiveStart, w as DetachResult, z as encode } from "./connect-10vHuShV.mjs";
+import { A as ConnectionStatus, B as project, E as Error, L as authorizationError, M as ProviderConnection, N as ProviderTarget, O as Service, P as ProviderTargetEvidence, R as decode, S as AttachmentResult, T as DisconnectResult, V as validate, W as ProviderAuthorization, a as Continuation, c as Failure, d as Method, f as StartResult, i as CompleteInput, j as DomainAttachment, k as AuthorizationError, l as InteractiveFlow, m as start, n as AuthenticationFailure, o as ContinuationStore, p as complete, r as BaseInput, s as Error$1, t as Authentication, u as InteractiveStart, w as DetachResult, z as encode } from "./connect-D-X8T9W8.mjs";
 import { Effect } from "effect";
 //#region src/auth/connection-lifecycle.d.ts
 /** Attach one exact provider target to one organization domain. */
@@ -23,4 +23,4 @@ declare namespace connection_api_d_exports {
 }
 //#endregion
 export { connection_api_d_exports as t };
-//# sourceMappingURL=connection-api-DW7xUJdj.d.mts.map
+//# sourceMappingURL=connection-api-lqG1nBtD.d.mts.map