domainkit 0.8.0 → 0.9.1

package/dist/types/entry/server.d.ts

@@ -0,0 +1,2 @@
+/** domainkit/server */
+export * as Server from "../Server.ts";

package/dist/types/entry/testing.d.ts

@@ -0,0 +1,3 @@
+/** domainkit/testing */
+export { VERSION } from "../index.ts";
+export * as Testing from "../Testing.ts";

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+/** The current package version from the package manifest. */
+export declare const VERSION: string;
+export * as Approval from "./Approval.ts";
+export * as Cleanup from "./Cleanup.ts";
+export * as Cloudflare from "./Cloudflare.ts";
+export * as Connect from "./Connect.ts";
+export * as Custody from "./Custody.ts";
+export * as DnsRecord from "./DnsRecord.ts";
+export * as DomainKit from "./DomainKit.ts";
+export * as DomainName from "./DomainName.ts";
+export * as Plan from "./Plan.ts";
+export * as Principal from "./Principal.ts";
+export * as Provider from "./Provider.ts";
+export * as Providers from "./Providers.ts";
+export * as Provision from "./Provision.ts";
+export * as Reason from "./Reason.ts";
+export * as Receipt from "./Receipt.ts";
+export * as Resolver from "./Resolver.ts";
+export * as Storage from "./Storage.ts";
+export * as Vercel from "./Vercel.ts";
+export * as Verify from "./Verify.ts";

package/dist/types/internal/aes.d.ts

@@ -0,0 +1,8 @@
+import { Effect, Redacted } from "effect";
+import * as Errors from "./error.ts";
+/** Accepts a 32-byte key as base64, base64url, or hex. */
+export declare const decodeKey: (encoded: string) => Uint8Array<ArrayBuffer> | null;
+export declare const importKey: (raw: Uint8Array<ArrayBuffer>) => Effect.Effect<CryptoKey, Errors.DomainKitError>;
+export declare const seal: (key: CryptoKey, plaintext: Redacted.Redacted<string>) => Effect.Effect<string, Errors.DomainKitError>;
+export declare const open: (key: CryptoKey, envelope: string) => Effect.Effect<Redacted.Redacted<string>, Errors.DomainKitError>;
+export declare const generateKey: () => string;

package/dist/types/internal/attempts.d.ts

@@ -0,0 +1,40 @@
+import { Effect } from "effect";
+import * as Approval from "../Approval.ts";
+import * as Connect from "../Connect.ts";
+import * as DnsRecord from "../DnsRecord.ts";
+import * as Errors from "./error.ts";
+import * as Plan from "../Plan.ts";
+import * as Principal from "../Principal.ts";
+import type * as Provider from "../Provider.ts";
+import * as Receipt from "../Receipt.ts";
+import * as Storage from "../Storage.ts";
+type Fx<A> = Effect.Effect<A, Errors.DomainKitError, Principal.Service>;
+export interface ApproveOptions {
+    readonly operationIds?: ReadonlyArray<Plan.OperationId>;
+    readonly allowPartial?: boolean;
+}
+export interface PolicyShape {
+    readonly planTtlMs: number;
+    readonly applyLeaseMs: number;
+}
+/** Every requirement must sit at or below the attached domain; other tenants share the zone. */
+export declare const assertWithin: (attachment: Storage.Attachment, records: ReadonlyArray<DnsRecord.Model>) => Effect.Effect<void, Errors.DomainKitError>;
+/** Shared plan -> approve -> apply machinery for provisioning and cleanup attempts. */
+export declare const make: (storage: Storage.Interface, connect: Connect.Interface, kind: Plan.Kind) => {
+    record: (input: {
+        readonly attachment: Storage.Attachment;
+        readonly target: Provider.Target;
+        readonly operations: ReadonlyArray<Plan.Operation>;
+        readonly ttlMs: number;
+        readonly sourceReceiptId: Receipt.ReceiptId | null;
+    }) => Fx<Plan.Model>;
+    approve: (plan: Plan.Model | Plan.PlanId, options?: ApproveOptions) => Fx<Approval.Model>;
+    reject: (plan: Plan.Model | Plan.PlanId, options?: {
+        readonly reason?: string;
+    }) => Fx<Storage.Attempt>;
+    apply: (approval: Approval.Model | Approval.ApprovalId, policy: PolicyShape) => Fx<Receipt.Model>;
+    attemptOf: (plan: Plan.Model | Plan.PlanId) => Fx<Storage.Attempt>;
+};
+/** Read one receipt-proven record back; anything but an exact match is a conflict. */
+export declare const cleanupOperation: (dns: Provider.Dns, zone: string, id: Plan.OperationId, record: DnsRecord.Model, providerRecordId: string) => Effect.Effect<Plan.Delete | Plan.Conflict, Errors.DomainKitError>;
+export {};

package/dist/types/internal/cloudflare/client.d.ts

@@ -0,0 +1,23 @@
+import { DateTime, Effect } from "effect";
+import * as Errors from "../error.ts";
+import type * as Provider from "../../Provider.ts";
+import { type Fetch } from "../http.ts";
+import * as Protocol from "./protocol.ts";
+export declare const provider = "cloudflare";
+export interface Options {
+    readonly token: string;
+    readonly fetch: Fetch;
+    readonly baseUrl: string;
+}
+type Fx<A> = Effect.Effect<A, Errors.DomainKitError>;
+/** Every zone the credential can see, across accounts; internal zones cannot host records. */
+export declare const listZones: (options: Options, accountId?: string) => Fx<ReadonlyArray<Protocol.Zone>>;
+/** Token expiry from the verify endpoint; `null` when the token never expires or verification is unavailable. */
+/** Token status and expiry from a verify endpoint; an inactive token is `Unauthenticated`. */
+export declare const verifyToken: (options: Options, path: string) => Fx<DateTime.Utc | null>;
+export declare const tokenExpiry: (options: Options, accountId: string | null) => Fx<{
+    readonly expiresAt: DateTime.Utc | null;
+    readonly kind: "user" | "account";
+}>;
+export declare const dns: (options: Options, zoneId: string) => Provider.Dns;
+export {};

package/dist/types/internal/cloudflare/protocol.d.ts

@@ -0,0 +1,71 @@
+import { Schema as S } from "effect";
+export declare const ErrorDetail: S.Struct<{
+    readonly code: S.Number;
+    readonly message: S.String;
+}>;
+export declare const ResultInfo: S.Struct<{
+    readonly count: S.optionalKey<S.Number>;
+    readonly page: S.optionalKey<S.Number>;
+    readonly per_page: S.optionalKey<S.Number>;
+    readonly total_count: S.optionalKey<S.Number>;
+    readonly total_pages: S.optionalKey<S.Number>;
+}>;
+export declare const BaseEnvelope: S.Struct<{
+    readonly errors: S.$Array<S.Struct<{
+        readonly code: S.Number;
+        readonly message: S.String;
+    }>>;
+    readonly messages: S.optionalKey<S.$Array<S.Struct<{
+        readonly code: S.optionalKey<S.Number>;
+        readonly message: S.String;
+    }>>>;
+    readonly success: S.Boolean;
+}>;
+export declare const Account: S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+}>;
+export type Account = typeof Account.Type;
+export declare const Zone: S.Struct<{
+    readonly account: S.Struct<{
+        readonly id: S.String;
+        readonly name: S.String;
+    }>;
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly name_servers: S.optionalKey<S.$Array<S.String>>;
+    readonly status: S.optionalKey<S.String>;
+    readonly type: S.optionalKey<S.String>;
+}>;
+export type Zone = typeof Zone.Type;
+export declare const Record: S.Struct<{
+    readonly content: S.optionalKey<S.String>;
+    readonly data: S.optionalKey<S.Unknown>;
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly priority: S.optionalKey<S.Number>;
+    readonly proxied: S.optionalKey<S.Boolean>;
+    readonly ttl: S.Number;
+    readonly type: S.String;
+}>;
+export type Record = typeof Record.Type;
+export declare const Token: S.Struct<{
+    readonly expires_on: S.optionalKey<S.NullOr<S.String>>;
+    readonly id: S.String;
+    readonly status: S.String;
+}>;
+export declare const Envelope: S.Struct<{
+    readonly errors: S.$Array<S.Struct<{
+        readonly code: S.Number;
+        readonly message: S.String;
+    }>>;
+    readonly result: S.Unknown;
+    readonly result_info: S.optionalKey<S.Struct<{
+        readonly count: S.optionalKey<S.Number>;
+        readonly page: S.optionalKey<S.Number>;
+        readonly per_page: S.optionalKey<S.Number>;
+        readonly total_count: S.optionalKey<S.Number>;
+        readonly total_pages: S.optionalKey<S.Number>;
+    }>>;
+    readonly success: S.Boolean;
+}>;

package/dist/types/internal/cloudflare/records.d.ts

@@ -0,0 +1,8 @@
+import { Effect } from "effect";
+import * as DnsRecord from "../../DnsRecord.ts";
+import type * as Provider from "../../Provider.ts";
+import type * as Protocol from "./protocol.ts";
+/** Records DomainKit cannot model, or cannot parse, come back opaque so plans never touch them. */
+export declare const decode: (record: Protocol.Record) => Effect.Effect<Provider.ObservedRecord>;
+export declare const encode: (record: DnsRecord.Model) => Record<string, unknown>;
+export declare const isWithinZone: (name: string, zone: string) => boolean;

package/dist/types/internal/config.d.ts

@@ -0,0 +1,4 @@
+import { Config, Effect } from "effect";
+import * as Errors from "./error.ts";
+/** Accept a literal or a `Config`; config failures surface as `InvalidInput` on `field`. */
+export declare const resolve: <A>(value: A | Config.Config<A>, field: string) => Effect.Effect<A, Errors.DomainKitError>;

package/dist/types/internal/conformance/provider.d.ts

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+import * as Errors from "../error.ts";
+import * as Provider from "../../Provider.ts";
+export declare const cases: readonly ["create-readback-cleanup", "exact-noop", "conflict", "stale-plan", "partial-apply-cleanup"];
+export type Case = (typeof cases)[number];
+/**
+ * Runs create/readback/cleanup, exact-noop, conflict, stale-plan, and partial-apply against a
+ * real provider definition, through the same Provision and Cleanup services hosts use.
+ */
+export declare const provider: (definition: Provider.Definition, credential: Provider.Credential, zone: string, options?: {
+    readonly prefix?: string;
+}) => Effect.Effect<void, Errors.DomainKitError>;

package/dist/types/internal/conformance/storage.d.ts

@@ -0,0 +1,14 @@
+import { Effect, Layer } from "effect";
+import * as Storage from "../../Storage.ts";
+export interface Case {
+    readonly name: string;
+    readonly run: Effect.Effect<void, unknown>;
+}
+export interface Options {
+    /** Register each case with a test runner, e.g. vitest's `it`. */
+    readonly it?: (name: string, run: () => Promise<void>) => void;
+}
+/** Every invariant a `Storage` implementation must hold. Each case runs against a fresh layer. */
+export declare const cases: (layer: Layer.Layer<Storage.Service, unknown>) => ReadonlyArray<Case>;
+/** Registers every case with `options.it` when given; always returns the cases. */
+export declare const storage: (layer: Layer.Layer<Storage.Service, unknown>, options?: Options) => ReadonlyArray<Case>;

package/dist/types/internal/digest.d.ts

@@ -0,0 +1,10 @@
+import { Effect, Schema } from "effect";
+import * as Errors from "./error.ts";
+export type Json = null | boolean | number | string | ReadonlyArray<Json> | {
+    readonly [key: string]: Json;
+};
+/** Deterministic JSON serialization for already schema-encoded protocol values. */
+export declare function stringify(value: unknown): string;
+export declare const sha256Hex: (value: string) => Effect.Effect<string, Errors.DomainKitError>;
+/** Digest of the canonical JSON encoding of `value` under `schema`. */
+export declare const sha256Encoded: <S extends Schema.ConstraintEncoder<unknown>>(schema: S, value: S["Type"]) => Effect.Effect<string, Errors.DomainKitError>;

package/dist/types/internal/doh.d.ts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import * as DnsRecord from "../DnsRecord.ts";
+import * as Errors from "./error.ts";
+import type { Fetch } from "./http.ts";
+export interface Answer {
+    readonly records: ReadonlyArray<DnsRecord.Observed>;
+    readonly negative: boolean;
+    readonly ttl: number | null;
+}
+/** One RFC 8484 wire-format query; the caller applies the timeout. */
+export declare const query: (input: {
+    readonly resolver: string;
+    readonly url: string;
+    readonly fetch: Fetch;
+    readonly name: string;
+    readonly type: DnsRecord.Type;
+    /** Host-supplied abort, combined with the fiber's own interruption signal. */
+    readonly signal?: AbortSignal | undefined;
+}) => Effect.Effect<Answer, Errors.DomainKitError>;

package/dist/types/internal/error.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The one error every DomainKit operation fails with, published as `DomainKit.Error`. Hosts match
+ * on `reason`; `category`, `isRetryable`, and `httpStatus` derive from it. Modelled on `SqlError`
+ * and `HttpClientError` in Effect.
+ */
+import { Effect, Schema } from "effect";
+import * as Reason from "../Reason.ts";
+export type Category = "request" | "auth" | "plan" | "provider" | "storage" | "internal";
+declare const DomainKitError_base: Schema.Class<DomainKitError, Schema.TaggedStruct<"DomainKitError", {
+    readonly reason: Schema.suspend<Schema.Union<readonly [typeof Reason.InvalidInput, typeof Reason.Unauthenticated, typeof Reason.Forbidden, typeof Reason.NotFound, typeof Reason.Conflict, typeof Reason.Stale, typeof Reason.Expired, typeof Reason.Busy, typeof Reason.ProviderRejected, typeof Reason.ProviderUnavailable, typeof Reason.ProviderConflict, typeof Reason.Unsupported, typeof Reason.Reconnect, typeof Reason.StorageFailed, typeof Reason.CryptoFailed, typeof Reason.ResolverFailed]>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class DomainKitError extends DomainKitError_base {
+    get category(): Category;
+    get isRetryable(): boolean;
+    /** The HTTP status `domainkit/server` answers with; hosts mapping their own routes use the same table. */
+    get httpStatus(): number;
+    get message(): string;
+}
+export declare const isDomainKitError: (input: unknown) => input is DomainKitError;
+/** `Effect.fail(new DomainKitError({ reason }))` shorthand used across the package. */
+export declare const fail: <R extends Reason.Model>(reason: R) => Effect.Effect<never, DomainKitError>;
+/** Decode with any schema, failing with reason `InvalidInput` and the schema's message. */
+export declare const decode: <S extends Schema.ConstraintDecoder<unknown>>(schema: S, input: unknown, field?: string) => Effect.Effect<S["Type"], DomainKitError>;
+export {};

package/dist/types/internal/http.d.ts

@@ -0,0 +1,27 @@
+import { Effect } from "effect";
+import * as Errors from "./error.ts";
+import * as Reason from "../Reason.ts";
+export type Fetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface Reply {
+    readonly status: number;
+    readonly ok: boolean;
+    readonly headers: Headers;
+    /** Parsed JSON, or `null` for an empty body. */
+    readonly body: unknown;
+}
+/** One provider HTTP round trip: transport failures and non-JSON replies are already classified. */
+export declare const requestJson: (input: {
+    readonly fetch: Fetch;
+    readonly provider: string;
+    readonly url: URL | string;
+    readonly init?: RequestInit;
+}) => Effect.Effect<Reply, Errors.DomainKitError>;
+/** Host-supplied request headers, given as a value or as a thunk that may await a fresh token. */
+export declare const headersFrom: (source: HeadersInit | (() => HeadersInit | Promise<HeadersInit>) | undefined) => Effect.Effect<Headers, Errors.DomainKitError>;
+/**
+ * Map an HTTP failure to a reason: 401 -> Unauthenticated, 403 -> Forbidden, 409 or a provider
+ * conflict code -> ProviderConflict, 429/5xx -> ProviderUnavailable, else ProviderRejected.
+ */
+export declare const classify: (provider: string, status: number, headers: Headers, message: string, code?: string) => Reason.Model;
+export declare const rejected: (provider: string, message: string, code?: string) => Errors.DomainKitError;
+export declare const bearer: (token: string, init?: RequestInit) => RequestInit;

package/dist/types/internal/ids.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+/** A fresh, prefixed, URL-safe identifier (`prefix_<uuid>`). */
+export declare const fresh: (prefix: string) => Effect.Effect<string>;

package/dist/types/internal/oauth.d.ts

@@ -0,0 +1,58 @@
+import { DateTime, Effect, Redacted } from "effect";
+import * as Errors from "./error.ts";
+import type { Fetch } from "./http.ts";
+export interface Server {
+    readonly issuer: string;
+    readonly authorization_endpoint: string;
+    readonly token_endpoint: string;
+    readonly revocation_endpoint?: string;
+}
+export type ClientAuth = "client_secret_basic" | "client_secret_post" | "none";
+export interface Client {
+    readonly clientId: string;
+    readonly clientSecret: Redacted.Redacted<string> | null;
+    readonly clientAuth: ClientAuth;
+}
+/** A PKCE pair: the verifier stays in the continuation, the challenge goes to the provider. */
+export declare const pkce: () => Effect.Effect<{
+    readonly codeVerifier: string;
+    readonly codeChallenge: string;
+}, Errors.DomainKitError>;
+export declare const authorizationUrl: (input: {
+    readonly server: Server;
+    readonly clientId: string;
+    readonly scopes: ReadonlyArray<string>;
+    readonly state: string;
+    readonly callbackUrl: string;
+    readonly codeChallenge: string;
+}) => string;
+export interface Tokens {
+    readonly accessToken: string;
+    readonly refreshToken: string | null;
+    readonly expiresAt: DateTime.Utc | null;
+    readonly scope: string | null;
+}
+export declare const exchangeCode: (input: {
+    readonly provider: string;
+    readonly server: Server;
+    readonly client: Client;
+    readonly code: string;
+    readonly state: string;
+    readonly callbackUrl: string;
+    readonly codeVerifier: string;
+    readonly fetch?: Fetch;
+}) => Effect.Effect<Tokens, Errors.DomainKitError>;
+export declare const refresh: (input: {
+    readonly provider: string;
+    readonly server: Server;
+    readonly client: Client;
+    readonly refreshToken: string;
+    readonly fetch?: Fetch;
+}) => Effect.Effect<Tokens, Errors.DomainKitError>;
+export declare const revoke: (input: {
+    readonly provider: string;
+    readonly server: Server;
+    readonly client: Client;
+    readonly token: string;
+    readonly fetch?: Fetch;
+}) => Effect.Effect<void, Errors.DomainKitError>;

package/dist/types/internal/planner.d.ts

@@ -0,0 +1,22 @@
+import { Effect, Schema } from "effect";
+import * as DnsRecord from "../DnsRecord.ts";
+import * as Errors from "./error.ts";
+import * as Plan from "../Plan.ts";
+declare const Unsigned: Schema.Struct<{
+    readonly version: Schema.Literal<"domainkit.plan.v2">;
+    readonly kind: Schema.Literals<readonly ["provisioning", "cleanup"]>;
+    readonly domain: Schema.String;
+    readonly zone: Schema.String;
+    readonly provider: Schema.String;
+    readonly attachmentId: Schema.String;
+    readonly operations: Schema.$Array<Schema.Union<readonly [typeof Plan.Create, typeof Plan.Noop, typeof Plan.Conflict, typeof Plan.Delete]>>;
+}>;
+export type Unsigned = typeof Unsigned.Type;
+export declare const operationId: (record: DnsRecord.Model) => Effect.Effect<Plan.OperationId, Errors.DomainKitError>;
+/** The digest covers every operation but not requirement labels, which are display metadata. */
+export declare const digest: (unsigned: Unsigned) => Effect.Effect<Plan.Digest, Errors.DomainKitError>;
+/** Additive, fail-closed reconciliation of requirements against what the provider holds. */
+export declare const reconcile: (requirements: ReadonlyArray<DnsRecord.Model>, existing: ReadonlyArray<DnsRecord.Observed>) => Effect.Effect<ReadonlyArray<Plan.Create | Plan.Noop | Plan.Conflict>, Errors.DomainKitError>;
+/** Requirements a plan was built from, for re-planning at apply time. */
+export declare const requirements: (plan: Plan.Model) => ReadonlyArray<DnsRecord.Model>;
+export {};

package/dist/types/internal/provider-async.d.ts

@@ -0,0 +1,78 @@
+import { type Schema } from "effect";
+import type * as DnsRecord from "../DnsRecord.ts";
+import * as Provider from "../Provider.ts";
+import type { Capability } from "../Storage.ts";
+/** Plain-object credential for Promise-shaped providers; `secret` is the raw string. */
+export interface AsyncCredential {
+    readonly secret: string;
+    readonly context: unknown;
+}
+export interface AsyncIssuedCredential extends AsyncCredential {
+    readonly expiresAt: Date | null;
+}
+export interface AsyncDns {
+    readonly list: (zone: string) => Promise<ReadonlyArray<Provider.ObservedRecord>>;
+    readonly create: (zone: string, record: DnsRecord.Model) => Promise<{
+        readonly providerRecordId: string;
+    }>;
+    readonly get: (zone: string, providerRecordId: string) => Promise<DnsRecord.Observed | null>;
+    readonly delete: (zone: string, providerRecordId: string) => Promise<void>;
+}
+export interface AsyncSession {
+    readonly listTargets: () => Promise<ReadonlyArray<Provider.Target>>;
+    readonly resolveTarget: (domain: string) => Promise<Provider.Resolution>;
+    readonly dns: (target: Provider.Target) => AsyncDns;
+    readonly capabilities: () => Promise<ReadonlyArray<Capability>>;
+}
+export interface AsyncTokenAuth {
+    readonly label: string;
+    readonly docsUrl?: string;
+    readonly requiredCapabilities: ReadonlyArray<Capability>;
+    readonly fields: Schema.Struct<Provider.TokenFieldSchemas>;
+    /** Decoded field values with secrets unwrapped to strings. */
+    readonly authenticate: (values: Readonly<Record<string, string | undefined>>) => Promise<AsyncIssuedCredential>;
+}
+export interface AsyncOAuthAuth {
+    readonly label: string;
+    readonly scopes: ReadonlyArray<string>;
+    readonly start: (input: {
+        readonly state: string;
+        readonly callbackUrl: string;
+        readonly codeChallenge: string;
+    }) => Promise<{
+        readonly authorizationUrl: string;
+    }>;
+    readonly complete: (input: Provider.CallbackInput & {
+        readonly codeVerifier: string;
+    }) => Promise<AsyncIssuedCredential>;
+    readonly refresh: (credential: AsyncCredential) => Promise<AsyncIssuedCredential>;
+    readonly revoke?: (credential: AsyncCredential) => Promise<void>;
+}
+export interface AsyncIntegrationAuth {
+    readonly label: string;
+    readonly start: (input: {
+        readonly state: string;
+        readonly callbackUrl: string;
+    }) => Promise<{
+        readonly authorizationUrl: string;
+    }>;
+    readonly complete: (input: Provider.CallbackInput) => Promise<AsyncIssuedCredential>;
+    readonly refresh?: (credential: AsyncCredential) => Promise<AsyncIssuedCredential>;
+    readonly revoke?: (credential: AsyncCredential) => Promise<void>;
+}
+/** `Provider.Definition` with every operation returning a Promise. */
+export interface AsyncDefinition<Context = unknown> {
+    readonly id: string;
+    readonly name: string;
+    readonly auth: {
+        readonly token?: AsyncTokenAuth;
+        readonly oauth?: AsyncOAuthAuth;
+        readonly integration?: AsyncIntegrationAuth;
+    };
+    readonly context: Schema.Codec<Context, unknown, never, never>;
+    readonly contextVersion: string;
+    readonly migrateContext?: (envelope: Provider.Envelope) => Promise<Context>;
+    readonly session: (credential: AsyncCredential) => AsyncSession;
+}
+/** Adapt a Promise-shaped provider; rejections become `DomainKit.Error` (a thrown one passes through). */
+export declare const fromAsync: <Context>(definition: AsyncDefinition<Context>) => Provider.Definition<Context>;

package/dist/types/internal/storage-memory.d.ts

@@ -0,0 +1,2 @@
+import * as Storage from "../Storage.ts";
+export declare function makeMemory(options?: Storage.MemoryOptions): Storage.Interface;

package/dist/types/internal/vercel/client.d.ts

@@ -0,0 +1,29 @@
+import { Effect } from "effect";
+import * as Errors from "../error.ts";
+import type * as Provider from "../../Provider.ts";
+import { type Fetch } from "../http.ts";
+import * as Protocol from "./protocol.ts";
+export declare const provider = "vercel";
+export interface Options {
+    readonly token: string;
+    readonly fetch: Fetch;
+    readonly baseUrl: string;
+}
+type Fx<A> = Effect.Effect<A, Errors.DomainKitError>;
+export declare const user: (options: Options) => Effect.Effect<{
+    readonly id: string;
+    readonly name: string | null;
+    readonly username: string;
+}, Errors.DomainKitError, never>;
+export declare const teams: (options: Options) => Fx<ReadonlyArray<typeof Protocol.Team.Type>>;
+/** Domains with Vercel-hosted DNS for one account (`teamId` null means the personal account). */
+export declare const zones: (options: Options, teamId: string | null) => Fx<ReadonlyArray<Protocol.Domain>>;
+export declare const exchangeCode: (input: {
+    readonly options: Options;
+    readonly clientId: string;
+    readonly clientSecret: string;
+    readonly code: string;
+    readonly callbackUrl: string;
+}) => Fx<typeof Protocol.IntegrationToken.Type>;
+export declare const dns: (options: Options, teamId: string | null) => Provider.Dns;
+export {};

package/dist/types/internal/vercel/protocol.d.ts

@@ -0,0 +1,124 @@
+import { Schema as S } from "effect";
+export declare const Pagination: S.Struct<{
+    readonly count: S.Number;
+    readonly next: S.NullOr<S.Number>;
+    readonly prev: S.NullOr<S.Number>;
+}>;
+export declare const ErrorDetail: S.Struct<{
+    readonly code: S.String;
+    readonly message: S.String;
+    readonly limit: S.optionalKey<S.Struct<{
+        readonly remaining: S.Number;
+        readonly reset: S.optionalKey<S.Number>;
+        readonly resetMs: S.optionalKey<S.Number>;
+        readonly total: S.Number;
+    }>>;
+}>;
+export declare const ErrorEnvelope: S.Struct<{
+    readonly error: S.Struct<{
+        readonly code: S.String;
+        readonly message: S.String;
+        readonly limit: S.optionalKey<S.Struct<{
+            readonly remaining: S.Number;
+            readonly reset: S.optionalKey<S.Number>;
+            readonly resetMs: S.optionalKey<S.Number>;
+            readonly total: S.Number;
+        }>>;
+    }>;
+}>;
+export declare const User: S.Struct<{
+    readonly id: S.String;
+    readonly name: S.NullOr<S.String>;
+    readonly username: S.String;
+}>;
+export declare const UserEnvelope: S.Struct<{
+    readonly user: S.Struct<{
+        readonly id: S.String;
+        readonly name: S.NullOr<S.String>;
+        readonly username: S.String;
+    }>;
+}>;
+export declare const Team: S.Struct<{
+    readonly id: S.String;
+    readonly name: S.NullOr<S.String>;
+    readonly slug: S.String;
+}>;
+export declare const TeamListEnvelope: S.Struct<{
+    readonly pagination: S.Struct<{
+        readonly count: S.Number;
+        readonly next: S.NullOr<S.Number>;
+        readonly prev: S.NullOr<S.Number>;
+    }>;
+    readonly teams: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly name: S.NullOr<S.String>;
+        readonly slug: S.String;
+    }>>;
+}>;
+export declare const Domain: S.Struct<{
+    readonly id: S.String;
+    readonly intendedNameservers: S.$Array<S.String>;
+    readonly name: S.String;
+    readonly nameservers: S.$Array<S.String>;
+    readonly serviceType: S.Literals<readonly ["zeit.world", "external", "na"]>;
+    readonly teamId: S.NullOr<S.String>;
+    readonly userId: S.String;
+    readonly verified: S.Boolean;
+    readonly zone: S.optionalKey<S.Boolean>;
+}>;
+export type Domain = typeof Domain.Type;
+export declare const DomainListEnvelope: S.Struct<{
+    readonly domains: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly intendedNameservers: S.$Array<S.String>;
+        readonly name: S.String;
+        readonly nameservers: S.$Array<S.String>;
+        readonly serviceType: S.Literals<readonly ["zeit.world", "external", "na"]>;
+        readonly teamId: S.NullOr<S.String>;
+        readonly userId: S.String;
+        readonly verified: S.Boolean;
+        readonly zone: S.optionalKey<S.Boolean>;
+    }>>;
+    readonly pagination: S.Struct<{
+        readonly count: S.Number;
+        readonly next: S.NullOr<S.Number>;
+        readonly prev: S.NullOr<S.Number>;
+    }>;
+}>;
+export declare const Record: S.Struct<{
+    readonly id: S.String;
+    readonly mxPriority: S.optionalKey<S.Number>;
+    readonly name: S.String;
+    readonly priority: S.optionalKey<S.Number>;
+    readonly ttl: S.optionalKey<S.Number>;
+    readonly type: S.String;
+    readonly value: S.String;
+}>;
+export type Record = typeof Record.Type;
+export declare const RecordListEnvelope: S.Struct<{
+    readonly pagination: S.optionalKey<S.Struct<{
+        readonly count: S.Number;
+        readonly next: S.NullOr<S.Number>;
+        readonly prev: S.NullOr<S.Number>;
+    }>>;
+    readonly records: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly mxPriority: S.optionalKey<S.Number>;
+        readonly name: S.String;
+        readonly priority: S.optionalKey<S.Number>;
+        readonly ttl: S.optionalKey<S.Number>;
+        readonly type: S.String;
+        readonly value: S.String;
+    }>>;
+}>;
+export declare const CreateRecordEnvelope: S.Struct<{
+    readonly uid: S.String;
+    readonly updated: S.optionalKey<S.Number>;
+}>;
+export declare const IntegrationToken: S.Struct<{
+    readonly access_token: S.String;
+    readonly installation_id: S.optionalKey<S.String>;
+    readonly team_id: S.NullOr<S.String>;
+    readonly token_type: S.optionalKey<S.String>;
+    readonly user_id: S.String;
+}>;

package/dist/types/internal/vercel/records.d.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import * as DnsRecord from "../../DnsRecord.ts";
+import type * as Provider from "../../Provider.ts";
+import type * as Protocol from "./protocol.ts";
+export declare const decode: (zone: string, record: Protocol.Record) => Effect.Effect<Provider.ObservedRecord>;
+export declare const encode: (zone: string, record: DnsRecord.Model) => Effect.Effect<Record<string, unknown>, never>;
+export declare const outsideZone: (zone: string, name: string) => import("../error.ts").DomainKitError;