domainkit 0.0.1 → 0.1.0-beta.0

package/dist/verify-DPB1OfZ5.d.mts

@@ -0,0 +1,979 @@
+import { C as DnsRecord, H as Error, R as DomainName, _ as Service, a as OAuthClientConfiguration, d as Value, h as Error$1, o as OAuthMethod, w as Encoded } from "./manifest-DjH3BVB9.mjs";
+import { A as Service$3, B as Connection, E as Service$1, I as Error$2, P as Service$2, R as AuthorizationError$1, V as Grant, a as Interface, c as Service$4, g as DnsPlan, m as ApplyReceipt, n as AsyncInterface, v as PlanAuthorization } from "./resolver-BjZwN2JE.mjs";
+import { Cause, Crypto, Effect, Layer, Schema } from "effect";
+import * as oauth from "oauth4webapi";
+declare namespace canonical_json_d_exports {
+  export { CryptoError, Json, sha256Encoded, sha256Json, sha256Text, stringify, webCryptoLayer };
+}
+declare const CryptoError_base: Schema.Class<CryptoError, Schema.TaggedStruct<"CryptoError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class CryptoError extends CryptoError_base {}
+type Json = null | boolean | number | string | ReadonlyArray<Json> | {
+  readonly [key: string]: Json;
+};
+/** Deterministic JSON serialization for already schema-encoded protocol values. */
+declare function stringify(value: Json): string;
+declare const sha256Text: (value: string) => Effect.Effect<string, CryptoError, Crypto.Crypto>;
+declare const sha256Json: (value: Json) => Effect.Effect<string, CryptoError, Crypto.Crypto>;
+declare const sha256Encoded: <S extends Schema.Constraint>(schema: S, value: S["Type"]) => Effect.Effect<string, CryptoError, Crypto.Crypto | S["EncodingServices"]>;
+/** Portable Web Crypto implementation for hosts that want a ready-made Layer. */
+declare const webCryptoLayer: Layer.Layer<Crypto.Crypto>;
+declare namespace oauth_d_exports {
+  export { BeginInput, Fetch$1 as Fetch, OAuthError, OAuthSubjectResolver, begin, complete, refresh, revoke };
+}
+type Fetch$1 = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+interface BeginInput {
+  readonly client: OAuthClientConfiguration;
+  readonly grant: Grant;
+  readonly method: OAuthMethod;
+  readonly redirectUri: string;
+  readonly subjectId: string;
+  readonly ttlMs?: number;
+}
+interface OAuthSubjectResolver {
+  (tokens: oauth.TokenEndpointResponse, accessToken: Value): Effect.Effect<{
+    readonly accountId: string;
+    readonly expiresAt: Date | null;
+  }, Error | Error$1>;
+}
+type OAuthError = AuthorizationError$1 | CryptoError | Error | Error$1 | Error$2;
+declare const begin: (input: BeginInput) => Effect.Effect<{
+  readonly authorizationUrl: URL;
+}, CryptoError | Error$2, Crypto.Crypto | Service$1>;
+declare const complete: (input: {
+  readonly callbackUrl: URL;
+  readonly client: OAuthClientConfiguration;
+  readonly fetch?: Fetch$1;
+  readonly providerId: string;
+  readonly resolveSubject: OAuthSubjectResolver;
+}) => Effect.Effect<Connection, OAuthError, Crypto.Crypto | Service$2 | Service$3 | Service$1>;
+declare const refresh: (input: {
+  readonly client: OAuthClientConfiguration;
+  readonly connection: Connection;
+  readonly fetch?: Fetch$1;
+  readonly method: OAuthMethod;
+}) => Effect.Effect<void, OAuthError, Service$3>;
+declare const revoke: (input: {
+  readonly client: OAuthClientConfiguration;
+  readonly connection: Connection;
+  readonly fetch?: Fetch$1;
+  readonly method: OAuthMethod;
+}) => Effect.Effect<void, OAuthError, Service$3>;
+declare namespace selection_d_exports {
+  export { ConnectedZone, Evidence, Selection, select };
+}
+interface ConnectedZone {
+  readonly accountId: string;
+  readonly connection: Connection;
+  readonly nameservers: ReadonlyArray<string>;
+  readonly providerId: string;
+  readonly zone: string;
+}
+declare const Evidence: Schema.Struct<{
+  readonly accountId: Schema.String;
+  readonly connectionId: Schema.String;
+  readonly decisiveNameserverMatch: Schema.Boolean;
+  readonly matchedNameservers: Schema.$Array<Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>>;
+  readonly providerId: Schema.String;
+  readonly zone: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+}>;
+interface Evidence extends Schema.Schema.Type<typeof Evidence> {}
+declare const Selection: Schema.TaggedUnion<{
+  readonly manual: Schema.TaggedStruct<"manual", {
+    readonly evidence: Schema.$Array<Schema.Struct<{
+      readonly accountId: Schema.String;
+      readonly connectionId: Schema.String;
+      readonly decisiveNameserverMatch: Schema.Boolean;
+      readonly matchedNameservers: Schema.$Array<Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>>;
+      readonly providerId: Schema.String;
+      readonly zone: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    }>>;
+    readonly reason: Schema.Literals<readonly ["ambiguous", "unsupported"]>;
+  }>;
+  readonly selected: Schema.TaggedStruct<"selected", {
+    readonly candidate: Schema.Struct<{
+      readonly accountId: Schema.String;
+      readonly connectionId: Schema.String;
+      readonly decisiveNameserverMatch: Schema.Boolean;
+      readonly matchedNameservers: Schema.$Array<Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>>;
+      readonly providerId: Schema.String;
+      readonly zone: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    }>;
+    readonly evidence: Schema.$Array<Schema.Struct<{
+      readonly accountId: Schema.String;
+      readonly connectionId: Schema.String;
+      readonly decisiveNameserverMatch: Schema.Boolean;
+      readonly matchedNameservers: Schema.$Array<Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>>;
+      readonly providerId: Schema.String;
+      readonly zone: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+    }>>;
+    readonly reason: Schema.Literals<readonly ["explicit", "unique-nameserver-match"]>;
+  }>;
+}>;
+type Selection = typeof Selection.Type;
+declare function select(input: {
+  readonly authoritativeNameservers: ReadonlyArray<string>;
+  readonly connectedZones: ReadonlyArray<ConnectedZone>;
+  readonly domain: string;
+  readonly explicit?: {
+    readonly accountId: string;
+    readonly providerId: string;
+    readonly zone: string;
+  };
+  readonly now?: Date;
+}): Selection;
+declare namespace zones_d_exports {
+  export { candidates };
+}
+declare function candidates(input: string): ReadonlyArray<DomainName>;
+declare namespace plan_d_exports {
+  export { ApplyError, ApplyInput, AuthorizationError, AuthorizeError, ConflictError, CreateError, CreateInput, PartialApplyError, StaleError, apply, authorize, create, renderManualInstructions };
+}
+declare const ConflictError_base: Schema.Class<ConflictError, Schema.TaggedStruct<"PlanConflictError", {
+  readonly operationIds: Schema.$Array<Schema.String>;
+}>, Cause.YieldableError>;
+declare class ConflictError extends ConflictError_base {}
+declare const AuthorizationError_base: Schema.Class<AuthorizationError, Schema.TaggedStruct<"AuthorizationError", {
+  readonly message: Schema.String;
+}>, Cause.YieldableError>;
+declare class AuthorizationError extends AuthorizationError_base {}
+declare const StaleError_base: Schema.Class<StaleError, Schema.TaggedStruct<"StalePlanError", {
+  readonly approvedPlanDigest: Schema.String;
+  readonly currentPlanDigest: Schema.String;
+}>, Cause.YieldableError>;
+declare class StaleError extends StaleError_base {}
+declare const PartialApplyError_base: Schema.Class<PartialApplyError, Schema.TaggedStruct<"PartialApplyError", {
+  readonly causeTag: Schema.Literals<readonly ["CryptoError", "InvalidInputError", "Interrupted", "ProviderError", "StalePlanError"]>;
+  readonly failedOperationId: Schema.String;
+  readonly message: Schema.String;
+  readonly receipt: Schema.Struct<{
+    readonly appliedAt: Schema.DateFromString;
+    readonly operations: Schema.$Array<Schema.Struct<{
+      readonly operationId: Schema.String;
+      readonly providerRecordId: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly planDigest: Schema.String;
+    readonly providerId: Schema.String;
+    readonly status: Schema.Literals<readonly ["complete", "partial"]>;
+    readonly version: Schema.Literal<"domainkit.apply-receipt.v1">;
+    readonly zone: Schema.decodeTo<Schema.brand<Schema.String, "DomainName">, Schema.String, never, never>;
+  }>;
+}>, Cause.YieldableError>;
+declare class PartialApplyError extends PartialApplyError_base {}
+interface CreateInput {
+  readonly requirements: ReadonlyArray<Encoded | DnsRecord>;
+  readonly zone: string;
+}
+interface ApplyInput {
+  readonly authorization: PlanAuthorization;
+  readonly plan: DnsPlan;
+}
+type CreateError = Error | Error$1 | CryptoError;
+type AuthorizeError = AuthorizationError | CryptoError;
+type ApplyError = Error | Error$1 | CryptoError | AuthorizationError | ConflictError | StaleError | PartialApplyError;
+/** Builds a deterministic DNS plan through the provider in the Effect environment. */
+declare const create: (input: CreateInput) => Effect.Effect<{
+  operations: readonly ({
+    readonly _tag: "conflict";
+    readonly existing: readonly ({
+      readonly _tag: "Opaque";
+      readonly name: string;
+      readonly providerRecordId: string | null;
+      readonly providerType: string;
+    } | {
+      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;
+    } | {
+      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;
+    } | {
+      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;
+    } | {
+      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">;
+    } | {
+      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;
+    } | {
+      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">;
+    } | {
+      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;
+    } | {
+      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;
+    })[];
+    readonly id: string;
+    readonly reason: string;
+    readonly requirement: {
+      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;
+    } | {
+      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;
+    } | {
+      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;
+    } | {
+      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">;
+    } | {
+      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;
+    } | {
+      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">;
+    } | {
+      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;
+    } | {
+      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;
+    };
+  } | {
+    readonly _tag: "create";
+    readonly id: string;
+    readonly requirement: {
+      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;
+    } | {
+      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;
+    } | {
+      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;
+    } | {
+      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">;
+    } | {
+      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;
+    } | {
+      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">;
+    } | {
+      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;
+    } | {
+      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;
+    };
+  } | {
+    readonly _tag: "noop";
+    readonly id: string;
+    readonly requirement: {
+      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;
+    } | {
+      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;
+    } | {
+      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;
+    } | {
+      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">;
+    } | {
+      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;
+    } | {
+      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">;
+    } | {
+      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;
+    } | {
+      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;
+    };
+    readonly ttlDrift: boolean;
+  })[];
+  providerId: string;
+  version: "domainkit.dns-plan.v1";
+  zone: string & import("effect/Brand").Brand<"DomainName">;
+  digest: string;
+}, CryptoError | Error | Error$1, Crypto.Crypto | Service>;
+/** Authorizes all or a selected subset of create operations in a digest-bound plan. */
+declare const authorize: (plan: DnsPlan, operationIds?: readonly string[] | undefined, options?: {
+  readonly allowPartial?: boolean;
+} | undefined) => Effect.Effect<{
+  allowPartial: boolean;
+  operationIds: string[];
+  planDigest: string;
+  version: "domainkit.plan-authorization.v1";
+}, AuthorizeError, Crypto.Crypto>;
+/** Applies approved creates sequentially after full and per-operation revalidation. */
+declare const apply: (input: ApplyInput) => Effect.Effect<ApplyReceipt, AuthorizationError | ConflictError | CryptoError | Error | Error$1 | PartialApplyError | StaleError, Crypto.Crypto | Service>;
+declare function renderManualInstructions(plan: DnsPlan): ReadonlyArray<string>;
+declare namespace doh_d_exports {
+  export { Fetch, Options$1 as Options, layer$1 as layer, make$1 as make, toAsync$1 as toAsync };
+}
+type Fetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+interface Options$1 {
+  readonly endpoint: string;
+  readonly fetch?: Fetch;
+  readonly timeoutMs?: number;
+}
+declare function make$1(options: Options$1): Interface;
+declare const layer$1: (options: Options$1) => Layer.Layer<Service$4>;
+declare const toAsync$1: (options: Options$1) => AsyncInterface;
+declare namespace cloudflare_doh_d_exports {
+  export { Options, layer, make, toAsync };
+}
+interface Options extends Omit<Options$1, "endpoint"> {
+  readonly endpoint?: string;
+}
+declare function make(options?: Options): Interface;
+declare const layer: (options?: Options) => Layer.Layer<Service$4>;
+declare const toAsync: (options?: Options) => AsyncInterface;
+declare namespace verify_d_exports {
+  export { ProviderObservation, PublicDnsObservation, Result, record };
+}
+declare const ProviderObservation: Schema.TaggedUnion<{
+  readonly failure: Schema.TaggedStruct<"failure", {
+    readonly message: Schema.String;
+  }>;
+  readonly match: Schema.TaggedStruct<"match", {}>;
+  readonly mismatch: Schema.TaggedStruct<"mismatch", {
+    readonly records: Schema.$Array<Schema.TaggedUnion<{
+      readonly A: 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 AAAA: 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 CAA: 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 CNAME: 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 MX: 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 NS: 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 SRV: 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 TXT: 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 missing: Schema.TaggedStruct<"missing", {}>;
+}>;
+type ProviderObservation = typeof ProviderObservation.Type;
+declare const PublicDnsObservation: Schema.TaggedUnion<{
+  readonly failure: Schema.TaggedStruct<"failure", {
+    readonly message: Schema.String;
+  }>;
+  readonly mismatch: Schema.TaggedStruct<"mismatch", {
+    readonly answers: Schema.$Array<Schema.String>;
+  }>;
+  readonly missing: Schema.TaggedStruct<"missing", {}>;
+  readonly propagated: Schema.TaggedStruct<"propagated", {}>;
+  readonly timeout: Schema.TaggedStruct<"timeout", {}>;
+}>;
+type PublicDnsObservation = typeof PublicDnsObservation.Type;
+declare const Result: Schema.Struct<{
+  readonly provider: Schema.TaggedUnion<{
+    readonly failure: Schema.TaggedStruct<"failure", {
+      readonly message: Schema.String;
+    }>;
+    readonly match: Schema.TaggedStruct<"match", {}>;
+    readonly mismatch: Schema.TaggedStruct<"mismatch", {
+      readonly records: Schema.$Array<Schema.TaggedUnion<{
+        readonly A: 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 AAAA: 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 CAA: 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 CNAME: 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 MX: 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 NS: 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 SRV: 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 TXT: 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 missing: Schema.TaggedStruct<"missing", {}>;
+  }>;
+  readonly publicDns: Schema.TaggedUnion<{
+    readonly failure: Schema.TaggedStruct<"failure", {
+      readonly message: Schema.String;
+    }>;
+    readonly mismatch: Schema.TaggedStruct<"mismatch", {
+      readonly answers: Schema.$Array<Schema.String>;
+    }>;
+    readonly missing: Schema.TaggedStruct<"missing", {}>;
+    readonly propagated: Schema.TaggedStruct<"propagated", {}>;
+    readonly timeout: Schema.TaggedStruct<"timeout", {}>;
+  }>;
+  readonly status: Schema.Literals<readonly ["verified", "pending", "mismatch", "unavailable"]>;
+}>;
+interface Result extends Schema.Schema.Type<typeof Result> {}
+declare const record: (input: {
+  readonly record: DnsRecord;
+  readonly zone: DomainName;
+}) => Effect.Effect<{
+  provider: {
+    readonly _tag: "failure";
+    readonly message: string;
+  } | {
+    readonly _tag: "match";
+  } | {
+    readonly _tag: "mismatch";
+    readonly records: readonly ({
+      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;
+    } | {
+      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;
+    } | {
+      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;
+    } | {
+      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">;
+    } | {
+      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;
+    } | {
+      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">;
+    } | {
+      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;
+    } | {
+      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;
+    })[];
+  } | {
+    readonly _tag: "missing";
+  };
+  publicDns: {
+    readonly _tag: "missing";
+  } | {
+    readonly _tag: "failure";
+    readonly message: string;
+  } | {
+    readonly _tag: "mismatch";
+    readonly answers: readonly string[];
+  } | {
+    readonly _tag: "propagated";
+  } | {
+    readonly _tag: "timeout";
+  };
+  status: "mismatch" | "pending" | "unavailable" | "verified";
+}, never, Service | Service$4>;
+//#endregion
+export { canonical_json_d_exports as _, Options$1 as a, CreateInput as c, zones_d_exports as d, selection_d_exports as f, CryptoError as g, oauth_d_exports as h, cloudflare_doh_d_exports as i, plan_d_exports as l, Fetch$1 as m, verify_d_exports as n, doh_d_exports as o, BeginInput as p, Options as r, AuthorizeError as s, Result as t, renderManualInstructions as u };
+//# sourceMappingURL=verify-DPB1OfZ5.d.mts.map