domainkit 0.2.2 → 0.3.0

package/dist/index.d.mts

@@ -1,229 +1,681 @@
-import { At as Type, Bt as invalid_input_d_exports, Ct as Ns, Dt as Schema$3, Et as RequirementMetadata, Ft as DomainName, G as EvidenceSchema, H as Capability, It as Schema$4, K as ProviderAuthorization, M as Connection, Nt as equals, Ot as Srv, Pt as parse, Q as AsyncOAuthSubjectResolver, Rt as parse$1, St as Mx, Tt as Opaque, U as CapabilityEvidence, W as Evidence, Y as encode, _t as Aaaa, at as Schema$1, bt as DnsRecord, dt as CreateResult, et as Manifest, gt as A, jt as data, kt as Txt, lt as secret_d_exports, nt as OAuthClientConfiguration, ot as TokenValidation, q as Schema$2, rt as OAuthMethod, tt as Method, ut as AsyncInterface, vt as Caa, w as provider_context_d_exports, wt as Observed, xt as Encoded, yt as Cname } from "./zone-discovery-BPnH3sLU.mjs";
-import { a as Source, i as authorization_lifecycle_d_exports, o as zone_discovery_d_exports, r as connection_d_exports } from "./connection-BfkloPZy.mjs";
-import { n as cloudflare_d_exports } from "./cloudflare-BrZPU9li.mjs";
-import { _ as selection_d_exports, c as Policy, f as Options$3, g as zones_d_exports, i as Result, m as Options$4, n as PublicDns$1, o as DefaultOptions, r as PublicDnsObservation, s as Observation, t as ProviderObservation, u as Options$5, v as diagnostic_d_exports } from "./verify-Dls29YC-.mjs";
-import { A as renderManualInstructions$1, C as DiscoverCreateInput$1, E as ResolvedCreateResult, F as PlanAuthorization, I as Receipt, L as Schema$5, M as Authorization, N as DnsPlan, O as Target, P as Operation, R as encode$1, S as CreateResult$1, _ as Receipt$1, d as Authorization$1, f as CreateError, g as Plan, h as PartialError, j as ApplyReceipt, m as Operation$1, n as AsyncInterface$1, o as Query, p as Error, r as AsyncResolution, t as Answer, u as ApplyError, w as ExactCreateInput$1, z as encodeReceipt } from "./resolver-Dc0hwV-J.mjs";
-import { i as vercel_d_exports } from "./vercel-BsNDu4Np.mjs";
-import { Data } from "effect";
-declare namespace dns_provider_d_exports {
-  export { CreateResult, AsyncInterface as Interface };
+import { $t as manifest_d_exports, B as types_d_exports, Bt as ProviderAuthorization, Ct as Connection, En as secret_d_exports, Ht as authorization_d_exports, Mn as invalid_input_d_exports, N as DnsPlan, Sn as dns_record_d_exports, St as AuthorizationError, U as zone_discovery_d_exports, an as provider_d_exports, b as AuthorizeError, bn as Type, bt as CryptoError, ft as provider_context_d_exports, jn as Error$1, k as plan_d_exports, kn as domain_name_d_exports, l as resolver_d_exports, un as DnsRecord$1, v as deletion_d_exports, xt as canonical_json_d_exports, yt as lifecycle_repository_d_exports } from "./resolver-uqe1h5Vz.mjs";
+import { J as diagnostic_d_exports, K as zones_d_exports, Y as connection_api_d_exports, a as verify_d_exports, d as google_doh_d_exports, g as index_d_exports$1, h as doh_d_exports, j as index_d_exports, l as resolver_pool_d_exports, p as cloudflare_doh_d_exports, q as selection_d_exports } from "./verify-CkgVrwyl.mjs";
+import { Context, Crypto, Data, Effect, Layer, Schema } from "effect";
+declare namespace connection_authorization_d_exports {
+  export { Error, Requirements, authorize };
 }
-declare namespace dns_resolver_d_exports {
-  export { Answer, AsyncInterface$1 as Interface, Query, AsyncResolution as Resolution };
-}
-declare namespace provider_auth_d_exports {
-  export { Manifest, Method, OAuthClientConfiguration, OAuthMethod, AsyncOAuthSubjectResolver as OAuthSubjectResolver, Schema$1 as Schema, TokenValidation, decode$2 as decode };
-}
-declare function decode$2(input: unknown): Promise<Manifest>;
-declare namespace provider_authorization_d_exports {
-  export { Capability, CapabilityEvidence, Evidence, EvidenceSchema, ProviderAuthorization, Schema$2 as Schema, decode$1 as decode, encode };
-}
-declare function decode$1(input: unknown): Promise<ProviderAuthorization>;
-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, equals, parse };
-}
-declare namespace domain_name_d_exports {
-  export { DomainName, Schema$4 as Schema, parse$1 as parse };
-}
-declare namespace dns_plan_d_exports {
-  export { ApplyReceipt, Authorization, DnsPlan, Operation, PlanAuthorization, Receipt, Schema$5 as Schema, decode, decodeReceipt, encode$1 as encode, encodeReceipt };
-}
-declare function decode(input: unknown): Promise<DnsPlan>;
-declare function decodeReceipt(input: unknown): Promise<ApplyReceipt>;
-declare namespace deletion_d_exports {
-  export { ApplyError, Authorization$1 as Authorization, CreateError, Authorization$1 as DeletionAuthorization, Operation$1 as DeletionOperation, Plan as DeletionPlan, Receipt$1 as DeletionReceipt, Error, Operation$1 as Operation, PartialError, Plan, Receipt$1 as Receipt, apply$1 as apply, authorize$1 as authorize, create$1 as create };
-}
-declare function create$1(input: {
-  readonly plan: DnsPlan;
-  readonly provider: AsyncInterface;
-  readonly receipt: ApplyReceipt;
-  readonly ttlMs?: number;
-}): Promise<Plan>;
-declare function authorize$1(plan: Plan, operationIds?: ReadonlyArray<string>): Promise<Authorization$1>;
-declare function apply$1(input: {
-  readonly authorization: Authorization$1;
-  readonly plan: Plan;
-  readonly priorReceipt?: Receipt$1;
-  readonly provider: AsyncInterface;
-}): Promise<Receipt$1>;
-declare namespace provisioning_d_exports {
-  export { CreateResult$1 as CreateResult, DiscoverCreateInput, ExactCreateInput, Target, apply, authorize, authorizeForConnection, create, renderManualInstructions };
-}
-interface ExactCreateInput extends ExactCreateInput$1 {
-  readonly provider: AsyncInterface;
-}
-interface DiscoverCreateInput extends DiscoverCreateInput$1 {
-  readonly sources: ReadonlyArray<Source>;
-}
-declare function create(input: ExactCreateInput): Promise<ResolvedCreateResult>;
-declare function create(input: DiscoverCreateInput): Promise<CreateResult$1>;
-declare function authorize(plan: DnsPlan, operationIds?: ReadonlyArray<string>, options?: {
-  readonly allowPartial?: boolean;
-}): Promise<PlanAuthorization>;
-declare function apply(input: {
-  readonly authorization: PlanAuthorization;
-  readonly plan: DnsPlan;
-  readonly provider: AsyncInterface;
-}): Promise<ApplyReceipt>;
-declare function authorizeForConnection(input: {
+declare const authorize: (input: {
   readonly allowPartial?: boolean;
   readonly authorization: ProviderAuthorization;
   readonly connection: Connection;
   readonly domain: string;
   readonly operationIds?: ReadonlyArray<string>;
   readonly plan: DnsPlan;
-}): Promise<PlanAuthorization>;
-declare const renderManualInstructions: typeof renderManualInstructions$1;
-declare namespace resolver_pool_d_exports {
-  export { Entry, Interface, Observation, Policy, defaultMake, make$3 as make };
+}) => Effect.Effect<{
+  allowPartial: boolean;
+  operationIds: string[];
+  planDigest: string;
+  version: "domainkit.plan-authorization.v1";
+}, AuthorizationError | Error$1 | AuthorizeError, Crypto.Crypto>;
+type Error = AuthorizationError | Error$1 | CryptoError;
+type Requirements = Crypto.Crypto;
+declare namespace transport_d_exports {
+  export { ApplyResult, AsyncInterface, AsyncOptions, AuthenticationMethod, AuthenticationParameter, CleanupApplyInput, CleanupOperation, CleanupPlan, CleanupPlanInput, CleanupResult, ConnectInput, Connected, ConnectionResult, ConnectionSnapshot, Disconnected, DnsRecord, Failure, InspectInput, Interface, Method, Observation, ObservationEvidence, ObserveInput, OperationResult, PlanOperation, Provider, ProvisioningApplyInput, ProvisioningPlan, ProvisioningPlanInput, Redirect, RemoveDomainInput, RemoveDomainResult, ReusableConnection, ReuseInput, Service, Unsupported, fromAsync, fromDnsRecord, layerFromAsync, toAsync };
 }
-interface Entry {
-  readonly id: string;
-  readonly resolver: AsyncInterface$1;
-  readonly timeoutMs?: number;
-}
-interface Interface {
-  readonly observe: (query: Query) => Promise<ReadonlyArray<Observation>>;
-}
-declare function make$3(entries: ReadonlyArray<Entry>): Interface;
-declare function defaultMake(options?: DefaultOptions): Interface;
-declare namespace verification_d_exports {
-  export { Config, Provider, ProviderObservation, PublicDns, PublicDnsObservation, Result, observe };
-}
-type PublicDns = PublicDns$1;
-declare const PublicDns: {
-  readonly $is: <Tag extends "Disabled" | "Enabled">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Disabled";
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Enabled";
-    readonly policy?: Policy;
-  }, {
-    readonly _tag: Tag;
+declare const Failure_base: Schema.Class<Failure, Schema.TaggedStruct<"Failure", {
+  readonly message: Schema.String;
+  readonly operation: Schema.String;
+  readonly retry: Schema.Literals<readonly ["never", "after-user-action", "safe", "unknown"]>;
+}>, import("effect/Cause").YieldableError>;
+/** A user-presentable failure at the application transport boundary. */
+declare class Failure extends Failure_base {}
+declare const AuthenticationParameter: Schema.Struct<{
+  readonly description: Schema.optionalKey<Schema.String>;
+  readonly key: Schema.String;
+  readonly label: Schema.String;
+  readonly placeholder: Schema.optionalKey<Schema.String>;
+  readonly required: Schema.optionalKey<Schema.Boolean>;
+}>;
+type AuthenticationParameter = typeof AuthenticationParameter.Type;
+declare const AuthenticationMethod: Schema.TaggedUnion<{
+  readonly OAuth: Schema.TaggedStruct<"OAuth", {
+    readonly label: Schema.String;
   }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Disabled" | "Enabled"]: (args: Extract<{
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly policy?: Policy;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly policy?: Policy;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Disabled" | "Enabled"]>>;
-    <Cases extends { readonly [Tag in "Disabled" | "Enabled"]: (args: Extract<{
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly policy?: Policy;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly policy?: Policy;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Disabled" | "Enabled"]>>;
-  };
-  readonly Disabled: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Disabled";
-  }, "_tag">;
-  readonly Enabled: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Enabled";
-    readonly policy?: Policy;
-  }, "_tag">;
-};
-type Provider = Data.TaggedEnum<{
-  Disabled: {};
-  Enabled: {
-    readonly provider: AsyncInterface;
-    readonly zone: DomainName;
+  readonly Token: Schema.TaggedStruct<"Token", {
+    readonly label: Schema.String;
+    readonly parameters: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+      readonly description: Schema.optionalKey<Schema.String>;
+      readonly key: Schema.String;
+      readonly label: Schema.String;
+      readonly placeholder: Schema.optionalKey<Schema.String>;
+      readonly required: Schema.optionalKey<Schema.Boolean>;
+    }>>>;
+    readonly placeholder: Schema.optionalKey<Schema.String>;
+  }>;
+}>;
+type AuthenticationMethod = typeof AuthenticationMethod.Type;
+/** The authentication choice supplied to a connection request. */
+type Method = Data.TaggedEnum<{
+  OAuth: {};
+  Token: {
+    readonly parameters?: Readonly<Record<string, string>>;
+    readonly token: string;
   };
 }>;
-declare const Provider: {
-  readonly $is: <Tag extends "Disabled" | "Enabled">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Disabled";
+declare const Method: {
+  readonly $is: <Tag extends "OAuth" | "Token">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "OAuth";
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Enabled";
-    readonly provider: AsyncInterface;
-    readonly zone: DomainName;
+    readonly _tag: "Token";
+    readonly parameters?: Readonly<Record<string, string>>;
+    readonly token: string;
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends { readonly [Tag in "Disabled" | "Enabled"]: (args: Extract<{
-      readonly _tag: "Disabled";
+    <Cases extends { readonly [Tag in "OAuth" | "Token"]: (args: Extract<{
+      readonly _tag: "OAuth";
     } | {
-      readonly _tag: "Enabled";
-      readonly provider: AsyncInterface;
-      readonly zone: DomainName;
+      readonly _tag: "Token";
+      readonly parameters?: Readonly<Record<string, string>>;
+      readonly token: string;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Disabled";
+      readonly _tag: "OAuth";
     } | {
-      readonly _tag: "Enabled";
-      readonly provider: AsyncInterface;
-      readonly zone: DomainName;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Disabled" | "Enabled"]>>;
-    <Cases extends { readonly [Tag in "Disabled" | "Enabled"]: (args: Extract<{
-      readonly _tag: "Disabled";
+      readonly _tag: "Token";
+      readonly parameters?: Readonly<Record<string, string>>;
+      readonly token: string;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["OAuth" | "Token"]>>;
+    <Cases extends { readonly [Tag in "OAuth" | "Token"]: (args: Extract<{
+      readonly _tag: "OAuth";
     } | {
-      readonly _tag: "Enabled";
-      readonly provider: AsyncInterface;
-      readonly zone: DomainName;
+      readonly _tag: "Token";
+      readonly parameters?: Readonly<Record<string, string>>;
+      readonly token: string;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
-      readonly _tag: "Disabled";
+      readonly _tag: "OAuth";
     } | {
-      readonly _tag: "Enabled";
-      readonly provider: AsyncInterface;
-      readonly zone: DomainName;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Disabled" | "Enabled"]>>;
+      readonly _tag: "Token";
+      readonly parameters?: Readonly<Record<string, string>>;
+      readonly token: string;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["OAuth" | "Token"]>>;
   };
-  readonly Disabled: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Disabled";
+  readonly OAuth: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "OAuth";
   }, "_tag">;
-  readonly Enabled: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Enabled";
-    readonly provider: AsyncInterface;
-    readonly zone: DomainName;
+  readonly Token: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Token";
+    readonly parameters?: Readonly<Record<string, string>>;
+    readonly token: string;
   }, "_tag">;
 };
-interface Config {
-  readonly provider?: Provider;
-  readonly publicDns?: PublicDns;
-  readonly record: DnsRecord;
-  readonly resolvers?: ReadonlyArray<Entry>;
+declare const Provider: Schema.Struct<{
+  readonly authentication: Schema.$Array<Schema.TaggedUnion<{
+    readonly OAuth: Schema.TaggedStruct<"OAuth", {
+      readonly label: Schema.String;
+    }>;
+    readonly Token: Schema.TaggedStruct<"Token", {
+      readonly label: Schema.String;
+      readonly parameters: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly key: Schema.String;
+        readonly label: Schema.String;
+        readonly placeholder: Schema.optionalKey<Schema.String>;
+        readonly required: Schema.optionalKey<Schema.Boolean>;
+      }>>>;
+      readonly placeholder: Schema.optionalKey<Schema.String>;
+    }>;
+  }>>;
+  readonly id: Schema.String;
+  readonly name: Schema.String;
+}>;
+type Provider = typeof Provider.Type;
+declare const Connected: Schema.TaggedStruct<"Connected", {
+  readonly connectionId: Schema.String;
+  readonly domain: Schema.String;
+  readonly provider: Schema.Struct<{
+    readonly authentication: Schema.$Array<Schema.TaggedUnion<{
+      readonly OAuth: Schema.TaggedStruct<"OAuth", {
+        readonly label: Schema.String;
+      }>;
+      readonly Token: Schema.TaggedStruct<"Token", {
+        readonly label: Schema.String;
+        readonly parameters: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+          readonly description: Schema.optionalKey<Schema.String>;
+          readonly key: Schema.String;
+          readonly label: Schema.String;
+          readonly placeholder: Schema.optionalKey<Schema.String>;
+          readonly required: Schema.optionalKey<Schema.Boolean>;
+        }>>>;
+        readonly placeholder: Schema.optionalKey<Schema.String>;
+      }>;
+    }>>;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+  }>;
+}>;
+type Connected = typeof Connected.Type;
+declare const ReusableConnection: Schema.Struct<{
+  readonly connectionId: Schema.String;
+  readonly label: Schema.String;
+}>;
+type ReusableConnection = typeof ReusableConnection.Type;
+declare const Disconnected: Schema.TaggedStruct<"Disconnected", {
+  readonly domain: Schema.String;
+  readonly provider: Schema.Struct<{
+    readonly authentication: Schema.$Array<Schema.TaggedUnion<{
+      readonly OAuth: Schema.TaggedStruct<"OAuth", {
+        readonly label: Schema.String;
+      }>;
+      readonly Token: Schema.TaggedStruct<"Token", {
+        readonly label: Schema.String;
+        readonly parameters: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+          readonly description: Schema.optionalKey<Schema.String>;
+          readonly key: Schema.String;
+          readonly label: Schema.String;
+          readonly placeholder: Schema.optionalKey<Schema.String>;
+          readonly required: Schema.optionalKey<Schema.Boolean>;
+        }>>>;
+        readonly placeholder: Schema.optionalKey<Schema.String>;
+      }>;
+    }>>;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+  }>;
+  readonly reusableConnection: Schema.optionalKey<Schema.Struct<{
+    readonly connectionId: Schema.String;
+    readonly label: Schema.String;
+  }>>;
+}>;
+type Disconnected = typeof Disconnected.Type;
+declare const Unsupported: Schema.TaggedStruct<"Unsupported", {
+  readonly domain: Schema.String;
+}>;
+type Unsupported = typeof Unsupported.Type;
+declare const ConnectionSnapshot: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Connected", {
+  readonly connectionId: Schema.String;
+  readonly domain: Schema.String;
+  readonly provider: Schema.Struct<{
+    readonly authentication: Schema.$Array<Schema.TaggedUnion<{
+      readonly OAuth: Schema.TaggedStruct<"OAuth", {
+        readonly label: Schema.String;
+      }>;
+      readonly Token: Schema.TaggedStruct<"Token", {
+        readonly label: Schema.String;
+        readonly parameters: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+          readonly description: Schema.optionalKey<Schema.String>;
+          readonly key: Schema.String;
+          readonly label: Schema.String;
+          readonly placeholder: Schema.optionalKey<Schema.String>;
+          readonly required: Schema.optionalKey<Schema.Boolean>;
+        }>>>;
+        readonly placeholder: Schema.optionalKey<Schema.String>;
+      }>;
+    }>>;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+  }>;
+}>, Schema.TaggedStruct<"Disconnected", {
+  readonly domain: Schema.String;
+  readonly provider: Schema.Struct<{
+    readonly authentication: Schema.$Array<Schema.TaggedUnion<{
+      readonly OAuth: Schema.TaggedStruct<"OAuth", {
+        readonly label: Schema.String;
+      }>;
+      readonly Token: Schema.TaggedStruct<"Token", {
+        readonly label: Schema.String;
+        readonly parameters: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+          readonly description: Schema.optionalKey<Schema.String>;
+          readonly key: Schema.String;
+          readonly label: Schema.String;
+          readonly placeholder: Schema.optionalKey<Schema.String>;
+          readonly required: Schema.optionalKey<Schema.Boolean>;
+        }>>>;
+        readonly placeholder: Schema.optionalKey<Schema.String>;
+      }>;
+    }>>;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+  }>;
+  readonly reusableConnection: Schema.optionalKey<Schema.Struct<{
+    readonly connectionId: Schema.String;
+    readonly label: Schema.String;
+  }>>;
+}>, Schema.TaggedStruct<"Unsupported", {
+  readonly domain: Schema.String;
+}>]>;
+type ConnectionSnapshot = typeof ConnectionSnapshot.Type;
+declare const Redirect: Schema.TaggedStruct<"Redirect", {
+  readonly authorizationUrl: Schema.String;
+}>;
+type Redirect = typeof Redirect.Type;
+declare const ConnectionResult: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Connected", {
+  readonly connectionId: Schema.String;
+  readonly domain: Schema.String;
+  readonly provider: Schema.Struct<{
+    readonly authentication: Schema.$Array<Schema.TaggedUnion<{
+      readonly OAuth: Schema.TaggedStruct<"OAuth", {
+        readonly label: Schema.String;
+      }>;
+      readonly Token: Schema.TaggedStruct<"Token", {
+        readonly label: Schema.String;
+        readonly parameters: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+          readonly description: Schema.optionalKey<Schema.String>;
+          readonly key: Schema.String;
+          readonly label: Schema.String;
+          readonly placeholder: Schema.optionalKey<Schema.String>;
+          readonly required: Schema.optionalKey<Schema.Boolean>;
+        }>>>;
+        readonly placeholder: Schema.optionalKey<Schema.String>;
+      }>;
+    }>>;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+  }>;
+}>, Schema.TaggedStruct<"Redirect", {
+  readonly authorizationUrl: Schema.String;
+}>]>;
+type ConnectionResult = typeof ConnectionResult.Type;
+declare const RemoveDomainResult: Schema.TaggedStruct<"Removed", {
+  readonly connectionId: Schema.String;
+  readonly domain: Schema.String;
+  readonly remainingDomainCount: Schema.Int;
+}>;
+type RemoveDomainResult = typeof RemoveDomainResult.Type;
+/** A presentation projection of a DNS requirement. */
+declare const DnsRecord: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly name: Schema.String;
+  readonly priority: Schema.optionalKey<Schema.Int>;
+  readonly type: Schema.String;
+  readonly value: Schema.String;
+}>;
+type DnsRecord = typeof DnsRecord.Type;
+/** Projects DomainKit's operational record into its application transport representation. */
+declare const fromDnsRecord: (id: string, record: DnsRecord$1) => DnsRecord;
+declare const PlanOperation: Schema.TaggedUnion<{
+  readonly Conflict: Schema.TaggedStruct<"Conflict", {
+    readonly id: Schema.String;
+    readonly reason: Schema.String;
+    readonly record: Schema.Struct<{
+      readonly id: Schema.String;
+      readonly name: Schema.String;
+      readonly priority: Schema.optionalKey<Schema.Int>;
+      readonly type: Schema.String;
+      readonly value: Schema.String;
+    }>;
+  }>;
+  readonly Create: Schema.TaggedStruct<"Create", {
+    readonly id: Schema.String;
+    readonly record: Schema.Struct<{
+      readonly id: Schema.String;
+      readonly name: Schema.String;
+      readonly priority: Schema.optionalKey<Schema.Int>;
+      readonly type: Schema.String;
+      readonly value: Schema.String;
+    }>;
+  }>;
+  readonly Noop: Schema.TaggedStruct<"Noop", {
+    readonly id: Schema.String;
+    readonly record: Schema.Struct<{
+      readonly id: Schema.String;
+      readonly name: Schema.String;
+      readonly priority: Schema.optionalKey<Schema.Int>;
+      readonly type: Schema.String;
+      readonly value: Schema.String;
+    }>;
+  }>;
+}>;
+type PlanOperation = typeof PlanOperation.Type;
+declare const ProvisioningPlan: Schema.TaggedStruct<"Plan", {
+  readonly digest: Schema.String;
+  readonly expiresAt: Schema.String;
+  readonly operations: Schema.$Array<Schema.TaggedUnion<{
+    readonly Conflict: Schema.TaggedStruct<"Conflict", {
+      readonly id: Schema.String;
+      readonly reason: Schema.String;
+      readonly record: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly priority: Schema.optionalKey<Schema.Int>;
+        readonly type: Schema.String;
+        readonly value: Schema.String;
+      }>;
+    }>;
+    readonly Create: Schema.TaggedStruct<"Create", {
+      readonly id: Schema.String;
+      readonly record: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly priority: Schema.optionalKey<Schema.Int>;
+        readonly type: Schema.String;
+        readonly value: Schema.String;
+      }>;
+    }>;
+    readonly Noop: Schema.TaggedStruct<"Noop", {
+      readonly id: Schema.String;
+      readonly record: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly priority: Schema.optionalKey<Schema.Int>;
+        readonly type: Schema.String;
+        readonly value: Schema.String;
+      }>;
+    }>;
+  }>>;
+}>;
+type ProvisioningPlan = typeof ProvisioningPlan.Type;
+declare const OperationResult: Schema.TaggedUnion<{
+  readonly Applied: Schema.TaggedStruct<"Applied", {
+    readonly operationId: Schema.String;
+  }>;
+  readonly Failed: Schema.TaggedStruct<"Failed", {
+    readonly message: Schema.String;
+    readonly operationId: Schema.String;
+  }>;
+  readonly Unchanged: Schema.TaggedStruct<"Unchanged", {
+    readonly operationId: Schema.String;
+  }>;
+}>;
+type OperationResult = typeof OperationResult.Type;
+declare const ApplyResult: Schema.TaggedUnion<{
+  readonly Applied: Schema.TaggedStruct<"Applied", {
+    operationId: Schema.String;
+    receiptId: Schema.String;
+    results: Schema.$Array<Schema.TaggedUnion<{
+      readonly Applied: Schema.TaggedStruct<"Applied", {
+        readonly operationId: Schema.String;
+      }>;
+      readonly Failed: Schema.TaggedStruct<"Failed", {
+        readonly message: Schema.String;
+        readonly operationId: Schema.String;
+      }>;
+      readonly Unchanged: Schema.TaggedStruct<"Unchanged", {
+        readonly operationId: Schema.String;
+      }>;
+    }>>;
+  }>;
+  readonly Partial: Schema.TaggedStruct<"Partial", {
+    operationId: Schema.String;
+    receiptId: Schema.String;
+    results: Schema.$Array<Schema.TaggedUnion<{
+      readonly Applied: Schema.TaggedStruct<"Applied", {
+        readonly operationId: Schema.String;
+      }>;
+      readonly Failed: Schema.TaggedStruct<"Failed", {
+        readonly message: Schema.String;
+        readonly operationId: Schema.String;
+      }>;
+      readonly Unchanged: Schema.TaggedStruct<"Unchanged", {
+        readonly operationId: Schema.String;
+      }>;
+    }>>;
+  }>;
+  readonly Stale: Schema.TaggedStruct<"Stale", {
+    readonly message: Schema.String;
+  }>;
+}>;
+type ApplyResult = typeof ApplyResult.Type;
+declare const ObservationEvidence: Schema.TaggedUnion<{
+  readonly Found: Schema.TaggedStruct<"Found", {
+    readonly recordId: Schema.String;
+  }>;
+  readonly Mismatch: Schema.TaggedStruct<"Mismatch", {
+    readonly message: Schema.String;
+    readonly recordId: Schema.String;
+  }>;
+  readonly Missing: Schema.TaggedStruct<"Missing", {
+    readonly recordId: Schema.String;
+  }>;
+  readonly Unavailable: Schema.TaggedStruct<"Unavailable", {
+    readonly message: Schema.String;
+    readonly recordId: Schema.String;
+  }>;
+}>;
+type ObservationEvidence = typeof ObservationEvidence.Type;
+declare const Observation: Schema.TaggedStruct<"Observation", {
+  readonly provider: Schema.$Array<Schema.TaggedUnion<{
+    readonly Found: Schema.TaggedStruct<"Found", {
+      readonly recordId: Schema.String;
+    }>;
+    readonly Mismatch: Schema.TaggedStruct<"Mismatch", {
+      readonly message: Schema.String;
+      readonly recordId: Schema.String;
+    }>;
+    readonly Missing: Schema.TaggedStruct<"Missing", {
+      readonly recordId: Schema.String;
+    }>;
+    readonly Unavailable: Schema.TaggedStruct<"Unavailable", {
+      readonly message: Schema.String;
+      readonly recordId: Schema.String;
+    }>;
+  }>>;
+  readonly publicDns: Schema.$Array<Schema.TaggedUnion<{
+    readonly Found: Schema.TaggedStruct<"Found", {
+      readonly recordId: Schema.String;
+    }>;
+    readonly Mismatch: Schema.TaggedStruct<"Mismatch", {
+      readonly message: Schema.String;
+      readonly recordId: Schema.String;
+    }>;
+    readonly Missing: Schema.TaggedStruct<"Missing", {
+      readonly recordId: Schema.String;
+    }>;
+    readonly Unavailable: Schema.TaggedStruct<"Unavailable", {
+      readonly message: Schema.String;
+      readonly recordId: Schema.String;
+    }>;
+  }>>;
+}>;
+type Observation = typeof Observation.Type;
+declare const CleanupOperation: Schema.TaggedUnion<{
+  readonly AlreadyAbsent: Schema.TaggedStruct<"AlreadyAbsent", {
+    readonly id: Schema.String;
+    readonly record: Schema.Struct<{
+      readonly id: Schema.String;
+      readonly name: Schema.String;
+      readonly priority: Schema.optionalKey<Schema.Int>;
+      readonly type: Schema.String;
+      readonly value: Schema.String;
+    }>;
+  }>;
+  readonly Blocked: Schema.TaggedStruct<"Blocked", {
+    readonly id: Schema.String;
+    readonly reason: Schema.String;
+    readonly record: Schema.Struct<{
+      readonly id: Schema.String;
+      readonly name: Schema.String;
+      readonly priority: Schema.optionalKey<Schema.Int>;
+      readonly type: Schema.String;
+      readonly value: Schema.String;
+    }>;
+  }>;
+  readonly Delete: Schema.TaggedStruct<"Delete", {
+    readonly id: Schema.String;
+    readonly record: Schema.Struct<{
+      readonly id: Schema.String;
+      readonly name: Schema.String;
+      readonly priority: Schema.optionalKey<Schema.Int>;
+      readonly type: Schema.String;
+      readonly value: Schema.String;
+    }>;
+  }>;
+}>;
+type CleanupOperation = typeof CleanupOperation.Type;
+declare const CleanupPlan: Schema.TaggedStruct<"CleanupPlan", {
+  readonly digest: Schema.String;
+  readonly expiresAt: Schema.String;
+  readonly operations: Schema.$Array<Schema.TaggedUnion<{
+    readonly AlreadyAbsent: Schema.TaggedStruct<"AlreadyAbsent", {
+      readonly id: Schema.String;
+      readonly record: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly priority: Schema.optionalKey<Schema.Int>;
+        readonly type: Schema.String;
+        readonly value: Schema.String;
+      }>;
+    }>;
+    readonly Blocked: Schema.TaggedStruct<"Blocked", {
+      readonly id: Schema.String;
+      readonly reason: Schema.String;
+      readonly record: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly priority: Schema.optionalKey<Schema.Int>;
+        readonly type: Schema.String;
+        readonly value: Schema.String;
+      }>;
+    }>;
+    readonly Delete: Schema.TaggedStruct<"Delete", {
+      readonly id: Schema.String;
+      readonly record: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly priority: Schema.optionalKey<Schema.Int>;
+        readonly type: Schema.String;
+        readonly value: Schema.String;
+      }>;
+    }>;
+  }>>;
+}>;
+type CleanupPlan = typeof CleanupPlan.Type;
+declare const CleanupResult: Schema.TaggedUnion<{
+  readonly Cleaned: Schema.TaggedStruct<"Cleaned", {
+    operationId: Schema.String;
+    results: Schema.$Array<Schema.TaggedUnion<{
+      readonly Applied: Schema.TaggedStruct<"Applied", {
+        readonly operationId: Schema.String;
+      }>;
+      readonly Failed: Schema.TaggedStruct<"Failed", {
+        readonly message: Schema.String;
+        readonly operationId: Schema.String;
+      }>;
+      readonly Unchanged: Schema.TaggedStruct<"Unchanged", {
+        readonly operationId: Schema.String;
+      }>;
+    }>>;
+  }>;
+  readonly Partial: Schema.TaggedStruct<"Partial", {
+    operationId: Schema.String;
+    results: Schema.$Array<Schema.TaggedUnion<{
+      readonly Applied: Schema.TaggedStruct<"Applied", {
+        readonly operationId: Schema.String;
+      }>;
+      readonly Failed: Schema.TaggedStruct<"Failed", {
+        readonly message: Schema.String;
+        readonly operationId: Schema.String;
+      }>;
+      readonly Unchanged: Schema.TaggedStruct<"Unchanged", {
+        readonly operationId: Schema.String;
+      }>;
+    }>>;
+  }>;
+  readonly Stale: Schema.TaggedStruct<"Stale", {
+    readonly message: Schema.String;
+  }>;
+}>;
+type CleanupResult = typeof CleanupResult.Type;
+interface ConnectInput {
+  readonly domain: string;
+  readonly method: Method;
+  readonly providerId: string;
+}
+interface InspectInput {
+  readonly domain: string;
+}
+interface ReuseInput {
+  readonly connectionId: string;
+  readonly domain: string;
+}
+interface RemoveDomainInput extends ReuseInput {
+  readonly preserveDns: true;
+}
+interface ProvisioningPlanInput extends ReuseInput {
+  readonly records: ReadonlyArray<DnsRecord>;
+}
+interface ProvisioningApplyInput extends ReuseInput {
+  readonly planDigest: string;
+}
+interface ObserveInput {
+  readonly connectionId?: string;
+  readonly domain: string;
+  readonly records: ReadonlyArray<DnsRecord>;
+  readonly sources: {
+    readonly provider: boolean;
+    readonly publicDns: boolean;
+  };
+}
+interface CleanupPlanInput extends ReuseInput {
+  readonly receiptId: string;
 }
-declare function observe(input: Config): Promise<Result>;
-declare namespace cloudflare_doh_d_exports {
-  export { Options$2 as Options, make$2 as make };
+interface CleanupApplyInput extends CleanupPlanInput {
+  readonly planDigest: string;
+}
+/** Application-facing DNS connection and provisioning capability. */
+interface Interface {
+  readonly cleanup: {
+    readonly apply: (input: CleanupApplyInput) => Effect.Effect<CleanupResult, Failure>;
+    readonly plan: (input: CleanupPlanInput) => Effect.Effect<CleanupPlan, Failure>;
+  };
+  readonly connection: {
+    readonly connect: (input: ConnectInput) => Effect.Effect<ConnectionResult, Failure>;
+    readonly inspect: (input: InspectInput) => Effect.Effect<ConnectionSnapshot, Failure>;
+    readonly removeDomain: (input: RemoveDomainInput) => Effect.Effect<RemoveDomainResult, Failure>;
+    readonly reuse: (input: ReuseInput) => Effect.Effect<Connected, Failure>;
+  };
+  readonly provisioning: {
+    readonly apply: (input: ProvisioningApplyInput) => Effect.Effect<ApplyResult, Failure>;
+    readonly plan: (input: ProvisioningPlanInput) => Effect.Effect<ProvisioningPlan, Failure>;
+  };
+  readonly verification: {
+    readonly observe: (input: ObserveInput) => Effect.Effect<Observation, Failure>;
+  };
+}
+declare const Service_base: Context.ServiceClass<Service, "@domainkit/Transport", Interface>;
+declare class Service extends Service_base {}
+/** Promise-shaped host seam for foreign runtimes and framework actions. */
+interface AsyncInterface {
+  readonly cleanup: {
+    readonly apply: (input: CleanupApplyInput) => Promise<CleanupResult>;
+    readonly plan: (input: CleanupPlanInput) => Promise<CleanupPlan>;
+  };
+  readonly connection: {
+    readonly connect: (input: ConnectInput) => Promise<ConnectionResult>;
+    readonly inspect: (input: InspectInput) => Promise<ConnectionSnapshot>;
+    readonly removeDomain: (input: RemoveDomainInput) => Promise<RemoveDomainResult>;
+    readonly reuse: (input: ReuseInput) => Promise<Connected>;
+  };
+  readonly provisioning: {
+    readonly apply: (input: ProvisioningApplyInput) => Promise<ApplyResult>;
+    readonly plan: (input: ProvisioningPlanInput) => Promise<ProvisioningPlan>;
+  };
+  readonly verification: {
+    readonly observe: (input: ObserveInput) => Promise<Observation>;
+  };
 }
-type Options$2 = Options$3;
-declare function make$2(options?: Options$2): AsyncInterface$1;
-declare namespace doh_d_exports {
-  export { Options$1 as Options, make$1 as make };
+interface AsyncOptions {
+  readonly onError?: (operation: string, cause: unknown) => Failure;
 }
-type Options$1 = Options$4;
-declare function make$1(options: Options$1): AsyncInterface$1;
-declare namespace google_doh_d_exports {
-  export { Options, make };
+/** Converts a Promise-shaped host implementation into the canonical Effect service. */
+declare const fromAsync: (transport: AsyncInterface, options?: AsyncOptions) => Interface;
+declare const layerFromAsync: (transport: AsyncInterface, options?: AsyncOptions) => Layer.Layer<Service>;
+/** Converts an environment-free Effect service into its Promise-shaped host seam. */
+declare const toAsync: (transport: Interface) => AsyncInterface;
+declare namespace dns_data_d_exports {
+  export { parse };
 }
-type Options = Options$5;
-declare function make(options?: Options): AsyncInterface$1;
+declare function parse(type: Type, input: unknown): string;
 //#endregion
 //#region src/index.d.ts
 /** The current package version from the package manifest. */
 declare const VERSION: string;
 //#endregion
-export { authorization_lifecycle_d_exports as AuthorizationLifecycle, cloudflare_d_exports as Cloudflare, cloudflare_doh_d_exports as CloudflareDnsOverHttps, connection_d_exports as Connection, deletion_d_exports as Deletion, diagnostic_d_exports as Diagnostic, doh_d_exports as DnsOverHttps, dns_plan_d_exports as DnsPlan, type dns_provider_d_exports as DnsProvider, dns_record_d_exports as DnsRecord, type dns_resolver_d_exports as DnsResolver, resolver_pool_d_exports as DnsResolverPool, domain_name_d_exports as DomainName, google_doh_d_exports as GoogleDnsOverHttps, invalid_input_d_exports as InvalidInput, provider_auth_d_exports as ProviderAuth, provider_authorization_d_exports as ProviderAuthorization, provider_context_d_exports as ProviderContext, selection_d_exports as ProviderDiscovery, provisioning_d_exports as Provisioning, secret_d_exports as Secret, VERSION, vercel_d_exports as Vercel, verification_d_exports as Verification, zone_discovery_d_exports as ZoneDiscovery, zones_d_exports as Zones };
+export { lifecycle_repository_d_exports as AuthorizationLifecycle, index_d_exports as Cloudflare, cloudflare_doh_d_exports as CloudflareDnsOverHttps, connection_api_d_exports as Connection, connection_authorization_d_exports as ConnectionAuthorization, deletion_d_exports as Deletion, diagnostic_d_exports as Diagnostic, canonical_json_d_exports as Digest, dns_data_d_exports as DnsData, doh_d_exports as DnsOverHttps, types_d_exports as DnsPlan, provider_d_exports as DnsProvider, dns_record_d_exports as DnsRecord, resolver_d_exports as DnsResolver, resolver_pool_d_exports as DnsResolverPool, domain_name_d_exports as DomainName, google_doh_d_exports as GoogleDnsOverHttps, invalid_input_d_exports as InvalidInput, manifest_d_exports as ProviderAuth, authorization_d_exports as ProviderAuthorization, provider_context_d_exports as ProviderContext, selection_d_exports as ProviderDiscovery, plan_d_exports as Provisioning, secret_d_exports as Secret, transport_d_exports as Transport, VERSION, index_d_exports$1 as Vercel, verify_d_exports as Verification, zone_discovery_d_exports as ZoneDiscovery, zones_d_exports as Zones };
 //# sourceMappingURL=index.d.mts.map