domainkit 0.0.1 → 0.1.0-beta.1

package/dist/effect.mjs

@@ -0,0 +1,28 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { E as domain_name_exports, S as provider_exports, g as dns_record_exports, k as invalid_input_exports } from "./dns-record-C_KwGPLf.mjs";
+import { o as client_exports, s as make, t as auth_exports } from "./auth-Vi-hhXbV.mjs";
+import { C as plan_exports, F as zones_exports, L as token_exports, N as types_exports, P as selection_exports, V as manifest_exports, W as oauth_exports, Z as authorization_exports, _ as deletion_exports, a as doh_exports, ct as connection_exports, dt as version, n as verify_exports, q as canonical_json_exports, r as cloudflare_doh_exports, s as dns_data_exports, tt as connection_lifecycle_exports, y as connection_authorization_exports } from "./verify-Dvc-9Kgp.mjs";
+import { S as error_exports, c as oauth_state_exports, d as authorization_exports$1, h as credential_exports, i as resolver_exports, y as connection_exports$1 } from "./resolver-tEXpKxmH.mjs";
+import { l as secret_exports, n as make$1, r as auth_exports$1, t as client_exports$1 } from "./client-BnD7QLRF.mjs";
+import { n as receipt_exports } from "./receipt-CGSnfZQ6.mjs";
+//#region src/providers/cloudflare/index.ts
+var cloudflare_exports = /* @__PURE__ */ __exportAll({
+	Auth: () => auth_exports,
+	Client: () => client_exports,
+	make: () => make
+});
+//#endregion
+//#region src/providers/vercel/index.ts
+var vercel_exports = /* @__PURE__ */ __exportAll({
+	Auth: () => auth_exports$1,
+	Client: () => client_exports$1,
+	make: () => make$1
+});
+//#endregion
+//#region src/effect.ts
+/** The current package version from the package manifest. */
+const VERSION = version;
+//#endregion
+export { cloudflare_exports as Cloudflare, cloudflare_doh_exports as CloudflareDnsOverHttps, connection_exports as Connection, connection_authorization_exports as ConnectionAuthorization, connection_lifecycle_exports as ConnectionLifecycle, connection_exports$1 as ConnectionStore, credential_exports as CredentialStore, deletion_exports as Deletion, canonical_json_exports as Digest, dns_data_exports as DnsData, doh_exports as DnsOverHttps, types_exports as DnsPlan, provider_exports as DnsProvider, dns_record_exports as DnsRecord, resolver_exports as DnsResolver, domain_name_exports as DomainName, invalid_input_exports as InvalidInput, oauth_exports as OAuth, oauth_state_exports as OAuthStateStore, manifest_exports as ProviderAuth, authorization_exports as ProviderAuthorization, authorization_exports$1 as ProviderAuthorizationStore, selection_exports as ProviderDiscovery, plan_exports as Provisioning, receipt_exports as ReceiptStore, secret_exports as Secret, error_exports as Storage, token_exports as TokenConnection, VERSION, vercel_exports as Vercel, verify_exports as Verification, zones_exports as Zones };
+
+//# sourceMappingURL=effect.mjs.map

package/dist/effect.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.mjs","names":["packageJson.version"],"sources":["../src/providers/cloudflare/index.ts","../src/providers/vercel/index.ts","../src/effect.ts"],"sourcesContent":["export * as Auth from \"./auth.ts\";\nexport * as Client from \"./client.ts\";\n\nexport { make } from \"./client.ts\";\nexport type { Account, Fetch, Interface, ListZonesInput, Options, Zone } from \"./client.ts\";\n","export * as Auth from \"./auth.ts\";\nexport * as Client from \"./client.ts\";\n\nexport { make } from \"./client.ts\";\nexport type {\n  Account,\n  AccountContext,\n  Fetch,\n  Interface,\n  ListZonesInput,\n  Options,\n  Zone,\n} from \"./client.ts\";\n","import packageJson from \"../package.json\" with { type: \"json\" };\n\n/** The current package version from the package manifest. */\nexport const VERSION = packageJson.version;\n\nexport * as Connection from \"./auth/connection.ts\";\nexport * as ConnectionLifecycle from \"./auth/connection-lifecycle.ts\";\nexport * as ProviderAuthorization from \"./auth/authorization.ts\";\nexport * as OAuth from \"./auth/oauth.ts\";\nexport * as ProviderAuth from \"./auth/manifest.ts\";\nexport * as Secret from \"./auth/secret.ts\";\nexport * as TokenConnection from \"./auth/token.ts\";\nexport * as ProviderDiscovery from \"./discovery/selection.ts\";\nexport * as Zones from \"./discovery/zones.ts\";\nexport * as DnsRecord from \"./domain/dns-record.ts\";\nexport * as DomainName from \"./domain/domain-name.ts\";\nexport * as InvalidInput from \"./invalid-input.ts\";\nexport * as ConnectionAuthorization from \"./plan/connection-authorization.ts\";\nexport * as Digest from \"./plan/canonical-json.ts\";\nexport * as Deletion from \"./plan/deletion.ts\";\nexport * as Provisioning from \"./plan/plan.ts\";\nexport * as DnsPlan from \"./plan/types.ts\";\nexport * as DnsProvider from \"./provider/provider.ts\";\nexport * as Cloudflare from \"./providers/cloudflare/index.ts\";\nexport * as Vercel from \"./providers/vercel/index.ts\";\nexport * as ConnectionStore from \"./stores/connection.ts\";\nexport * as ProviderAuthorizationStore from \"./stores/authorization.ts\";\nexport * as CredentialStore from \"./stores/credential.ts\";\nexport * as OAuthStateStore from \"./stores/oauth-state.ts\";\nexport * as ReceiptStore from \"./stores/receipt.ts\";\nexport * as Storage from \"./stores/error.ts\";\nexport * as CloudflareDnsOverHttps from \"./verification/cloudflare-doh.ts\";\nexport * as DnsData from \"./verification/dns-data.ts\";\nexport * as DnsOverHttps from \"./verification/doh.ts\";\nexport * as DnsResolver from \"./verification/resolver.ts\";\nexport * as Verification from \"./verification/verify.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AEGA,MAAa,UAAUA"}

package/dist/index-CEzk2gbZ.d.mts

@@ -0,0 +1,94 @@
+import { R as DomainName, d as Value, g as Interface$1, h as Error, l as TokenValidation, n as IntegrationMethod, r as Manifest } from "./manifest-CP85ePFn.mjs";
+import { Effect } from "effect";
+declare namespace client_d_exports {
+  export { Account, AccountContext, Fetch, Interface, ListZonesInput, Options, Zone, make };
+}
+type Fetch = (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;
+};
+/** Configuration for an Effect-native Vercel authoritative-DNS client. */
+interface Options {
+  readonly baseUrl?: string;
+  /** Capabilities the host required when issuing or authorizing this credential. */
+  readonly capabilities: TokenValidation["capabilities"];
+  readonly context: AccountContext;
+  readonly fetch?: Fetch;
+  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 extends Interface$1 {
+  readonly listAccounts: () => Effect.Effect<ReadonlyArray<Account>, Error>;
+  readonly listZones: (input?: ListZonesInput) => Effect.Effect<ReadonlyArray<Zone>, Error>;
+  readonly validateToken: () => Effect.Effect<TokenValidation, Error>;
+}
+/** Creates an Effect-native Vercel client without owning the credential lifecycle. */
+declare function make(options: Options): Interface;
+declare namespace auth_d_exports {
+  export { ExchangeCodeOptions, IntegrationCredential, IntegrationMethodOptions, exchangeCode, integrationMethod, manifest, tokenMethod };
+}
+/** 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;
+  readonly fetch?: Fetch;
+  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 teamId?: never;
+  } | {
+    readonly _tag: "team";
+    readonly teamId: string;
+  };
+  installationId: string | null;
+  userId: string;
+}, Error, never>;
+declare namespace index_d_exports {
+  export { Account, AccountContext, auth_d_exports as Auth, client_d_exports as Client, Fetch, Interface, ListZonesInput, Options, Zone, make };
+}
+//#endregion
+export { make as _, auth_d_exports as a, tokenMethod as c, Fetch as d, Interface as f, client_d_exports as g, Zone as h, IntegrationMethodOptions as i, Account as l, Options as m, ExchangeCodeOptions as n, integrationMethod as o, ListZonesInput as p, IntegrationCredential as r, manifest as s, index_d_exports as t, AccountContext as u };
+//# sourceMappingURL=index-CEzk2gbZ.d.mts.map

package/dist/index-CS9Rl5LQ.d.mts

@@ -0,0 +1,71 @@
+import { R as DomainName, d as Value, g as Interface$1, h as Error, l as TokenValidation, o as OAuthMethod, r as Manifest, s as OAuthSubjectResolver } from "./manifest-CP85ePFn.mjs";
+import { Effect, Schema } from "effect";
+//#region src/providers/cloudflare/protocol.d.ts
+declare const Account$1: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly name: Schema.String;
+}>;
+interface Account$1 extends Schema.Schema.Type<typeof Account$1> {}
+declare namespace client_d_exports {
+  export { Account, Fetch, Interface, ListZonesInput, Options, Zone, make };
+}
+type Fetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/** Configuration for an Effect-native Cloudflare authoritative-DNS client. */
+interface Options {
+  readonly accountId: string;
+  readonly baseUrl?: string;
+  /** Capabilities the host required when issuing or authorizing this credential. */
+  readonly capabilities: TokenValidation["capabilities"];
+  readonly fetch?: Fetch;
+  readonly token: Value;
+  readonly tokenKind?: "account" | "user";
+}
+interface ListZonesInput {
+  readonly accountId?: string;
+  readonly name?: DomainName;
+}
+type Account = Account$1;
+/** A portable Cloudflare authoritative zone with normalized nameserver evidence. */
+interface Zone {
+  readonly accountId: string;
+  readonly id: string;
+  readonly name: DomainName;
+  readonly nameservers: ReadonlyArray<DomainName>;
+  readonly status: string | null;
+}
+interface Interface extends Interface$1 {
+  readonly listAccounts: () => Effect.Effect<ReadonlyArray<Account>, Error>;
+  readonly listZones: (input?: ListZonesInput) => Effect.Effect<ReadonlyArray<Zone>, Error>;
+  readonly validateToken: () => Effect.Effect<TokenValidation, Error>;
+}
+/** Creates an Effect-native Cloudflare client without owning the credential lifecycle. */
+declare function make(options: Options): Interface;
+declare namespace auth_d_exports {
+  export { OAuthMethodOptions, SubjectResolverOptions, manifest, oauthMethod, subjectResolver, tokenMethod, tokenValidator };
+}
+/** Describes Cloudflare's caller-created API-token authorization method. */
+declare function tokenMethod(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(options: OAuthMethodOptions): Manifest;
+interface SubjectResolverOptions extends Omit<Options, "token" | "tokenKind"> {}
+/** Resolves the Cloudflare account selected by a completed OAuth grant. */
+declare function subjectResolver(options: SubjectResolverOptions): OAuthSubjectResolver;
+/** Creates a host callback that validates a Cloudflare API token. */
+declare function tokenValidator(options: Omit<Options, "token">): (token: Value) => ReturnType<Interface["validateToken"]>;
+declare namespace index_d_exports {
+  export { Account, auth_d_exports as Auth, client_d_exports as Client, Fetch, Interface, ListZonesInput, Options, Zone, make };
+}
+//#endregion
+export { manifest as a, Account as c, ListZonesInput as d, Options as f, make as h, auth_d_exports as i, Fetch as l, client_d_exports as m, OAuthMethodOptions as n, oauthMethod as o, Zone as p, SubjectResolverOptions as r, tokenMethod as s, index_d_exports as t, Interface as u };
+//# sourceMappingURL=index-CS9Rl5LQ.d.mts.map

package/dist/index.d.mts

@@ -0,0 +1,173 @@
+import { A as Schema$1, C as DnsRecord, D as Observed, E as Ns, I as equals, L as parse, M as Txt, N as Type, O as Opaque, P as data, R as DomainName, S as Cname, T as Mx, U as invalid_input_d_exports, V as parse$1, a as OAuthClientConfiguration, b as Aaaa, c as Schema, d as Value, f as secret_d_exports, i as Method, j as Srv, k as RequirementMetadata, l as TokenValidation, m as CreateResult, o as OAuthMethod, p as AsyncInterface, r as Manifest, t as AsyncOAuthSubjectResolver, w as Encoded, x as Caa, y as A, z as Schema$2 } from "./manifest-CP85ePFn.mjs";
+import { n as cloudflare_d_exports } from "./cloudflare-tdjNS8vE.mjs";
+import { $ as Schema$4, G as OAuthContinuation, H as AuthorizationError, I as AsyncInterface$1, J as assertGrant, K as Schema$3, M as AsyncInterface$3, O as AsyncInterface$2, Q as ProviderAuthorization, S as encodeReceipt, U as Connection, W as Grant, X as encode, Z as Capability, _ as Operation, b as Schema$5, g as DnsPlan, h as Authorization, m as ApplyReceipt, n as AsyncInterface$4, o as Query, q as StoredCredential, r as AsyncResolution, t as Answer, tt as encode$1, u as AsyncInterface$6, v as PlanAuthorization, w as AsyncInterface$5, x as encode$2, y as Receipt } from "./resolver-BHPsADzE.mjs";
+import { A as updateGrant$1, C as Fetch$1, D as DetachResult, O as Error, S as BeginInput$1, _ as CreateInput$1, a as Options$3, b as zones_d_exports, c as Authorization$1, d as Operation$1, f as PartialError, l as CreateError, m as Receipt$1, p as Plan, r as Options$2, s as ApplyError, t as Result, u as Error$1, x as selection_d_exports, y as renderManualInstructions$1 } from "./verify-B80xCBh2.mjs";
+import { r as vercel_d_exports } from "./vercel-D-E2aqb1.mjs";
+declare namespace connection_d_exports {
+  export { AuthorizationError, Connection, Grant, OAuthContinuation, Schema$3 as Schema, StoredCredential, assertGrant, decode$3 as decode, encode };
+}
+declare function decode$3(input: unknown): Promise<Connection>;
+declare namespace connection_lifecycle_d_exports {
+  export { DetachResult, Error, detach, updateGrant };
+}
+declare function updateGrant(input: {
+  readonly connection: Parameters<typeof updateGrant$1>[0]["connection"];
+  readonly connectionStore: AsyncInterface$1;
+  readonly grant: Parameters<typeof updateGrant$1>[0]["grant"];
+}): Promise<Connection>;
+declare function detach(input: {
+  readonly authorizationStore: AsyncInterface$2;
+  readonly connectionId: string;
+  readonly connectionStore: AsyncInterface$1;
+  readonly credentialStore: AsyncInterface$3;
+  readonly revokeAuthorization: (authorization: ProviderAuthorization) => Promise<void>;
+}): Promise<DetachResult>;
+declare namespace provider_authorization_d_exports {
+  export { Capability, ProviderAuthorization, Schema$4 as Schema, decode$2 as decode, encode$1 as encode };
+}
+declare function decode$2(input: unknown): Promise<ProviderAuthorization>;
+declare namespace provider_auth_d_exports {
+  export { Manifest, Method, OAuthClientConfiguration, OAuthMethod, AsyncOAuthSubjectResolver as OAuthSubjectResolver, Schema, TokenValidation, decode$1 as decode };
+}
+declare function decode$1(input: unknown): Promise<Manifest>;
+declare namespace dns_record_d_exports {
+  export { A, Aaaa, Caa, Cname, DnsRecord, Encoded, Mx, Ns, Observed, Opaque, RequirementMetadata, Schema$1 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$5 as Schema, decode, decodeReceipt, encode$2 as encode, encodeReceipt };
+}
+declare function decode(input: unknown): Promise<DnsPlan>;
+declare function decodeReceipt(input: unknown): Promise<ApplyReceipt>;
+declare namespace deletion_d_exports {
+  export { ApplyError, Authorization$1 as Authorization, CreateError, Authorization$1 as DeletionAuthorization, Operation$1 as DeletionOperation, Plan as DeletionPlan, Receipt$1 as DeletionReceipt, Error$1 as 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 dns_provider_d_exports {
+  export { CreateResult, AsyncInterface as Interface };
+}
+declare namespace dns_resolver_d_exports {
+  export { Answer, AsyncInterface$4 as Interface, Query, AsyncResolution as Resolution };
+}
+declare namespace oauth_d_exports {
+  export { BeginInput, Fetch, begin, complete, refresh, revoke };
+}
+interface BeginInput extends BeginInput$1 {
+  readonly stateStore: AsyncInterface$5;
+}
+declare function begin(input: BeginInput): Promise<{
+  readonly authorizationUrl: URL;
+}>;
+declare function complete(input: {
+  readonly callbackUrl: URL;
+  readonly client: OAuthClientConfiguration;
+  readonly connectionStore: AsyncInterface$1;
+  readonly credentialStore: AsyncInterface$3;
+  readonly authorizationStore: AsyncInterface$2;
+  readonly fetch?: Fetch$1;
+  readonly providerId: string;
+  readonly resolveSubject: AsyncOAuthSubjectResolver;
+  readonly stateStore: AsyncInterface$5;
+}): Promise<{
+  readonly authorization: ProviderAuthorization;
+  readonly connection: Connection;
+}>;
+declare function refresh(input: {
+  readonly authorization: ProviderAuthorization;
+  readonly client: OAuthClientConfiguration;
+  readonly credentialStore: AsyncInterface$3;
+  readonly fetch?: Fetch$1;
+  readonly method: OAuthMethod;
+}): Promise<void>;
+declare function revoke(input: {
+  readonly authorization: ProviderAuthorization;
+  readonly client: OAuthClientConfiguration;
+  readonly credentialStore: AsyncInterface$3;
+  readonly fetch?: Fetch$1;
+  readonly method: OAuthMethod;
+}): Promise<void>;
+type Fetch = Fetch$1;
+declare namespace provisioning_d_exports {
+  export { CreateInput, apply, authorize, authorizeForConnection, create, renderManualInstructions };
+}
+interface CreateInput extends CreateInput$1 {
+  readonly provider: AsyncInterface;
+}
+declare function create(input: CreateInput): Promise<DnsPlan>;
+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 connection: Connection;
+  readonly domain: string;
+  readonly operationIds?: ReadonlyArray<string>;
+  readonly plan: DnsPlan;
+}): Promise<PlanAuthorization>;
+declare const renderManualInstructions: typeof renderManualInstructions$1;
+declare namespace stores_d_exports {
+  export { AsyncInterface$1 as Connection, AsyncInterface$3 as Credential, AsyncInterface$5 as OAuthState, AsyncInterface$2 as ProviderAuthorization, AsyncInterface$6 as Receipt };
+}
+declare namespace token_d_exports {
+  export { connect };
+}
+declare function connect(input: {
+  readonly connectionStore: AsyncInterface$1;
+  readonly credentialStore: AsyncInterface$3;
+  readonly authorizationStore: AsyncInterface$2;
+  readonly grant: Grant;
+  readonly ownerId: string;
+  readonly providerId: string;
+  readonly subjectId: string;
+  readonly token: Value;
+  readonly validate: (token: Value) => Promise<TokenValidation>;
+}): Promise<{
+  readonly authorization: ProviderAuthorization;
+  readonly connection: Connection;
+}>;
+declare namespace verification_d_exports {
+  export { record };
+}
+declare function record(input: {
+  readonly provider: AsyncInterface;
+  readonly record: DnsRecord;
+  readonly resolver: AsyncInterface$4;
+  readonly zone: DomainName;
+}): Promise<Result>;
+declare namespace cloudflare_doh_d_exports {
+  export { Options$1 as Options, make$1 as make };
+}
+type Options$1 = Options$2;
+declare function make$1(options?: Options$1): AsyncInterface$4;
+declare namespace doh_d_exports {
+  export { Options, make };
+}
+type Options = Options$3;
+declare function make(options: Options): AsyncInterface$4;
+//#endregion
+//#region src/index.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, connection_lifecycle_d_exports as ConnectionLifecycle, deletion_d_exports as Deletion, doh_d_exports as DnsOverHttps, dns_plan_d_exports as DnsPlan, type dns_provider_d_exports as DnsProvider, dns_record_d_exports as DnsRecord, type dns_resolver_d_exports as DnsResolver, domain_name_d_exports as DomainName, invalid_input_d_exports as InvalidInput, oauth_d_exports as OAuth, provider_auth_d_exports as ProviderAuth, provider_authorization_d_exports as ProviderAuthorization, selection_d_exports as ProviderDiscovery, provisioning_d_exports as Provisioning, secret_d_exports as Secret, type stores_d_exports as Stores, token_d_exports as TokenConnection, VERSION, vercel_d_exports as Vercel, verification_d_exports as Verification, zones_d_exports as Zones };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,261 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { D as parse$1, O as Error$1, _ as equals, a as Mx, c as Opaque, d as Srv, f as Txt, i as Cname, k as invalid_input_exports, l as RequirementMetadata, m as data, n as Aaaa, o as Ns, p as Type, r as Caa, s as Observed, t as A, u as Schema$1, v as parse, w as Schema$2, x as layerFromAsync, y as Error$2 } from "./dns-record-C_KwGPLf.mjs";
+import { t as cloudflare_exports } from "./cloudflare-C6ryPlCZ.mjs";
+import { $ as encode$1, A as decodeReceipt$1, B as decode$6, D as Receipt, E as Operation, F as zones_exports, G as refresh$1, H as begin$1, I as connect$1, J as webCryptoLayer, K as revoke$1, M as encodeReceipt, O as Schema$6, P as selection_exports, Q as decode$5, R as Method, S as create$3, T as Authorization, U as complete$1, X as Schema$4, Y as Capability, at as Grant, b as apply$3, c as Authorization$1, d as PartialError, dt as version, et as Error$3, f as Plan, g as create$2, h as authorize$2, i as toAsync, it as AuthorizationError, j as encode$2, k as decode$7, l as Error$4, lt as decode$4, m as apply$2, nt as detach$1, o as toAsync$1, ot as Schema$3, p as Receipt$1, rt as updateGrant$1, st as assertGrant, t as record$1, u as Operation$1, ut as encode, v as authorize$4, w as renderManualInstructions$1, x as authorize$3, z as Schema$5 } from "./verify-Dvc-9Kgp.mjs";
+import { b as layerFromAsync$1, f as layerFromAsync$2, g as layerFromAsync$3, r as layerFromAsync$5, s as layerFromAsync$4 } from "./resolver-tEXpKxmH.mjs";
+import { l as secret_exports } from "./client-BnD7QLRF.mjs";
+import { n as vercel_exports } from "./vercel-DD89DCqH.mjs";
+import { Effect, Layer } from "effect";
+//#region src/promise/connection.ts
+var connection_exports = /* @__PURE__ */ __exportAll({
+	AuthorizationError: () => AuthorizationError,
+	Grant: () => Grant,
+	Schema: () => Schema$3,
+	assertGrant: () => assertGrant,
+	decode: () => decode$3,
+	encode: () => encode
+});
+function decode$3(input) {
+	return Effect.runPromise(decode$4(input));
+}
+//#endregion
+//#region src/promise/connection-lifecycle.ts
+var connection_lifecycle_exports = /* @__PURE__ */ __exportAll({
+	Error: () => Error$3,
+	detach: () => detach,
+	updateGrant: () => updateGrant
+});
+function updateGrant(input) {
+	return Effect.runPromise(updateGrant$1({
+		connection: input.connection,
+		grant: input.grant
+	}).pipe(Effect.provide(layerFromAsync$1(input.connectionStore))));
+}
+function detach(input) {
+	return Effect.runPromise(detach$1({
+		connectionId: input.connectionId,
+		revokeAuthorization: (authorization) => Effect.tryPromise({
+			try: () => input.revokeAuthorization(authorization),
+			catch: (cause) => new Error$3({ message: cause instanceof globalThis.Error ? cause.message : String(cause) })
+		})
+	}).pipe(Effect.provide(Layer.mergeAll(layerFromAsync$2(input.authorizationStore), layerFromAsync$1(input.connectionStore), layerFromAsync$3(input.credentialStore)))));
+}
+//#endregion
+//#region src/promise/provider-authorization.ts
+var provider_authorization_exports = /* @__PURE__ */ __exportAll({
+	Capability: () => Capability,
+	Schema: () => Schema$4,
+	decode: () => decode$2,
+	encode: () => encode$1
+});
+function decode$2(input) {
+	return Effect.runPromise(decode$5(input));
+}
+//#endregion
+//#region src/promise/provider-auth.ts
+var provider_auth_exports = /* @__PURE__ */ __exportAll({
+	Method: () => Method,
+	Schema: () => Schema$5,
+	decode: () => decode$1
+});
+function decode$1(input) {
+	return Effect.runPromise(decode$6(input));
+}
+//#endregion
+//#region src/promise/dns-record.ts
+var dns_record_exports = /* @__PURE__ */ __exportAll({
+	A: () => A,
+	Aaaa: () => Aaaa,
+	Caa: () => Caa,
+	Cname: () => Cname,
+	Mx: () => Mx,
+	Ns: () => Ns,
+	Observed: () => Observed,
+	Opaque: () => Opaque,
+	RequirementMetadata: () => RequirementMetadata,
+	Schema: () => Schema$1,
+	Srv: () => Srv,
+	Txt: () => Txt,
+	Type: () => Type,
+	data: () => data,
+	equals: () => equals,
+	parse: () => parse
+});
+//#endregion
+//#region src/promise/domain-name.ts
+var domain_name_exports = /* @__PURE__ */ __exportAll({
+	Schema: () => Schema$2,
+	parse: () => parse$1
+});
+//#endregion
+//#region src/promise/dns-plan.ts
+var dns_plan_exports = /* @__PURE__ */ __exportAll({
+	Authorization: () => Authorization,
+	Operation: () => Operation,
+	Receipt: () => Receipt,
+	Schema: () => Schema$6,
+	decode: () => decode,
+	decodeReceipt: () => decodeReceipt,
+	encode: () => encode$2,
+	encodeReceipt: () => encodeReceipt
+});
+function decode(input) {
+	return Effect.runPromise(decode$7(input));
+}
+function decodeReceipt(input) {
+	return Effect.runPromise(decodeReceipt$1(input));
+}
+//#endregion
+//#region src/promise/deletion.ts
+var deletion_exports = /* @__PURE__ */ __exportAll({
+	Authorization: () => Authorization$1,
+	Error: () => Error$4,
+	Operation: () => Operation$1,
+	PartialError: () => PartialError,
+	Plan: () => Plan,
+	Receipt: () => Receipt$1,
+	apply: () => apply$1,
+	authorize: () => authorize$1,
+	create: () => create$1
+});
+function create$1(input) {
+	return Effect.runPromise(create$2({
+		plan: input.plan,
+		receipt: input.receipt,
+		...input.ttlMs === void 0 ? {} : { ttlMs: input.ttlMs }
+	}).pipe(Effect.provide(Layer.merge(layerFromAsync(input.provider), webCryptoLayer))));
+}
+function authorize$1(plan, operationIds) {
+	return Effect.runPromise(authorize$2(plan, operationIds).pipe(Effect.provide(webCryptoLayer)));
+}
+function apply$1(input) {
+	return Effect.runPromise(apply$2({
+		authorization: input.authorization,
+		plan: input.plan,
+		...input.priorReceipt === void 0 ? {} : { priorReceipt: input.priorReceipt }
+	}).pipe(Effect.provide(Layer.merge(layerFromAsync(input.provider), webCryptoLayer))));
+}
+//#endregion
+//#region src/promise/oauth.ts
+var oauth_exports = /* @__PURE__ */ __exportAll({
+	begin: () => begin,
+	complete: () => complete,
+	refresh: () => refresh,
+	revoke: () => revoke
+});
+function begin(input) {
+	const { stateStore, ...programInput } = input;
+	return Effect.runPromise(begin$1(programInput).pipe(Effect.provide(Layer.merge(layerFromAsync$4(stateStore), webCryptoLayer))));
+}
+function complete(input) {
+	return Effect.runPromise(complete$1({
+		callbackUrl: input.callbackUrl,
+		client: input.client,
+		...input.fetch === void 0 ? {} : { fetch: input.fetch },
+		providerId: input.providerId,
+		resolveSubject: (tokens, accessToken) => Effect.tryPromise({
+			try: () => input.resolveSubject(tokens, accessToken),
+			catch: (cause) => providerFailure(input.providerId, "resolveSubject", cause)
+		})
+	}).pipe(Effect.provide(Layer.mergeAll(layerFromAsync$4(input.stateStore), layerFromAsync$2(input.authorizationStore), layerFromAsync$1(input.connectionStore), layerFromAsync$3(input.credentialStore), webCryptoLayer))));
+}
+function refresh(input) {
+	return Effect.runPromise(refresh$1({
+		client: input.client,
+		authorization: input.authorization,
+		...input.fetch === void 0 ? {} : { fetch: input.fetch },
+		method: input.method
+	}).pipe(Effect.provide(layerFromAsync$3(input.credentialStore))));
+}
+function revoke(input) {
+	return Effect.runPromise(revoke$1({
+		client: input.client,
+		authorization: input.authorization,
+		...input.fetch === void 0 ? {} : { fetch: input.fetch },
+		method: input.method
+	}).pipe(Effect.provide(layerFromAsync$3(input.credentialStore))));
+}
+function providerFailure(providerId, operation, cause) {
+	return cause instanceof Error$1 || cause instanceof Error$2 ? cause : new Error$2({
+		cause,
+		message: cause instanceof Error ? cause.message : "Provider callback failed",
+		operation,
+		providerId
+	});
+}
+//#endregion
+//#region src/promise/provisioning.ts
+var provisioning_exports = /* @__PURE__ */ __exportAll({
+	apply: () => apply,
+	authorize: () => authorize,
+	authorizeForConnection: () => authorizeForConnection,
+	create: () => create,
+	renderManualInstructions: () => renderManualInstructions
+});
+function create(input) {
+	const { provider, ...programInput } = input;
+	return Effect.runPromise(create$3(programInput).pipe(Effect.provide(Layer.merge(layerFromAsync(provider), webCryptoLayer))));
+}
+function authorize(plan, operationIds, options = {}) {
+	return Effect.runPromise(authorize$3(plan, operationIds, options).pipe(Effect.provide(webCryptoLayer)));
+}
+function apply(input) {
+	return Effect.runPromise(apply$3({
+		authorization: input.authorization,
+		plan: input.plan
+	}).pipe(Effect.provide(Layer.merge(layerFromAsync(input.provider), webCryptoLayer))));
+}
+function authorizeForConnection(input) {
+	return Effect.runPromise(authorize$4(input).pipe(Effect.provide(webCryptoLayer)));
+}
+const renderManualInstructions = renderManualInstructions$1;
+//#endregion
+//#region src/promise/token.ts
+var token_exports = /* @__PURE__ */ __exportAll({ connect: () => connect });
+function connect(input) {
+	return Effect.runPromise(connect$1({
+		grant: input.grant,
+		ownerId: input.ownerId,
+		providerId: input.providerId,
+		subjectId: input.subjectId,
+		token: input.token,
+		validate: (token) => Effect.tryPromise({
+			try: () => input.validate(token),
+			catch: (cause) => cause instanceof Error$1 || cause instanceof Error$2 ? cause : new Error$2({
+				cause,
+				message: cause instanceof Error ? cause.message : "Token validation failed",
+				operation: "validateToken",
+				providerId: input.providerId
+			})
+		})
+	}).pipe(Effect.provide(Layer.mergeAll(layerFromAsync$1(input.connectionStore), layerFromAsync$2(input.authorizationStore), layerFromAsync$3(input.credentialStore), webCryptoLayer))));
+}
+//#endregion
+//#region src/promise/verification.ts
+var verification_exports = /* @__PURE__ */ __exportAll({ record: () => record });
+function record(input) {
+	return Effect.runPromise(record$1({
+		record: input.record,
+		zone: input.zone
+	}).pipe(Effect.provide(Layer.merge(layerFromAsync(input.provider), layerFromAsync$5(input.resolver)))));
+}
+//#endregion
+//#region src/promise/cloudflare-doh.ts
+var cloudflare_doh_exports = /* @__PURE__ */ __exportAll({ make: () => make$1 });
+function make$1(options = {}) {
+	return toAsync(options);
+}
+//#endregion
+//#region src/promise/doh.ts
+var doh_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+function make(options) {
+	return toAsync$1(options);
+}
+//#endregion
+//#region src/index.ts
+/** The current package version from the package manifest. */
+const VERSION = version;
+//#endregion
+export { cloudflare_exports as Cloudflare, cloudflare_doh_exports as CloudflareDnsOverHttps, connection_exports as Connection, connection_lifecycle_exports as ConnectionLifecycle, deletion_exports as Deletion, doh_exports as DnsOverHttps, dns_plan_exports as DnsPlan, dns_record_exports as DnsRecord, domain_name_exports as DomainName, invalid_input_exports as InvalidInput, oauth_exports as OAuth, provider_auth_exports as ProviderAuth, provider_authorization_exports as ProviderAuthorization, selection_exports as ProviderDiscovery, provisioning_exports as Provisioning, secret_exports as Secret, token_exports as TokenConnection, VERSION, vercel_exports as Vercel, verification_exports as Verification, zones_exports as Zones };
+
+//# sourceMappingURL=index.mjs.map