domainkit 0.1.1 → 0.2.1

package/dist/verify-7_EbKbFM.d.mts

@@ -0,0 +1,805 @@
+import { A as Connection, Lt as Error, Nt as DomainName, W as ProviderAuthorization, ft as Service$1, vt as DnsRecord } from "./zone-discovery-BA5I24vu.mjs";
+import { a as Interface$1, c as Service$2, i as Error$1, n as AsyncInterface, o as Query, t as Answer } from "./resolver-BbVzTbCX.mjs";
+import { Context, Data, Effect, Layer, Schema } from "effect";
+declare namespace diagnostic_d_exports {
+  export { Category, Diagnostic, Fields, RetryAdvice, from };
+}
+declare const Category: Schema.Literals<readonly ["authorization", "configuration", "provider", "storage", "validation"]>;
+type Category = typeof Category.Type;
+declare const RetryAdvice: Schema.Literals<readonly ["never", "after-user-action", "safe", "unknown"]>;
+type RetryAdvice = typeof RetryAdvice.Type;
+declare const Fields: {
+  readonly category: Schema.Literals<readonly ["authorization", "configuration", "provider", "storage", "validation"]>;
+  readonly message: Schema.String;
+  readonly operation: Schema.String;
+  readonly retry: Schema.Literals<readonly ["never", "after-user-action", "safe", "unknown"]>;
+};
+interface Diagnostic {
+  readonly category: Category;
+  readonly message: string;
+  readonly operation: string;
+  readonly retry: RetryAdvice;
+  readonly tag: string;
+}
+declare function from(error: {
+  readonly _tag: string;
+  readonly category: Category;
+  readonly message: string;
+  readonly operation: string;
+  readonly retry: RetryAdvice;
+}): Diagnostic;
+declare namespace selection_d_exports {
+  export { ConnectedZone, Evidence$1 as Evidence, Selection, select };
+}
+interface ConnectedZone {
+  readonly authorization: ProviderAuthorization;
+  readonly connection: Connection;
+  readonly nameservers: ReadonlyArray<string>;
+  readonly providerId: string;
+  readonly zone: string;
+}
+declare const Evidence$1: 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$1 extends Schema.Schema.Type<typeof Evidence$1> {}
+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 doh_d_exports {
+  export { Fetch, Options$2 as Options, layer$2 as layer, make$3 as make, toAsync$2 as toAsync };
+}
+type Fetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+interface Options$2 {
+  readonly endpoint: string;
+  readonly fetch?: Fetch;
+  readonly timeoutMs?: number;
+}
+declare function make$3(options: Options$2): Interface$1;
+declare const layer$2: (options: Options$2) => Layer.Layer<Service$2>;
+declare const toAsync$2: (options: Options$2) => AsyncInterface;
+declare namespace cloudflare_doh_d_exports {
+  export { Options$1 as Options, layer$1 as layer, make$2 as make, toAsync$1 as toAsync };
+}
+interface Options$1 extends Omit<Options$2, "endpoint"> {
+  readonly endpoint?: string;
+}
+declare function make$2(options?: Options$1): Interface$1;
+declare const layer$1: (options?: Options$1) => Layer.Layer<Service$2>;
+declare const toAsync$1: (options?: Options$1) => AsyncInterface;
+declare namespace google_doh_d_exports {
+  export { Options, layer, make$1 as make, toAsync };
+}
+interface Options extends Omit<Options$2, "endpoint"> {
+  readonly endpoint?: string;
+}
+declare function make$1(options?: Options): Interface$1;
+declare const layer: (options?: Options) => Layer.Layer<Service$2>;
+declare const toAsync: (options?: Options) => AsyncInterface;
+declare namespace resolver_pool_d_exports {
+  export { DefaultOptions, Entry, Interface, Observation, Policy, Service, defaultLayer, defaultMake, make };
+}
+interface Entry {
+  readonly id: string;
+  readonly resolver: Interface$1;
+  readonly timeoutMs?: number;
+}
+type Observation = Data.TaggedEnum<{
+  Answer: {
+    readonly answers: ReadonlyArray<Answer>;
+    readonly resolverId: string;
+  };
+  Failed: {
+    readonly message: string;
+    readonly reason: Exclude<Error$1["reason"], "timeout">;
+    readonly resolverId: string;
+  };
+  NoData: {
+    readonly resolverId: string;
+  };
+  TimedOut: {
+    readonly resolverId: string;
+    readonly timeoutMs: number;
+  };
+}>;
+declare const Observation: {
+  readonly $is: <Tag extends "Answer" | "Failed" | "NoData" | "TimedOut">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Answer";
+    readonly answers: ReadonlyArray<Answer>;
+    readonly resolverId: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Failed";
+    readonly message: string;
+    readonly reason: Exclude<Error$1["reason"], "timeout">;
+    readonly resolverId: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "NoData";
+    readonly resolverId: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "TimedOut";
+    readonly resolverId: string;
+    readonly timeoutMs: number;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Answer" | "Failed" | "NoData" | "TimedOut"]: (args: Extract<{
+      readonly _tag: "Answer";
+      readonly answers: ReadonlyArray<Answer>;
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "Failed";
+      readonly message: string;
+      readonly reason: Exclude<Error$1["reason"], "timeout">;
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "NoData";
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "TimedOut";
+      readonly resolverId: string;
+      readonly timeoutMs: number;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Answer";
+      readonly answers: ReadonlyArray<Answer>;
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "Failed";
+      readonly message: string;
+      readonly reason: Exclude<Error$1["reason"], "timeout">;
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "NoData";
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "TimedOut";
+      readonly resolverId: string;
+      readonly timeoutMs: number;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Answer" | "Failed" | "NoData" | "TimedOut"]>>;
+    <Cases extends { readonly [Tag in "Answer" | "Failed" | "NoData" | "TimedOut"]: (args: Extract<{
+      readonly _tag: "Answer";
+      readonly answers: ReadonlyArray<Answer>;
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "Failed";
+      readonly message: string;
+      readonly reason: Exclude<Error$1["reason"], "timeout">;
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "NoData";
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "TimedOut";
+      readonly resolverId: string;
+      readonly timeoutMs: number;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Answer";
+      readonly answers: ReadonlyArray<Answer>;
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "Failed";
+      readonly message: string;
+      readonly reason: Exclude<Error$1["reason"], "timeout">;
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "NoData";
+      readonly resolverId: string;
+    } | {
+      readonly _tag: "TimedOut";
+      readonly resolverId: string;
+      readonly timeoutMs: number;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Answer" | "Failed" | "NoData" | "TimedOut"]>>;
+  };
+  readonly Answer: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Answer";
+    readonly answers: ReadonlyArray<Answer>;
+    readonly resolverId: string;
+  }, "_tag">;
+  readonly Failed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failed";
+    readonly message: string;
+    readonly reason: Exclude<Error$1["reason"], "timeout">;
+    readonly resolverId: string;
+  }, "_tag">;
+  readonly NoData: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "NoData";
+    readonly resolverId: string;
+  }, "_tag">;
+  readonly TimedOut: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "TimedOut";
+    readonly resolverId: string;
+    readonly timeoutMs: number;
+  }, "_tag">;
+};
+type Policy = Data.TaggedEnum<{
+  AllMatch: {};
+  AnyMatch: {};
+  Quorum: {
+    readonly minimum: number;
+  };
+}>;
+declare const Policy: {
+  AllMatch: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "AllMatch";
+  }, "_tag">;
+  AnyMatch: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "AnyMatch";
+  }, "_tag">;
+  Quorum: ({ minimum }: {
+    readonly minimum: number;
+  }) => Policy;
+  Schema: Schema.TaggedUnion<{
+    readonly AllMatch: Schema.TaggedStruct<"AllMatch", {}>;
+    readonly AnyMatch: Schema.TaggedStruct<"AnyMatch", {}>;
+    readonly Quorum: Schema.TaggedStruct<"Quorum", {
+      readonly minimum: Schema.Int;
+    }>;
+  }>;
+};
+interface Interface {
+  readonly observe: (query: Query) => Effect.Effect<ReadonlyArray<Observation>>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@domainkit/DnsResolverPool", Interface>;
+declare class Service extends Service_base {}
+declare function make(entries: ReadonlyArray<Entry>): Interface;
+interface DefaultOptions extends Omit<Options$2, "endpoint"> {}
+/** Cloudflare and Google RFC wire-format DoH resolvers. */
+declare function defaultMake(options?: DefaultOptions): Interface;
+declare const defaultLayer: (options?: DefaultOptions) => Layer.Layer<Service>;
+declare namespace verify_d_exports {
+  export { Config, Provider, ProviderConfig, ProviderObservation, PublicDns, PublicDnsObservation, PublicOnlyConfig, Result, observe };
+}
+type PublicDns = Data.TaggedEnum<{
+  Disabled: {};
+  Enabled: {
+    readonly policy?: Policy;
+  };
+}>;
+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;
+  }>;
+  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 zone: DomainName;
+  };
+}>;
+declare const Provider: {
+  readonly $is: <Tag extends "Disabled" | "Enabled">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Disabled";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Enabled";
+    readonly zone: DomainName;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Disabled" | "Enabled"]: (args: Extract<{
+      readonly _tag: "Disabled";
+    } | {
+      readonly _tag: "Enabled";
+      readonly zone: DomainName;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Disabled";
+    } | {
+      readonly _tag: "Enabled";
+      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: "Enabled";
+      readonly zone: DomainName;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Disabled";
+    } | {
+      readonly _tag: "Enabled";
+      readonly zone: DomainName;
+    }, 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 zone: DomainName;
+  }, "_tag">;
+};
+type ProviderEnabled = Extract<Provider, {
+  readonly _tag: "Enabled";
+}>;
+type ProviderDisabled = Extract<Provider, {
+  readonly _tag: "Disabled";
+}>;
+interface PublicOnlyConfig {
+  readonly provider?: ProviderDisabled;
+  readonly publicDns?: PublicDns;
+  readonly record: DnsRecord;
+}
+interface ProviderConfig {
+  readonly provider: ProviderEnabled;
+  readonly publicDns?: PublicDns;
+  readonly record: DnsRecord;
+}
+type Config = ProviderConfig | PublicOnlyConfig;
+type ProviderObservation = Data.TaggedEnum<{
+  Matched: {};
+  Mismatch: {
+    readonly records: ReadonlyArray<DnsRecord>;
+  };
+  Pending: {};
+  Unavailable: {
+    readonly message: string;
+  };
+}>;
+declare const ProviderObservation: {
+  readonly $is: <Tag extends "Matched" | "Mismatch" | "Pending" | "Unavailable">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Matched";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Mismatch";
+    readonly records: ReadonlyArray<DnsRecord>;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Pending";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Unavailable";
+    readonly message: string;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Matched" | "Mismatch" | "Pending" | "Unavailable"]: (args: Extract<{
+      readonly _tag: "Matched";
+    } | {
+      readonly _tag: "Mismatch";
+      readonly records: ReadonlyArray<DnsRecord>;
+    } | {
+      readonly _tag: "Pending";
+    } | {
+      readonly _tag: "Unavailable";
+      readonly message: string;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Matched";
+    } | {
+      readonly _tag: "Mismatch";
+      readonly records: ReadonlyArray<DnsRecord>;
+    } | {
+      readonly _tag: "Pending";
+    } | {
+      readonly _tag: "Unavailable";
+      readonly message: string;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Matched" | "Mismatch" | "Pending" | "Unavailable"]>>;
+    <Cases extends { readonly [Tag in "Matched" | "Mismatch" | "Pending" | "Unavailable"]: (args: Extract<{
+      readonly _tag: "Matched";
+    } | {
+      readonly _tag: "Mismatch";
+      readonly records: ReadonlyArray<DnsRecord>;
+    } | {
+      readonly _tag: "Pending";
+    } | {
+      readonly _tag: "Unavailable";
+      readonly message: string;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Matched";
+    } | {
+      readonly _tag: "Mismatch";
+      readonly records: ReadonlyArray<DnsRecord>;
+    } | {
+      readonly _tag: "Pending";
+    } | {
+      readonly _tag: "Unavailable";
+      readonly message: string;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Matched" | "Mismatch" | "Pending" | "Unavailable"]>>;
+  };
+  readonly Matched: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Matched";
+  }, "_tag">;
+  readonly Mismatch: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Mismatch";
+    readonly records: ReadonlyArray<DnsRecord>;
+  }, "_tag">;
+  readonly Pending: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Pending";
+  }, "_tag">;
+  readonly Unavailable: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Unavailable";
+    readonly message: string;
+  }, "_tag">;
+};
+type PublicDnsObservation = Data.TaggedEnum<{
+  Verified: {
+    readonly evidence: ReadonlyArray<Observation>;
+    readonly matchedResolverIds: ReadonlyArray<string>;
+  };
+  Mismatch: {
+    readonly evidence: ReadonlyArray<Observation>;
+  };
+  Pending: {
+    readonly evidence: ReadonlyArray<Observation>;
+  };
+  Unavailable: {
+    readonly evidence: ReadonlyArray<Observation>;
+  };
+}>;
+declare const PublicDnsObservation: {
+  readonly $is: <Tag extends "Mismatch" | "Pending" | "Unavailable" | "Verified">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Mismatch";
+    readonly evidence: ReadonlyArray<Observation>;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Pending";
+    readonly evidence: ReadonlyArray<Observation>;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Unavailable";
+    readonly evidence: ReadonlyArray<Observation>;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Verified";
+    readonly evidence: ReadonlyArray<Observation>;
+    readonly matchedResolverIds: ReadonlyArray<string>;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Mismatch" | "Pending" | "Unavailable" | "Verified"]: (args: Extract<{
+      readonly _tag: "Mismatch";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Pending";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Unavailable";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Verified";
+      readonly evidence: ReadonlyArray<Observation>;
+      readonly matchedResolverIds: ReadonlyArray<string>;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Mismatch";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Pending";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Unavailable";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Verified";
+      readonly evidence: ReadonlyArray<Observation>;
+      readonly matchedResolverIds: ReadonlyArray<string>;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Mismatch" | "Pending" | "Unavailable" | "Verified"]>>;
+    <Cases extends { readonly [Tag in "Mismatch" | "Pending" | "Unavailable" | "Verified"]: (args: Extract<{
+      readonly _tag: "Mismatch";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Pending";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Unavailable";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Verified";
+      readonly evidence: ReadonlyArray<Observation>;
+      readonly matchedResolverIds: ReadonlyArray<string>;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Mismatch";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Pending";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Unavailable";
+      readonly evidence: ReadonlyArray<Observation>;
+    } | {
+      readonly _tag: "Verified";
+      readonly evidence: ReadonlyArray<Observation>;
+      readonly matchedResolverIds: ReadonlyArray<string>;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Mismatch" | "Pending" | "Unavailable" | "Verified"]>>;
+  };
+  readonly Mismatch: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Mismatch";
+    readonly evidence: ReadonlyArray<Observation>;
+  }, "_tag">;
+  readonly Pending: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Pending";
+    readonly evidence: ReadonlyArray<Observation>;
+  }, "_tag">;
+  readonly Unavailable: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Unavailable";
+    readonly evidence: ReadonlyArray<Observation>;
+  }, "_tag">;
+  readonly Verified: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Verified";
+    readonly evidence: ReadonlyArray<Observation>;
+    readonly matchedResolverIds: ReadonlyArray<string>;
+  }, "_tag">;
+};
+interface Evidence {
+  readonly provider: ProviderObservation | null;
+  readonly publicDns: PublicDnsObservation | null;
+}
+type Result = Data.TaggedEnum<{
+  Mismatch: Evidence;
+  NotObserved: Evidence;
+  Pending: Evidence;
+  Unavailable: Evidence;
+  Verified: Evidence;
+}>;
+declare const Result: {
+  readonly $is: <Tag extends "Mismatch" | "NotObserved" | "Pending" | "Unavailable" | "Verified">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Mismatch";
+    readonly provider: ProviderObservation | null;
+    readonly publicDns: PublicDnsObservation | null;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "NotObserved";
+    readonly provider: ProviderObservation | null;
+    readonly publicDns: PublicDnsObservation | null;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Pending";
+    readonly provider: ProviderObservation | null;
+    readonly publicDns: PublicDnsObservation | null;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Unavailable";
+    readonly provider: ProviderObservation | null;
+    readonly publicDns: PublicDnsObservation | null;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Verified";
+    readonly provider: ProviderObservation | null;
+    readonly publicDns: PublicDnsObservation | null;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Mismatch" | "NotObserved" | "Pending" | "Unavailable" | "Verified"]: (args: Extract<{
+      readonly _tag: "Mismatch";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "NotObserved";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Pending";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Unavailable";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Verified";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Mismatch";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "NotObserved";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Pending";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Unavailable";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Verified";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Mismatch" | "NotObserved" | "Pending" | "Unavailable" | "Verified"]>>;
+    <Cases extends { readonly [Tag in "Mismatch" | "NotObserved" | "Pending" | "Unavailable" | "Verified"]: (args: Extract<{
+      readonly _tag: "Mismatch";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "NotObserved";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Pending";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Unavailable";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Verified";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Mismatch";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "NotObserved";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Pending";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Unavailable";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    } | {
+      readonly _tag: "Verified";
+      readonly provider: ProviderObservation | null;
+      readonly publicDns: PublicDnsObservation | null;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Mismatch" | "NotObserved" | "Pending" | "Unavailable" | "Verified"]>>;
+  };
+  readonly Mismatch: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Mismatch";
+    readonly provider: ProviderObservation | null;
+    readonly publicDns: PublicDnsObservation | null;
+  }, "_tag">;
+  readonly NotObserved: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "NotObserved";
+    readonly provider: ProviderObservation | null;
+    readonly publicDns: PublicDnsObservation | null;
+  }, "_tag">;
+  readonly Pending: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Pending";
+    readonly provider: ProviderObservation | null;
+    readonly publicDns: PublicDnsObservation | null;
+  }, "_tag">;
+  readonly Unavailable: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Unavailable";
+    readonly provider: ProviderObservation | null;
+    readonly publicDns: PublicDnsObservation | null;
+  }, "_tag">;
+  readonly Verified: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Verified";
+    readonly provider: ProviderObservation | null;
+    readonly publicDns: PublicDnsObservation | null;
+  }, "_tag">;
+};
+declare function observe(input: PublicOnlyConfig): Effect.Effect<Result, Error>;
+declare function observe(input: ProviderConfig): Effect.Effect<Result, Error, Service$1>;
+declare function observe(input: Config): Effect.Effect<Result, Error, Service$1>;
+//#endregion
+export { selection_d_exports as _, verify_d_exports as a, Policy as c, google_doh_d_exports as d, Options$1 as f, zones_d_exports as g, doh_d_exports as h, Result as i, resolver_pool_d_exports as l, Options$2 as m, PublicDns as n, DefaultOptions as o, cloudflare_doh_d_exports as p, PublicDnsObservation as r, Observation as s, ProviderObservation as t, Options as u, diagnostic_d_exports as v };
+//# sourceMappingURL=verify-7_EbKbFM.d.mts.map