domainkit 0.8.0 → 0.9.0

package/dist/managed-dns-connections-C3A_GBaz.mjs

@@ -1,99 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { o as Error, s as Service } from "./canonical-json-CQYKsZw7.mjs";
-import { Effect, Layer } from "effect";
-//#region src/promise/managed-dns-connections.ts
-var managed_dns_connections_exports = /* @__PURE__ */ __exportAll({
-	Error: () => Error,
-	from: () => from,
-	layerFromAsync: () => layerFromAsync,
-	toAsync: () => toAsync
-});
-const failure = (operation, cause) => cause instanceof Error ? cause : new Error({
-	category: "storage",
-	message: cause instanceof globalThis.Error ? cause.message : String(cause),
-	operation,
-	retry: "safe"
-});
-const layerFromAsync = (repository) => Layer.succeed(Service, {
-	attach: (input) => Effect.tryPromise({
-		try: () => repository.attach(input),
-		catch: (cause) => failure("ManagedDnsConnections.attach", cause)
-	}),
-	connect: (input) => Effect.tryPromise({
-		try: () => repository.connect(input),
-		catch: (cause) => failure("ManagedDnsConnections.connect", cause)
-	}),
-	detach: (input) => Effect.tryPromise({
-		try: () => repository.detach(input),
-		catch: (cause) => failure("ManagedDnsConnections.detach", cause)
-	}),
-	disconnect: ({ connectionId, ownerId, revoke }) => Effect.tryPromise({
-		try: () => repository.disconnect({
-			connectionId,
-			ownerId,
-			revoke: (authorization) => Effect.runPromise(revoke(authorization))
-		}),
-		catch: (cause) => failure("ManagedDnsConnections.disconnect", cause)
-	}),
-	findConnection: (ownerId, authorizationId) => Effect.tryPromise({
-		try: () => repository.findConnection(ownerId, authorizationId),
-		catch: (cause) => failure("ManagedDnsConnections.findConnection", cause)
-	}),
-	get: (authorizationId) => Effect.tryPromise({
-		try: () => repository.get(authorizationId),
-		catch: (cause) => failure("ManagedDnsConnections.get", cause)
-	}),
-	getAttachment: (attachmentId) => Effect.tryPromise({
-		try: () => repository.getAttachment(attachmentId),
-		catch: (cause) => failure("ManagedDnsConnections.getAttachment", cause)
-	}),
-	getByConnectionId: (connectionId) => Effect.tryPromise({
-		try: () => repository.getByConnectionId(connectionId),
-		catch: (cause) => failure("ManagedDnsConnections.getByConnectionId", cause)
-	}),
-	listAttachments: (connectionId, ownerId) => Effect.tryPromise({
-		try: () => repository.listAttachments(connectionId, ownerId),
-		catch: (cause) => failure("ManagedDnsConnections.listAttachments", cause)
-	}),
-	promoteEvidence: (authorizationId, evidence) => Effect.tryPromise({
-		try: () => repository.promoteEvidence(authorizationId, evidence),
-		catch: (cause) => failure("ManagedDnsConnections.promoteEvidence", cause)
-	}),
-	recover: ({ authorizationId, revoke }) => Effect.tryPromise({
-		try: () => repository.recover({
-			authorizationId,
-			revoke: (authorization) => Effect.runPromise(revoke(authorization))
-		}),
-		catch: (cause) => failure("ManagedDnsConnections.recover", cause)
-	}),
-	rotate: (authorizationId, credential) => Effect.tryPromise({
-		try: () => repository.rotate(authorizationId, credential),
-		catch: (cause) => failure("ManagedDnsConnections.rotate", cause)
-	})
-});
-const toAsync = (service) => ({
-	attach: (input) => Effect.runPromise(service.attach(input)),
-	connect: (input) => Effect.runPromise(service.connect(input)),
-	detach: (input) => Effect.runPromise(service.detach(input)),
-	disconnect: ({ connectionId, ownerId, revoke }) => Effect.runPromise(service.disconnect({
-		connectionId,
-		ownerId,
-		revoke: (authorization) => Effect.promise(() => revoke(authorization))
-	})),
-	findConnection: (ownerId, authorizationId) => Effect.runPromise(service.findConnection(ownerId, authorizationId)),
-	get: (authorizationId) => Effect.runPromise(service.get(authorizationId)),
-	getAttachment: (attachmentId) => Effect.runPromise(service.getAttachment(attachmentId)),
-	getByConnectionId: (connectionId) => Effect.runPromise(service.getByConnectionId(connectionId)),
-	listAttachments: (connectionId, ownerId) => Effect.runPromise(service.listAttachments(connectionId, ownerId)),
-	promoteEvidence: (authorizationId, evidence) => Effect.runPromise(service.promoteEvidence(authorizationId, evidence)),
-	recover: ({ authorizationId, revoke }) => Effect.runPromise(service.recover({
-		authorizationId,
-		revoke: (authorization) => Effect.promise(() => revoke(authorization))
-	})),
-	rotate: (authorizationId, credential) => Effect.runPromise(service.rotate(authorizationId, credential))
-});
-const from = (repository) => repository;
-//#endregion
-export { managed_dns_connections_exports as n, layerFromAsync as t };
-
-//# sourceMappingURL=managed-dns-connections-C3A_GBaz.mjs.map

package/dist/managed-dns-connections-C3A_GBaz.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"managed-dns-connections-C3A_GBaz.mjs","names":["Lifecycle.Error","Lifecycle.Service"],"sources":["../src/promise/managed-dns-connections.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\n\nimport type * as ProviderAuthorization from \"../auth/authorization.ts\";\nimport type * as Connection from \"../auth/connection.ts\";\nimport * as Lifecycle from \"../auth/lifecycle-repository.ts\";\n\nexport interface AsyncInterface {\n  readonly attach: (input: {\n    readonly attachment: Connection.DomainAttachment;\n    readonly connectionId: string;\n    readonly ownerId: string;\n  }) => Promise<Lifecycle.AttachmentResult>;\n  readonly connect: (input: Lifecycle.ConnectInput) => Promise<Lifecycle.Aggregate>;\n  readonly detach: (input: {\n    readonly attachmentId: string;\n    readonly ownerId: string;\n  }) => Promise<Lifecycle.DetachResult>;\n  readonly disconnect: (input: {\n    readonly connectionId: string;\n    readonly ownerId: string;\n    readonly revoke: (authorization: ProviderAuthorization.ProviderAuthorization) => Promise<void>;\n  }) => Promise<Lifecycle.DisconnectResult>;\n  readonly findConnection: (\n    ownerId: string,\n    authorizationId: string,\n  ) => Promise<Connection.StoredConnection | null>;\n  readonly get: (authorizationId: string) => Promise<Lifecycle.Aggregate | null>;\n  readonly getAttachment: (attachmentId: string) => Promise<Connection.DomainAttachment | null>;\n  readonly getByConnectionId: (connectionId: string) => Promise<Lifecycle.Aggregate | null>;\n  readonly listAttachments: (\n    connectionId: string,\n    ownerId: string,\n  ) => Promise<ReadonlyArray<Connection.DomainAttachment>>;\n  readonly promoteEvidence: (\n    authorizationId: string,\n    evidence: ReadonlyArray<ProviderAuthorization.CapabilityEvidence>,\n  ) => Promise<Lifecycle.Aggregate>;\n  readonly recover: (input: {\n    readonly authorizationId: string;\n    readonly revoke: (authorization: ProviderAuthorization.ProviderAuthorization) => Promise<void>;\n  }) => Promise<Lifecycle.DisconnectResult>;\n  readonly rotate: (\n    authorizationId: string,\n    credential: Connection.StoredCredential,\n  ) => Promise<Lifecycle.Aggregate>;\n}\n\nconst failure = (operation: string, cause: unknown): Lifecycle.Error =>\n  cause instanceof Lifecycle.Error\n    ? cause\n    : new Lifecycle.Error({\n        category: \"storage\",\n        message: cause instanceof globalThis.Error ? cause.message : String(cause),\n        operation,\n        retry: \"safe\",\n      });\n\nexport const layerFromAsync = (repository: AsyncInterface): Layer.Layer<Lifecycle.Service> =>\n  Layer.succeed(Lifecycle.Service, {\n    attach: (input) =>\n      Effect.tryPromise({\n        try: () => repository.attach(input),\n        catch: (cause) => failure(\"ManagedDnsConnections.attach\", cause),\n      }),\n    connect: (input) =>\n      Effect.tryPromise({\n        try: () => repository.connect(input),\n        catch: (cause) => failure(\"ManagedDnsConnections.connect\", cause),\n      }),\n    detach: (input) =>\n      Effect.tryPromise({\n        try: () => repository.detach(input),\n        catch: (cause) => failure(\"ManagedDnsConnections.detach\", cause),\n      }),\n    disconnect: ({ connectionId, ownerId, revoke }) =>\n      Effect.tryPromise({\n        try: () =>\n          repository.disconnect({\n            connectionId,\n            ownerId,\n            revoke: (authorization) => Effect.runPromise(revoke(authorization)),\n          }),\n        catch: (cause) => failure(\"ManagedDnsConnections.disconnect\", cause),\n      }),\n    findConnection: (ownerId, authorizationId) =>\n      Effect.tryPromise({\n        try: () => repository.findConnection(ownerId, authorizationId),\n        catch: (cause) => failure(\"ManagedDnsConnections.findConnection\", cause),\n      }),\n    get: (authorizationId) =>\n      Effect.tryPromise({\n        try: () => repository.get(authorizationId),\n        catch: (cause) => failure(\"ManagedDnsConnections.get\", cause),\n      }),\n    getAttachment: (attachmentId) =>\n      Effect.tryPromise({\n        try: () => repository.getAttachment(attachmentId),\n        catch: (cause) => failure(\"ManagedDnsConnections.getAttachment\", cause),\n      }),\n    getByConnectionId: (connectionId) =>\n      Effect.tryPromise({\n        try: () => repository.getByConnectionId(connectionId),\n        catch: (cause) => failure(\"ManagedDnsConnections.getByConnectionId\", cause),\n      }),\n    listAttachments: (connectionId, ownerId) =>\n      Effect.tryPromise({\n        try: () => repository.listAttachments(connectionId, ownerId),\n        catch: (cause) => failure(\"ManagedDnsConnections.listAttachments\", cause),\n      }),\n    promoteEvidence: (authorizationId, evidence) =>\n      Effect.tryPromise({\n        try: () => repository.promoteEvidence(authorizationId, evidence),\n        catch: (cause) => failure(\"ManagedDnsConnections.promoteEvidence\", cause),\n      }),\n    recover: ({ authorizationId, revoke }) =>\n      Effect.tryPromise({\n        try: () =>\n          repository.recover({\n            authorizationId,\n            revoke: (authorization) => Effect.runPromise(revoke(authorization)),\n          }),\n        catch: (cause) => failure(\"ManagedDnsConnections.recover\", cause),\n      }),\n    rotate: (authorizationId, credential) =>\n      Effect.tryPromise({\n        try: () => repository.rotate(authorizationId, credential),\n        catch: (cause) => failure(\"ManagedDnsConnections.rotate\", cause),\n      }),\n  });\n\nexport const toAsync = (service: Lifecycle.Interface): AsyncInterface => ({\n  attach: (input) => Effect.runPromise(service.attach(input)),\n  connect: (input) => Effect.runPromise(service.connect(input)),\n  detach: (input) => Effect.runPromise(service.detach(input)),\n  disconnect: ({ connectionId, ownerId, revoke }) =>\n    Effect.runPromise(\n      service.disconnect({\n        connectionId,\n        ownerId,\n        revoke: (authorization) => Effect.promise(() => revoke(authorization)),\n      }),\n    ),\n  findConnection: (ownerId, authorizationId) =>\n    Effect.runPromise(service.findConnection(ownerId, authorizationId)),\n  get: (authorizationId) => Effect.runPromise(service.get(authorizationId)),\n  getAttachment: (attachmentId) => Effect.runPromise(service.getAttachment(attachmentId)),\n  getByConnectionId: (connectionId) => Effect.runPromise(service.getByConnectionId(connectionId)),\n  listAttachments: (connectionId, ownerId) =>\n    Effect.runPromise(service.listAttachments(connectionId, ownerId)),\n  promoteEvidence: (authorizationId, evidence) =>\n    Effect.runPromise(service.promoteEvidence(authorizationId, evidence)),\n  recover: ({ authorizationId, revoke }) =>\n    Effect.runPromise(\n      service.recover({\n        authorizationId,\n        revoke: (authorization) => Effect.promise(() => revoke(authorization)),\n      }),\n    ),\n  rotate: (authorizationId, credential) =>\n    Effect.runPromise(service.rotate(authorizationId, credential)),\n});\n\nexport const from = (repository: AsyncInterface): AsyncInterface => repository;\n\nexport { Error } from \"../auth/lifecycle-repository.ts\";\nexport type {\n  AttachmentResult,\n  DetachResult,\n  DisconnectResult,\n} from \"../auth/lifecycle-repository.ts\";\n"],"mappings":"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"}

package/dist/promise.d.mts

@@ -1,378 +0,0 @@
-import { $ as Schema$1, At as Schema$2, Ct as Txt, Dt as equals, J as Manifest, K as AsyncOAuthSubjectResolver, M as ProviderConnection, Mt as parse$1, N as ProviderTarget, Ot as parse, Pt as invalid_input_d_exports, St as Srv, Tt as data, W as ProviderAuthorization, X as OAuthClientConfiguration, Y as Method, Z as OAuthMethod, _ as provider_context_d_exports, _t as Ns, at as CreateResult, bt as RecordSchema, dt as Aaaa, et as TokenValidation, ft as Caa, gt as Mx, ht as Encoded, it as AsyncInterface, j as DomainAttachment, kt as DomainName, mt as DnsRecord, nt as Value, pt as Cname, rt as secret_d_exports, ut as A, vt as Observed, wt as Type, xt as RequirementMetadata, yt as Opaque } from "./connect-D-X8T9W8.mjs";
-import { $ as RestoreInput, A as Options$4, B as manifest$2, C as manifest$3, D as Fetch$1, E as AccountContext, F as OAuthMethodOptions, G as Interface$5, H as tokenMethod$2, I as RefreshCredentialOptions, J as Zone, K as ListZonesInput, L as SubjectResolverOptions, N as CredentialTarget, O as Interface$6, P as OAuthFlowOptions, Q as Resolution$1, R as TokenConnectionOptions, S as integrationMethod$1, T as Account$1, U as Account, V as oauthMethod$1, W as Fetch, X as Interface$4, Y as Credential, Z as ListTargetsInput, _ as ExchangeCodeOptions, b as IntegrationMethodOptions, c as Policy, f as Options$5, i as Result, j as Zone$1, k as ListZonesInput$1, m as Options$6, n as PublicDns$1, nt as selection_d_exports, o as DefaultOptions, q as Options$3, r as PublicDnsObservation, rt as diagnostic_d_exports, s as Observation, t as ProviderObservation, tt as zones_d_exports, u as Options$7, v as IntegrationCredential, w as tokenMethod$3, x as TokenConnectionOptions$1, y as IntegrationFlowOptions, z as TokenValidatorOptions } from "./verify-FpunAcM7.mjs";
-import { A as renderManualInstructions$1, C as DiscoverCreateInput$1, E as ResolvedCreateResult, F as PlanAuthorization, H as Source$1, I as Receipt, L as Schema$3, M as Authorization, N as DnsPlan, O as Target, P as Operation, R as encode, S as CreateResult$1, V as Candidate, _ as Receipt$1, d as Authorization$1, f as CreateError, g as Plan, h as PartialError, j as ApplyReceipt, m as Operation$1, n as AsyncInterface$1, o as Query, p as Error, r as AsyncResolution, t as Answer, u as ApplyError, w as ExactCreateInput$1, z as encodeReceipt } from "./resolver-xoSwyXDJ.mjs";
-import { a as managed_dns_connections_d_exports, i as AsyncInterface$2, n as Method$1, r as connection_d_exports, t as InteractiveFlow } from "./connection-Dp6ZdSo8.mjs";
-import { Data } from "effect";
-declare namespace dns_provider_d_exports {
-  export { CreateResult, AsyncInterface as Interface };
-}
-declare namespace provider_session_d_exports {
-  export { Interface$3 as Interface, ListTargetsInput, Resolution$1 as Resolution, fromEffect };
-}
-interface Interface$3 {
-  readonly providerId: string;
-  readonly listTargets: (input?: ListTargetsInput) => Promise<ReadonlyArray<ProviderTarget>>;
-  readonly resolveTarget: (domain: DomainName) => Promise<Resolution$1>;
-  readonly forTarget: (target: ProviderTarget) => Promise<AsyncInterface>;
-}
-declare const fromEffect: (session: Interface$4) => Interface$3;
-declare namespace dns_resolver_d_exports {
-  export { Answer, AsyncInterface$1 as Interface, Query, Resolution };
-}
-declare const Resolution: {
-  Schema: import("effect/Schema").TaggedUnion<{
-    readonly answer: import("effect/Schema").TaggedStruct<"answer", {
-      readonly answers: import("effect/Schema").$Array<import("effect/Schema").Struct<{
-        readonly data: import("effect/Schema").String;
-        readonly name: import("effect/Schema").decodeTo<import("effect/Schema").brand<import("effect/Schema").String, "DomainName">, import("effect/Schema").String, never, never>;
-        readonly ttl: import("effect/Schema").Int;
-        readonly type: import("effect/Schema").Literals<readonly ["A", "AAAA", "CNAME", "TXT", "MX", "CAA", "NS", "SRV"]>;
-      }>>;
-    }>;
-    readonly failure: import("effect/Schema").TaggedStruct<"failure", {
-      readonly message: import("effect/Schema").String;
-    }>;
-    readonly nodata: import("effect/Schema").TaggedStruct<"nodata", {}>;
-    readonly timeout: import("effect/Schema").TaggedStruct<"timeout", {}>;
-  }>;
-  answer: (input: Parameters<(input: {
-    readonly _tag?: "answer";
-    readonly answers: readonly {
-      readonly data: string;
-      readonly name: string & import("effect/Brand").Brand<"DomainName">;
-      readonly ttl: number;
-      readonly type: "A" | "AAAA" | "CAA" | "CNAME" | "MX" | "NS" | "SRV" | "TXT";
-    }[];
-  }, options?: import("effect/Schema").MakeOptions) => {
-    readonly _tag: "answer";
-    readonly answers: readonly {
-      readonly data: string;
-      readonly name: string & import("effect/Brand").Brand<"DomainName">;
-      readonly ttl: number;
-      readonly type: "A" | "AAAA" | "CAA" | "CNAME" | "MX" | "NS" | "SRV" | "TXT";
-    }[];
-  }>[0]) => {
-    readonly _tag: "answer";
-    readonly answers: readonly {
-      readonly data: string;
-      readonly name: string & import("effect/Brand").Brand<"DomainName">;
-      readonly ttl: number;
-      readonly type: "A" | "AAAA" | "CAA" | "CNAME" | "MX" | "NS" | "SRV" | "TXT";
-    }[];
-  };
-  failure: (input: Parameters<(input: {
-    readonly _tag?: "failure";
-    readonly message: string;
-  }, options?: import("effect/Schema").MakeOptions) => {
-    readonly _tag: "failure";
-    readonly message: string;
-  }>[0]) => {
-    readonly _tag: "failure";
-    readonly message: string;
-  };
-  nodata: () => {
-    readonly _tag: "nodata";
-  };
-  timeout: () => {
-    readonly _tag: "timeout";
-  };
-};
-type Resolution = AsyncResolution;
-declare namespace provider_auth_d_exports {
-  export { Manifest, Method, OAuthClientConfiguration, OAuthMethod, AsyncOAuthSubjectResolver as OAuthSubjectResolver, Schema$1 as Schema, TokenValidation, decode$1 as decode };
-}
-declare function decode$1(input: unknown): Promise<Manifest>;
-declare namespace zone_discovery_d_exports {
-  export { Candidate, Outcome, Source, discover, toEffectSource };
-}
-interface Source {
-  readonly listZones: (name: DomainName) => Promise<ReadonlyArray<Omit<Candidate, "providerId">>>;
-  readonly provider: AsyncInterface;
-}
-type Outcome = {
-  readonly _tag: "NotFound";
-  readonly domain: DomainName;
-} | {
-  readonly _tag: "Resolved";
-  readonly candidate: Candidate;
-} | {
-  readonly _tag: "SelectionRequired";
-  readonly candidates: ReadonlyArray<Candidate>;
-};
-declare function discover(input: {
-  readonly domain: DomainName;
-  readonly sources: ReadonlyArray<Source>;
-}): Promise<Outcome>;
-declare function toEffectSource(source: Source): Source$1;
-declare namespace dns_record_d_exports {
-  export { A, Aaaa, Caa, Cname, DnsRecord, Encoded, Mx, Ns, Observed, Opaque, RequirementMetadata, RecordSchema as Schema, Srv, Txt, Type, data, equals, parse };
-}
-declare namespace domain_name_d_exports {
-  export { DomainName, Schema$2 as Schema, parse$1 as parse };
-}
-declare namespace dns_plan_d_exports {
-  export { ApplyReceipt, Authorization, DnsPlan, Operation, PlanAuthorization, Receipt, Schema$3 as Schema, decode, decodeReceipt, encode, encodeReceipt };
-}
-declare function decode(input: unknown): Promise<DnsPlan>;
-declare function decodeReceipt(input: unknown): Promise<ApplyReceipt>;
-declare namespace deletion_d_exports {
-  export { ApplyError, Authorization$1 as Authorization, CreateError, Authorization$1 as DeletionAuthorization, Operation$1 as DeletionOperation, Plan as DeletionPlan, Receipt$1 as DeletionReceipt, Error, Operation$1 as Operation, PartialError, Plan, Receipt$1 as Receipt, apply$1 as apply, authorize$1 as authorize, create$1 as create };
-}
-declare function create$1(input: {
-  readonly plan: DnsPlan;
-  readonly provider: AsyncInterface;
-  readonly receipt: ApplyReceipt;
-  readonly ttlMs?: number;
-}): Promise<Plan>;
-declare function authorize$1(plan: Plan, operationIds?: ReadonlyArray<string>): Promise<Authorization$1>;
-declare function apply$1(input: {
-  readonly authorization: Authorization$1;
-  readonly plan: Plan;
-  readonly priorReceipt?: Receipt$1;
-  readonly provider: AsyncInterface;
-}): Promise<Receipt$1>;
-declare namespace cloudflare_auth_d_exports {
-  export { CredentialTarget, OAuthFlowOptions, OAuthMethodOptions, RefreshCredentialOptions, SubjectResolverOptions, TokenValidatorOptions, manifest$1 as manifest, oauthFlow, oauthMethod, refreshCredential, restore$1 as restore, subjectResolver, tokenConnectionMethod$1 as tokenConnectionMethod, tokenMethod$1 as tokenMethod, tokenValidator };
-}
-declare const manifest$1: typeof manifest$2;
-declare const oauthMethod: typeof oauthMethod$1;
-declare function refreshCredential(options: RefreshCredentialOptions): Promise<Credential>;
-declare function restore$1(options: RestoreInput & Pick<Options$3, "baseUrl" | "fetch">): Promise<Interface$5>;
-declare const tokenMethod$1: typeof tokenMethod$2;
-declare function subjectResolver(options: SubjectResolverOptions): AsyncOAuthSubjectResolver;
-/** Creates Cloudflare's OAuth implementation for the Promise connection facade. */
-declare function oauthFlow(options: OAuthFlowOptions): InteractiveFlow;
-/** Creates a Cloudflare token method for the Promise connection facade. */
-declare function tokenConnectionMethod$1(options: TokenConnectionOptions): Extract<Method$1, {
-  readonly _tag: "Token";
-}>;
-declare function tokenValidator(options: TokenValidatorOptions): (token: Value) => Promise<TokenValidation>;
-declare namespace cloudflare_d_exports {
-  export { Account, cloudflare_auth_d_exports as Auth, Fetch, Interface$2 as Interface, ListZonesInput, Options$3 as Options, Zone, discovery$1 as discovery, make$5 as make };
-}
-interface Interface$2 extends AsyncInterface {
-  readonly providerId: "cloudflare";
-  readonly forTarget: (target: ProviderTarget) => Promise<AsyncInterface>;
-  readonly listAccounts: () => Promise<ReadonlyArray<Account>>;
-  readonly listZones: (input?: ListZonesInput) => Promise<ReadonlyArray<Zone>>;
-  readonly listTargets: (input?: ListTargetsInput) => Promise<ReadonlyArray<ProviderTarget>>;
-  readonly resolveTarget: (domain: DomainName) => Promise<Resolution$1>;
-  readonly validateToken: () => Promise<TokenValidation>;
-}
-/** Creates a Promise-compatible facade over the Effect-native Cloudflare client. */
-declare function make$5(options: Options$3): Interface$2;
-/** Creates the optional Cloudflare discovery source for Promise consumers. */
-declare function discovery$1(options: Options$3): Source;
-declare namespace vercel_auth_d_exports {
-  export { ExchangeCodeOptions, IntegrationCredential, IntegrationFlowOptions, IntegrationMethodOptions, exchangeCode, integrationFlow, integrationMethod, manifest, restore, tokenConnectionMethod, tokenMethod };
-}
-declare const integrationMethod: typeof integrationMethod$1;
-declare const manifest: typeof manifest$3;
-declare function restore(options: RestoreInput & Pick<Options$4, "baseUrl" | "fetch">): Promise<Interface$6>;
-declare const tokenMethod: typeof tokenMethod$3;
-declare function exchangeCode(options: ExchangeCodeOptions): Promise<IntegrationCredential>;
-/** Creates Vercel Integration's implementation for the Promise connection facade. */
-declare function integrationFlow(options: IntegrationFlowOptions): InteractiveFlow;
-/** Creates a Vercel token method for the Promise connection facade. */
-declare function tokenConnectionMethod(options: TokenConnectionOptions$1): Extract<Method$1, {
-  readonly _tag: "Token";
-}>;
-declare namespace vercel_d_exports {
-  export { Account$1 as Account, AccountContext, vercel_auth_d_exports as Auth, Fetch$1 as Fetch, Interface$1 as Interface, ListZonesInput$1 as ListZonesInput, Options$4 as Options, Zone$1 as Zone, discovery, make$4 as make };
-}
-interface Interface$1 extends AsyncInterface {
-  readonly providerId: "vercel";
-  readonly forTarget: (target: ProviderTarget) => Promise<AsyncInterface>;
-  readonly listAccounts: () => Promise<ReadonlyArray<Account$1>>;
-  readonly listZones: (input?: ListZonesInput$1) => Promise<ReadonlyArray<Zone$1>>;
-  readonly listTargets: (input?: ListTargetsInput) => Promise<ReadonlyArray<ProviderTarget>>;
-  readonly resolveTarget: (domain: DomainName) => Promise<Resolution$1>;
-  readonly validateToken: () => Promise<TokenValidation>;
-}
-/** Creates a Promise-compatible facade over the Effect-native Vercel client. */
-declare function make$4(options: Options$4): Interface$1;
-/** Creates the optional Vercel discovery source for Promise consumers. */
-declare function discovery(options: Options$4): Source;
-declare namespace provisioning_d_exports {
-  export { CreateResult$1 as CreateResult, DiscoverCreateInput, ExactCreateInput, Target, apply, authorize, authorizeForConnection, create, renderManualInstructions };
-}
-interface ExactCreateInput extends ExactCreateInput$1 {
-  readonly provider: AsyncInterface;
-}
-interface DiscoverCreateInput extends DiscoverCreateInput$1 {
-  readonly sources: ReadonlyArray<Source>;
-}
-declare function create(input: ExactCreateInput): Promise<ResolvedCreateResult>;
-declare function create(input: DiscoverCreateInput): Promise<CreateResult$1>;
-declare function authorize(plan: DnsPlan, operationIds?: ReadonlyArray<string>, options?: {
-  readonly allowPartial?: boolean;
-}): Promise<PlanAuthorization>;
-declare function apply(input: {
-  readonly authorization: PlanAuthorization;
-  readonly plan: DnsPlan;
-  readonly provider: AsyncInterface;
-}): Promise<ApplyReceipt>;
-declare function authorizeForConnection(input: {
-  readonly allowPartial?: boolean;
-  readonly authorization: ProviderAuthorization;
-  readonly attachment: DomainAttachment;
-  readonly connection: ProviderConnection;
-  readonly domain: string;
-  readonly operationIds?: ReadonlyArray<string>;
-  readonly plan: DnsPlan;
-  readonly repository: AsyncInterface$2;
-}): Promise<PlanAuthorization>;
-declare const renderManualInstructions: typeof renderManualInstructions$1;
-declare namespace resolver_pool_d_exports {
-  export { Entry, Interface, Observation, Policy, defaultMake, make$3 as make };
-}
-interface Entry {
-  readonly id: string;
-  readonly resolver: AsyncInterface$1;
-  readonly timeoutMs?: number;
-}
-interface Interface {
-  readonly observe: (query: Query) => Promise<ReadonlyArray<Observation>>;
-}
-declare function make$3(entries: ReadonlyArray<Entry>): Interface;
-declare function defaultMake(options?: DefaultOptions): Interface;
-declare namespace verification_d_exports {
-  export { Config, Provider, ProviderObservation, PublicDns, PublicDnsObservation, Result, observe };
-}
-type PublicDns = PublicDns$1;
-declare const PublicDns: {
-  readonly $is: <Tag extends "Disabled" | "Enabled">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Disabled";
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Enabled";
-    readonly policy?: Policy;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Disabled" | "Enabled"]: (args: Extract<{
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly policy?: Policy;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly policy?: Policy;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Disabled" | "Enabled"]>>;
-    <Cases extends { readonly [Tag in "Disabled" | "Enabled"]: (args: Extract<{
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly policy?: Policy;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly policy?: Policy;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Disabled" | "Enabled"]>>;
-  };
-  readonly Disabled: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Disabled";
-  }, "_tag">;
-  readonly Enabled: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Enabled";
-    readonly policy?: Policy;
-  }, "_tag">;
-};
-type Provider = Data.TaggedEnum<{
-  Disabled: {};
-  Enabled: {
-    readonly provider: AsyncInterface;
-    readonly zone: DomainName;
-  };
-}>;
-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 provider: AsyncInterface;
-    readonly zone: DomainName;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Disabled" | "Enabled"]: (args: Extract<{
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly provider: AsyncInterface;
-      readonly zone: DomainName;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly provider: AsyncInterface;
-      readonly zone: DomainName;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Disabled" | "Enabled"]>>;
-    <Cases extends { readonly [Tag in "Disabled" | "Enabled"]: (args: Extract<{
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly provider: AsyncInterface;
-      readonly zone: DomainName;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Disabled";
-    } | {
-      readonly _tag: "Enabled";
-      readonly provider: AsyncInterface;
-      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 provider: AsyncInterface;
-    readonly zone: DomainName;
-  }, "_tag">;
-};
-interface Config {
-  readonly provider?: Provider;
-  readonly publicDns?: PublicDns;
-  readonly record: DnsRecord;
-  readonly resolvers?: ReadonlyArray<Entry>;
-}
-declare function observe(input: Config): Promise<Result>;
-declare namespace cloudflare_doh_d_exports {
-  export { Options$2 as Options, make$2 as make };
-}
-type Options$2 = Options$5;
-declare function make$2(options?: Options$2): AsyncInterface$1;
-declare namespace doh_d_exports {
-  export { Options$1 as Options, make$1 as make };
-}
-type Options$1 = Options$6;
-declare function make$1(options: Options$1): AsyncInterface$1;
-declare namespace google_doh_d_exports {
-  export { Options, make };
-}
-type Options = Options$7;
-declare function make(options?: Options): AsyncInterface$1;
-//#endregion
-//#region src/promise.d.ts
-/** The current package version from the package manifest. */
-declare const VERSION: string;
-//#endregion
-export { cloudflare_d_exports as Cloudflare, cloudflare_doh_d_exports as CloudflareDnsOverHttps, connection_d_exports as Connection, deletion_d_exports as Deletion, diagnostic_d_exports as Diagnostic, doh_d_exports as DnsOverHttps, dns_plan_d_exports as DnsPlan, type dns_provider_d_exports as DnsProvider, dns_record_d_exports as DnsRecord, dns_resolver_d_exports as DnsResolver, resolver_pool_d_exports as DnsResolverPool, domain_name_d_exports as DomainName, google_doh_d_exports as GoogleDnsOverHttps, invalid_input_d_exports as InvalidInput, managed_dns_connections_d_exports as ManagedDnsConnections, provider_auth_d_exports as ProviderAuth, provider_context_d_exports as ProviderContext, selection_d_exports as ProviderDiscovery, provider_session_d_exports as ProviderSession, provisioning_d_exports as Provisioning, secret_d_exports as Secret, VERSION, vercel_d_exports as Vercel, verification_d_exports as Verification, zone_discovery_d_exports as ZoneDiscovery, zones_d_exports as Zones };
-//# sourceMappingURL=promise.d.mts.map