domainkit 0.7.0 → 0.9.0

package/dist/verify-C3V_GtzL.d.mts

@@ -1,1268 +0,0 @@
-import { H as Capability, J as Manifest, M as ProviderConnection, N as ProviderTarget, Nt as Error$1, Q as OAuthSubjectResolver, W as ProviderAuthorization, X as OAuthClientConfiguration, Z as OAuthMethod, ct as Service$1, d as Method, et as TokenValidation, g as Envelope, h as Codec, it as AsyncInterface$1, j as DomainAttachment, kt as DomainName, l as InteractiveFlow, mt as DnsRecord, nt as Value, ot as Error, q as IntegrationMethod, s as Error$2, st as Interface$4 } from "./connect-10vHuShV.mjs";
-import { H as Source, a as Interface$5, c as Service$2, i as Error$3, n as AsyncInterface$2, o as Query, t as Answer } from "./resolver-DRrLm_hB.mjs";
-import { Context, Data, Effect, Layer, Schema } from "effect";
-import * as oauth from "oauth4webapi";
-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 attachment: DomainAttachment;
-  readonly connection: ProviderConnection;
-  readonly nameservers: ReadonlyArray<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 session_d_exports {
-  export { AsyncInterface, Authorization, Credential, Interface$3 as Interface, ListTargetsInput, Resolution, RestoreInput, fromAsync, toAsync$3 as toAsync };
-}
-/** A credential-scoped provider session that discovers safe targets before DNS access. */
-interface Interface$3 {
-  /** The provider represented by this credential. */
-  readonly providerId: string;
-  /** Lists provider account and authoritative-zone targets visible to this credential. */
-  readonly listTargets: (input?: ListTargetsInput) => Effect.Effect<ReadonlyArray<ProviderTarget>, Error>;
-  /** Resolves a domain without guessing when more than one account owns a matching zone. */
-  readonly resolveTarget: (domain: DomainName) => Effect.Effect<Resolution, Error>;
-  /** Creates the focused DNS-record capability bound to one exact discovered target. */
-  readonly forTarget: (target: ProviderTarget) => Effect.Effect<Interface$4, Error>;
-}
-interface ListTargetsInput {
-  /** Restrict results to the authoritative zone candidates for this domain. */
-  readonly domain?: DomainName;
-  /** Provider-specific account filter, when supported by the adapter. */
-  readonly accountId?: string;
-}
-type Resolution = Data.TaggedEnum<{
-  NotFound: {
-    readonly domain: DomainName;
-  };
-  Resolved: {
-    readonly target: ProviderTarget;
-  };
-  SelectionRequired: {
-    readonly candidates: ReadonlyArray<ProviderTarget>;
-  };
-}>;
-declare const Resolution: {
-  readonly $is: <Tag extends "NotFound" | "Resolved" | "SelectionRequired">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "NotFound";
-    readonly domain: DomainName;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Resolved";
-    readonly target: ProviderTarget;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "SelectionRequired";
-    readonly candidates: ReadonlyArray<ProviderTarget>;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "NotFound" | "Resolved" | "SelectionRequired"]: (args: Extract<{
-      readonly _tag: "NotFound";
-      readonly domain: DomainName;
-    } | {
-      readonly _tag: "Resolved";
-      readonly target: ProviderTarget;
-    } | {
-      readonly _tag: "SelectionRequired";
-      readonly candidates: ReadonlyArray<ProviderTarget>;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "NotFound";
-      readonly domain: DomainName;
-    } | {
-      readonly _tag: "Resolved";
-      readonly target: ProviderTarget;
-    } | {
-      readonly _tag: "SelectionRequired";
-      readonly candidates: ReadonlyArray<ProviderTarget>;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["NotFound" | "Resolved" | "SelectionRequired"]>>;
-    <Cases extends { readonly [Tag in "NotFound" | "Resolved" | "SelectionRequired"]: (args: Extract<{
-      readonly _tag: "NotFound";
-      readonly domain: DomainName;
-    } | {
-      readonly _tag: "Resolved";
-      readonly target: ProviderTarget;
-    } | {
-      readonly _tag: "SelectionRequired";
-      readonly candidates: ReadonlyArray<ProviderTarget>;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "NotFound";
-      readonly domain: DomainName;
-    } | {
-      readonly _tag: "Resolved";
-      readonly target: ProviderTarget;
-    } | {
-      readonly _tag: "SelectionRequired";
-      readonly candidates: ReadonlyArray<ProviderTarget>;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["NotFound" | "Resolved" | "SelectionRequired"]>>;
-  };
-  readonly NotFound: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "NotFound";
-    readonly domain: DomainName;
-  }, "_tag">;
-  readonly Resolved: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Resolved";
-    readonly target: ProviderTarget;
-  }, "_tag">;
-  readonly SelectionRequired: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "SelectionRequired";
-    readonly candidates: ReadonlyArray<ProviderTarget>;
-  }, "_tag">;
-};
-/** The credential material a provider adapter needs to restore a session. */
-interface Credential {
-  readonly accessToken: Value;
-  readonly expiresAt: Date | null;
-  readonly refreshToken: Value | null;
-  readonly tokenType: string;
-}
-/** The non-secret authorization projection required when restoring a provider session. */
-type Authorization = Pick<ProviderAuthorization, "capabilityEvidence" | "method" | "providerContext" | "providerId" | "requiredCapabilities" | "revocation">;
-interface RestoreInput {
-  readonly authorization: Authorization;
-  readonly credential: Credential;
-}
-/** Minimal Promise-shaped provider-session contract for hosts that do not use Effect directly. */
-interface AsyncInterface {
-  readonly providerId: string;
-  readonly listTargets: (input?: ListTargetsInput) => Promise<ReadonlyArray<ProviderTarget>>;
-  readonly resolveTarget: (domain: DomainName) => Promise<Resolution>;
-  readonly forTarget: (target: ProviderTarget) => Promise<AsyncInterface$1>;
-}
-/** Adapts a Promise-shaped session to the Effect-native session boundary. */
-declare const fromAsync: (session: AsyncInterface) => Interface$3;
-/** Adapts an Effect-native session to the Promise facade. */
-declare const toAsync$3: (session: Interface$3) => AsyncInterface;
-//#endregion
-//#region src/providers/cloudflare/protocol.d.ts
-declare const Account$2: Schema.Struct<{
-  readonly id: Schema.String;
-  readonly name: Schema.String;
-}>;
-interface Account$2 extends Schema.Schema.Type<typeof Account$2> {}
-declare namespace client_d_exports$1 {
-  export { Account$1 as Account, Fetch$2 as Fetch, Interface$2 as Interface, ListZonesInput$1 as ListZonesInput, Options$4 as Options, Zone$1 as Zone, discoverAuthorizationAccount, discovery$1 as discovery, make$5 as make, validateDomainToken };
-}
-type Fetch$2 = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-/** Configuration for an Effect-native Cloudflare authoritative-DNS client. */
-interface Options$4 {
-  /** Account scope for account tokens; omit for user or OAuth credentials. */
-  readonly accountId?: string;
-  readonly baseUrl?: string;
-  /** Capabilities the host required when issuing or authorizing this credential. */
-  readonly capabilities: TokenValidation["capabilities"];
-  readonly fetch?: Fetch$2;
-  readonly token: Value;
-  readonly tokenKind?: "account" | "user";
-}
-interface ListZonesInput$1 {
-  readonly accountId?: string;
-  readonly name?: DomainName;
-}
-type Account$1 = Account$2;
-/** A portable Cloudflare authoritative zone with normalized nameserver evidence. */
-interface Zone$1 {
-  readonly accountId: string;
-  readonly id: string;
-  readonly name: DomainName;
-  readonly nameservers: ReadonlyArray<DomainName>;
-  readonly status: string | null;
-}
-interface Interface$2 extends Interface$4 {
-  readonly providerId: "cloudflare";
-  readonly forTarget: (target: ProviderTarget) => Effect.Effect<Interface$4, Error>;
-  readonly listAccounts: () => Effect.Effect<ReadonlyArray<Account$1>, Error>;
-  readonly listZones: (input?: ListZonesInput$1) => Effect.Effect<ReadonlyArray<Zone$1>, Error>;
-  readonly listTargets: (input?: ListTargetsInput) => Effect.Effect<ReadonlyArray<ProviderTarget>, Error>;
-  readonly resolveTarget: (domain: DomainName) => Effect.Effect<Resolution, Error>;
-  readonly validateToken: () => Effect.Effect<TokenValidation, Error>;
-}
-/** Exposes Cloudflare zone lookup as the optional provider discovery capability. */
-declare function discovery$1(client: Interface$2): Source;
-interface CredentialOptions$1 {
-  readonly baseUrl?: string;
-  readonly fetch?: Fetch$2;
-  readonly token: Value;
-}
-interface DomainCredentialOptions extends CredentialOptions$1 {
-  readonly capabilities: TokenValidation["capabilities"];
-  readonly domain: DomainName;
-  readonly tokenKind?: "account" | "user";
-}
-declare const discoverAuthorizationAccount: (options: CredentialOptions$1 & {
-  readonly domain: DomainName;
-}) => Effect.Effect<{
-  readonly id: string;
-  readonly name: string;
-}, Error, never>;
-declare const validateDomainToken: (options: DomainCredentialOptions) => Effect.Effect<{
-  accountId: string;
-  capabilities: readonly ("dns:read" | "dns:write")[];
-  expiresAt: Date | null;
-  scopes: never[];
-}, Error, never>;
-/** Creates an Effect-native Cloudflare client without owning the credential lifecycle. */
-declare function make$5(options: Options$4): Interface$2;
-declare namespace auth_d_exports$1 {
-  export { Context$2 as Context, CredentialTarget, OAuthFlowOptions, OAuthMethodOptions, RefreshCredentialOptions, SubjectResolverOptions, TokenConnectionOptions$1 as TokenConnectionOptions, TokenValidatorOptions, contextCodec$1 as contextCodec, manifest$1 as manifest, oauthAuthentication, oauthFlow, oauthMethod, refreshCredential, restore$1 as restore, subjectResolver, tokenConnectionMethod$1 as tokenConnectionMethod, tokenMethod$1 as tokenMethod, tokenValidator };
-}
-declare const Context$2: Schema.Struct<{
-  readonly accountId: Schema.optionalKey<Schema.String>;
-  readonly tokenKind: Schema.Literals<readonly ["account", "user"]>;
-}>;
-type Context$2 = typeof Context$2.Type;
-declare const contextCodec$1: Codec<{
-  readonly accountId?: string;
-  readonly tokenKind: "account" | "user";
-}>;
-/** Describes Cloudflare's caller-created API-token authorization method. */
-declare function tokenMethod$1(capabilities: TokenValidation["capabilities"]): Extract<Manifest["methods"][number], {
-  readonly _tag: "token";
-}>;
-interface OAuthMethodOptions {
-  /** Scope IDs assigned to the OAuth client by Cloudflare. */
-  readonly scopes: ReadonlyArray<string>;
-  /** Capabilities represented by those assigned scope IDs. */
-  readonly capabilities: TokenValidation["capabilities"];
-  readonly clientAuth: OAuthMethod["clientAuth"];
-}
-/** Describes a registered Cloudflare OAuth client and its assigned scope IDs. */
-declare function oauthMethod(options: OAuthMethodOptions): OAuthMethod;
-/** Creates the Cloudflare token and OAuth authorization manifest. */
-declare function manifest$1(options: OAuthMethodOptions): Manifest;
-type CredentialOptions = Omit<Options$4, "accountId" | "token" | "tokenKind">;
-/** Selects an explicit Cloudflare account or discovers it from an authorized domain. */
-type CredentialTarget = {
-  readonly accountId: string;
-  readonly domain?: never;
-} | {
-  readonly accountId?: never;
-  readonly domain: DomainName;
-};
-type SubjectResolverOptions = CredentialOptions & CredentialTarget;
-/** Configuration for validating a Cloudflare token against an account or authorized domain. */
-type TokenValidatorOptions = CredentialOptions & ({
-  readonly accountId: string;
-  readonly domain?: never;
-  readonly tokenKind?: "account" | "user";
-} | {
-  readonly accountId?: never;
-  readonly domain: DomainName;
-  readonly tokenKind?: "account" | "user";
-});
-/** Resolves the Cloudflare account selected by a completed OAuth authorization. */
-declare function subjectResolver(options: SubjectResolverOptions): OAuthSubjectResolver;
-/** Creates a host callback that validates a Cloudflare API token. */
-declare function tokenValidator(options: TokenValidatorOptions): (token: Value) => ReturnType<Interface$2["validateToken"]>;
-type TokenConnectionOptions$1 = TokenValidatorOptions & {
-  readonly token: Value;
-};
-/** Creates a provider-independent token connection method backed by Cloudflare validation. */
-declare function tokenConnectionMethod$1(options: TokenConnectionOptions$1): Extract<Method, {
-  readonly _tag: "Token";
-}>;
-/** Converts a completed Cloudflare OAuth authorization into canonical connection authentication. */
-declare const oauthAuthentication: (options: SubjectResolverOptions & {
-  readonly accessToken: Value;
-  readonly tokens: oauth.TokenEndpointResponse;
-}) => Effect.Effect<{
-  capabilityEvidence: {
-    capability: "dns:read" | "dns:write";
-    evidence: {
-      readonly _tag: "Introspected";
-      readonly observedAt: Date;
-    };
-  }[];
-  credential: {
-    accessToken: Value;
-    expiresAt: Date | null;
-    refreshToken: Value | null;
-    tokenType: Lowercase<string>;
-  };
-  providerAccountId: string;
-  providerContext: Envelope;
-  scopes: string[];
-}, Error$1 | Error, never>;
-/** Restore a credential-scoped Cloudflare session from persisted authorization state. */
-declare function restore$1(options: RestoreInput & Pick<Options$4, "baseUrl" | "fetch">): Effect.Effect<Interface$2, Error>;
-interface RefreshCredentialOptions {
-  readonly client: OAuthClientConfiguration;
-  readonly clientAuth: OAuthMethod["clientAuth"];
-  readonly credential: Credential;
-  readonly fetch?: Fetch$2;
-}
-/** Exchanges a Cloudflare refresh token for a fresh provider credential. */
-declare const refreshCredential: (options: RefreshCredentialOptions) => Effect.Effect<{
-  accessToken: Value;
-  expiresAt: Date | null;
-  refreshToken: Value;
-  tokenType: Lowercase<string>;
-}, Error | Error$2, never>;
-type OAuthFlowOptions = SubjectResolverOptions & {
-  readonly client: OAuthClientConfiguration;
-  readonly clientAuth: OAuthMethod["clientAuth"];
-  readonly redirectUri: string;
-  readonly scopes: ReadonlyArray<string>;
-};
-/** Creates Cloudflare's OAuth implementation of the common interactive connection capability. */
-declare function oauthFlow(options: OAuthFlowOptions): InteractiveFlow;
-declare namespace index_d_exports$1 {
-  export { Account$1 as Account, auth_d_exports$1 as Auth, client_d_exports$1 as Client, Fetch$2 as Fetch, Interface$2 as Interface, ListZonesInput$1 as ListZonesInput, Options$4 as Options, Zone$1 as Zone, discovery$1 as discovery, make$5 as make };
-}
-declare namespace client_d_exports {
-  export { Account, AccountContext, Fetch$1 as Fetch, Interface$1 as Interface, ListZonesInput, Options$3 as Options, Zone, discovery, make$4 as make };
-}
-type Fetch$1 = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-/** Selects whether Vercel requests operate on a personal account or a team. */
-type AccountContext = {
-  readonly _tag: "personal";
-} | {
-  readonly _tag: "team";
-  readonly teamId: string;
-};
-/** Constructs the account scope used by Vercel API requests. */
-declare const AccountContext: {
-  personal: () => Extract<AccountContext, {
-    readonly _tag: "personal";
-  }>;
-  team: ({ teamId }: {
-    readonly teamId: string;
-  }) => Extract<AccountContext, {
-    readonly _tag: "team";
-  }>;
-};
-/** Configuration for an Effect-native Vercel authoritative-DNS client. */
-interface Options$3 {
-  readonly baseUrl?: string;
-  /** Capabilities the host required when issuing or authorizing this credential. */
-  readonly capabilities: TokenValidation["capabilities"];
-  readonly context: AccountContext;
-  readonly fetch?: Fetch$1;
-  readonly token: Value;
-}
-interface ListZonesInput {
-  readonly name?: DomainName;
-}
-/** A Vercel account visible to the supplied credential. */
-interface Account {
-  readonly id: string;
-  readonly name: string;
-  readonly type: "personal" | "team";
-}
-/** A Vercel-managed authoritative zone with normalized nameserver evidence. */
-interface Zone {
-  readonly accountId: string;
-  readonly id: string;
-  readonly name: DomainName;
-  readonly nameservers: ReadonlyArray<DomainName>;
-  readonly status: "active" | "pending";
-}
-interface Interface$1 extends Interface$4 {
-  readonly providerId: "vercel";
-  readonly forTarget: (target: ProviderTarget) => Effect.Effect<Interface$4, Error>;
-  readonly listAccounts: () => Effect.Effect<ReadonlyArray<Account>, Error>;
-  readonly listZones: (input?: ListZonesInput) => Effect.Effect<ReadonlyArray<Zone>, Error>;
-  readonly listTargets: (input?: ListTargetsInput) => Effect.Effect<ReadonlyArray<ProviderTarget>, Error>;
-  readonly resolveTarget: (domain: DomainName) => Effect.Effect<Resolution, Error>;
-  readonly validateToken: () => Effect.Effect<TokenValidation, Error>;
-}
-/** Exposes Vercel zone lookup as the optional provider discovery capability. */
-declare function discovery(client: Interface$1): Source;
-/** Creates an Effect-native Vercel client without owning the credential lifecycle. */
-declare function make$4(options: Options$3): Interface$1;
-declare namespace auth_d_exports {
-  export { Context$1 as Context, ExchangeCodeOptions, IntegrationCredential, IntegrationFlowOptions, IntegrationMethodOptions, TokenConnectionOptions, contextCodec, exchangeCode, integrationAuthentication, integrationFlow, integrationMethod, manifest, restore, tokenConnectionMethod, tokenMethod };
-}
-declare const Context$1: Schema.TaggedUnion<{
-  readonly personal: Schema.TaggedStruct<"personal", {
-    readonly installationId: Schema.NullOr<Schema.String>;
-  }>;
-  readonly team: Schema.TaggedStruct<"team", {
-    readonly installationId: Schema.NullOr<Schema.String>;
-    readonly teamId: Schema.String;
-  }>;
-}>;
-type Context$1 = typeof Context$1.Type;
-declare const contextCodec: Codec<{
-  readonly _tag: "personal";
-  readonly installationId: string | null;
-} | {
-  readonly _tag: "team";
-  readonly installationId: string | null;
-  readonly teamId: string;
-}>;
-/** Describes Vercel's caller-created personal access-token method. */
-declare function tokenMethod(capabilities: TokenValidation["capabilities"]): Extract<Manifest["methods"][number], {
-  readonly _tag: "token";
-}>;
-interface IntegrationMethodOptions {
-  readonly capabilities: TokenValidation["capabilities"];
-  readonly slug: string;
-}
-/** Describes Vercel's provider-specific integration installation flow. */
-declare function integrationMethod(options: IntegrationMethodOptions): IntegrationMethod;
-/** Creates the Vercel token and integration authorization manifest. */
-declare function manifest(options: IntegrationMethodOptions): Manifest;
-interface ExchangeCodeOptions {
-  readonly baseUrl?: string;
-  readonly clientId: string;
-  readonly clientSecret: Value;
-  readonly code: Value;
-  /** Configuration ID returned by Vercel's integration callback, when available. */
-  readonly configurationId?: string;
-  readonly fetch?: Fetch$1;
-  readonly redirectUri: string;
-}
-interface IntegrationCredential {
-  readonly accessToken: Value;
-  readonly context: AccountContext;
-  readonly installationId: string | null;
-  readonly userId: string;
-}
-/** Exchanges Vercel's one-time integration code and preserves its account context. */
-declare const exchangeCode: (options: ExchangeCodeOptions) => Effect.Effect<{
-  accessToken: Value;
-  context: {
-    readonly _tag: "personal";
-  } | {
-    readonly _tag: "team";
-    readonly teamId: string;
-  };
-  installationId: string | null;
-  userId: string;
-}, Error, never>;
-interface TokenConnectionOptions extends Omit<Options$3, "token"> {
-  readonly token: Value;
-}
-/** Creates a provider-independent token connection method backed by Vercel validation. */
-declare function tokenConnectionMethod(options: TokenConnectionOptions): Extract<Method, {
-  readonly _tag: "Token";
-}>;
-/** Converts a completed Vercel Integration exchange into canonical connection authentication. */
-declare const integrationAuthentication: (options: ExchangeCodeOptions & {
-  readonly capabilities: ReadonlyArray<Capability>;
-}) => Effect.Effect<{
-  capabilityEvidence: {
-    capability: "dns:read" | "dns:write";
-    evidence: {
-      readonly _tag: "Introspected";
-      readonly observedAt: Date;
-    };
-  }[];
-  credential: {
-    accessToken: Value;
-    expiresAt: null;
-    refreshToken: null;
-    tokenType: string;
-  };
-  providerAccountId: string;
-  providerContext: Envelope;
-  scopes: never[];
-}, Error$1 | Error, never>;
-/** Restore a credential-scoped Vercel session from persisted authorization state. */
-declare function restore(options: RestoreInput & Pick<Options$3, "baseUrl" | "fetch">): Effect.Effect<Interface$1, Error>;
-interface IntegrationFlowOptions extends Omit<ExchangeCodeOptions, "code">, IntegrationMethodOptions {}
-/** Creates Vercel Integration's implementation of the common interactive connection capability. */
-declare function integrationFlow(options: IntegrationFlowOptions): InteractiveFlow;
-declare namespace index_d_exports {
-  export { Account, AccountContext, auth_d_exports as Auth, client_d_exports as Client, Fetch$1 as Fetch, Interface$1 as Interface, ListZonesInput, Options$3 as Options, Zone, discovery, make$4 as make };
-}
-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$5;
-declare const layer$2: (options: Options$2) => Layer.Layer<Service$2>;
-declare const toAsync$2: (options: Options$2) => AsyncInterface$2;
-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$5;
-declare const layer$1: (options?: Options$1) => Layer.Layer<Service$2>;
-declare const toAsync$1: (options?: Options$1) => AsyncInterface$2;
-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$5;
-declare const layer: (options?: Options) => Layer.Layer<Service$2>;
-declare const toAsync: (options?: Options) => AsyncInterface$2;
-declare namespace resolver_pool_d_exports {
-  export { DefaultOptions, Entry, Interface, Observation, Policy, Service, defaultLayer, defaultMake, make };
-}
-interface Entry {
-  readonly id: string;
-  readonly resolver: Interface$5;
-  readonly timeoutMs?: number;
-}
-type Observation = Data.TaggedEnum<{
-  Answer: {
-    readonly answers: ReadonlyArray<Answer>;
-    readonly resolverId: string;
-  };
-  Failed: {
-    readonly message: string;
-    readonly reason: Exclude<Error$3["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$3["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$3["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$3["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$3["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$3["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$3["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$1>;
-declare function observe(input: ProviderConfig): Effect.Effect<Result, Error$1, Service$1>;
-declare function observe(input: Config): Effect.Effect<Result, Error$1, Service$1>;
-//#endregion
-export { RestoreInput as $, Options$3 as A, manifest$1 as B, manifest as C, Fetch$1 as D, AccountContext as E, OAuthMethodOptions as F, Interface$2 as G, tokenMethod$1 as H, RefreshCredentialOptions as I, Zone$1 as J, ListZonesInput$1 as K, SubjectResolverOptions as L, index_d_exports$1 as M, CredentialTarget as N, Interface$1 as O, OAuthFlowOptions as P, Resolution as Q, TokenConnectionOptions$1 as R, integrationMethod as S, Account as T, Account$1 as U, oauthMethod as V, Fetch$2 as W, Interface$3 as X, Credential as Y, ListTargetsInput as Z, ExchangeCodeOptions as _, verify_d_exports as a, IntegrationMethodOptions as b, Policy as c, google_doh_d_exports as d, session_d_exports as et, Options$1 as f, index_d_exports as g, doh_d_exports as h, Result as i, Zone as j, ListZonesInput as k, resolver_pool_d_exports as l, Options$2 as m, PublicDns as n, selection_d_exports as nt, DefaultOptions as o, cloudflare_doh_d_exports as p, Options$4 as q, PublicDnsObservation as r, diagnostic_d_exports as rt, Observation as s, ProviderObservation as t, zones_d_exports as tt, Options as u, IntegrationCredential as v, tokenMethod as w, TokenConnectionOptions as x, IntegrationFlowOptions as y, TokenValidatorOptions as z };
-//# sourceMappingURL=verify-C3V_GtzL.d.mts.map