@domainkit/react 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,666 @@
+import { Dialog } from "@base-ui/react/dialog";
+import { CSSProperties, ComponentPropsWithoutRef, ElementType, ReactElement, ReactNode, RefObject } from "react";
+import { useRender } from "@base-ui/react/use-render";
+//#region src/composition.d.ts
+type ClassName<State> = string | ((state: State) => string | undefined);
+type Style<State> = CSSProperties | ((state: State) => CSSProperties | undefined);
+type PartProps<Tag extends ElementType, State extends Record<string, unknown>> = Omit<useRender.ElementProps<Tag>, "className" | "style"> & {
+  readonly className?: ClassName<State>;
+  readonly render?: useRender.RenderProp<State>;
+  readonly style?: Style<State>;
+};
+declare namespace transport_d_exports {
+  export { ApplyResult, AuthenticationMethod, AuthenticationParameter, CleanupOperation, CleanupPlan, CleanupResult, CleanupTransport, Connected, ConnectionResult, ConnectionSnapshot, ConnectionTransport, DnsRecord, DomainKitTransport, Failure, Observation, ObservationEvidence, OperationResult, PlanOperation, Provider, ProvisioningPlan, ProvisioningTransport, RemoveDomainResult, ReusableConnection, VerificationTransport };
+}
+interface Failure {
+  readonly _tag: "Failure";
+  readonly message: string;
+  readonly retry: "never" | "after-user-action" | "safe" | "unknown";
+}
+interface AuthenticationParameter {
+  readonly description?: string;
+  readonly key: string;
+  readonly label: string;
+  readonly placeholder?: string;
+  readonly required?: boolean;
+}
+type AuthenticationMethod = {
+  readonly _tag: "OAuth";
+  readonly label: string;
+} | {
+  readonly _tag: "Token";
+  readonly label: string;
+  readonly parameters?: ReadonlyArray<AuthenticationParameter>;
+  readonly placeholder?: string;
+};
+interface Provider {
+  readonly authentication: ReadonlyArray<AuthenticationMethod>;
+  readonly id: string;
+  readonly name: string;
+}
+interface Connected {
+  readonly _tag: "Connected";
+  readonly connectionId: string;
+  readonly domain: string;
+  readonly provider: Provider;
+}
+interface ReusableConnection {
+  readonly connectionId: string;
+  readonly label: string;
+}
+type ConnectionSnapshot = Connected | {
+  readonly _tag: "Disconnected";
+  readonly domain: string;
+  readonly provider: Provider;
+  readonly reusableConnection?: ReusableConnection;
+} | {
+  readonly _tag: "Unsupported";
+  readonly domain: string;
+} | Failure;
+type ConnectionResult = Connected | {
+  readonly _tag: "Redirect";
+  readonly authorizationUrl: string;
+} | Failure;
+interface ConnectionTransport {
+  readonly connect: (input: {
+    readonly domain: string;
+    readonly method: "oauth" | "token";
+    readonly parameters?: Readonly<Record<string, string>>;
+    readonly providerId: string;
+    readonly token?: string;
+  }) => Promise<ConnectionResult>;
+  readonly inspect: (input: {
+    readonly domain: string;
+  }) => Promise<ConnectionSnapshot>;
+  readonly reuse: (input: {
+    readonly connectionId: string;
+    readonly domain: string;
+  }) => Promise<Connected | Failure>;
+  readonly removeDomain: (input: {
+    readonly connectionId: string;
+    readonly domain: string;
+    readonly preserveDns: true;
+  }) => Promise<RemoveDomainResult | Failure>;
+}
+interface RemoveDomainResult {
+  readonly _tag: "Removed";
+  readonly connectionId: string;
+  readonly domain: string;
+  readonly remainingDomainCount: number;
+}
+interface DnsRecord {
+  readonly id: string;
+  readonly name: string;
+  readonly priority?: number;
+  readonly type: string;
+  readonly value: string;
+}
+type PlanOperation = {
+  readonly _tag: "Create";
+  readonly id: string;
+  readonly record: DnsRecord;
+} | {
+  readonly _tag: "Noop";
+  readonly id: string;
+  readonly record: DnsRecord;
+} | {
+  readonly _tag: "Conflict";
+  readonly id: string;
+  readonly record: DnsRecord;
+  readonly reason: string;
+};
+interface ProvisioningPlan {
+  readonly _tag: "Plan";
+  readonly digest: string;
+  readonly expiresAt: string;
+  readonly operations: ReadonlyArray<PlanOperation>;
+}
+type OperationResult = {
+  readonly _tag: "Applied";
+  readonly operationId: string;
+} | {
+  readonly _tag: "Unchanged";
+  readonly operationId: string;
+} | {
+  readonly _tag: "Failed";
+  readonly message: string;
+  readonly operationId: string;
+};
+type ApplyResult = {
+  readonly _tag: "Applied";
+  readonly operationId: string;
+  readonly receiptId: string;
+  readonly results: ReadonlyArray<OperationResult>;
+} | {
+  readonly _tag: "Partial";
+  readonly operationId: string;
+  readonly receiptId: string;
+  readonly results: ReadonlyArray<OperationResult>;
+} | {
+  readonly _tag: "Stale";
+  readonly message: string;
+} | Failure;
+interface ProvisioningTransport {
+  readonly plan: (input: {
+    readonly connectionId: string;
+    readonly domain: string;
+    readonly records: ReadonlyArray<DnsRecord>;
+  }) => Promise<ProvisioningPlan | Failure>;
+  readonly apply: (input: {
+    readonly connectionId: string;
+    readonly domain: string;
+    readonly planDigest: string;
+  }) => Promise<ApplyResult>;
+}
+type ObservationEvidence = {
+  readonly _tag: "Found";
+  readonly recordId: string;
+} | {
+  readonly _tag: "Missing";
+  readonly recordId: string;
+} | {
+  readonly _tag: "Mismatch";
+  readonly recordId: string;
+  readonly message: string;
+} | {
+  readonly _tag: "Unavailable";
+  readonly recordId: string;
+  readonly message: string;
+};
+interface Observation {
+  readonly _tag: "Observation";
+  readonly provider: ReadonlyArray<ObservationEvidence>;
+  readonly publicDns: ReadonlyArray<ObservationEvidence>;
+}
+interface VerificationTransport {
+  readonly observe: (input: {
+    readonly connectionId?: string;
+    readonly domain: string;
+    readonly records: ReadonlyArray<DnsRecord>;
+    readonly sources: {
+      readonly provider: boolean;
+      readonly publicDns: boolean;
+    };
+  }) => Promise<Observation | Failure>;
+}
+type CleanupOperation = {
+  readonly _tag: "Delete";
+  readonly id: string;
+  readonly record: DnsRecord;
+} | {
+  readonly _tag: "AlreadyAbsent";
+  readonly id: string;
+  readonly record: DnsRecord;
+} | {
+  readonly _tag: "Blocked";
+  readonly id: string;
+  readonly record: DnsRecord;
+  readonly reason: string;
+};
+interface CleanupPlan {
+  readonly _tag: "CleanupPlan";
+  readonly digest: string;
+  readonly expiresAt: string;
+  readonly operations: ReadonlyArray<CleanupOperation>;
+}
+type CleanupResult = {
+  readonly _tag: "Cleaned";
+  readonly operationId: string;
+  readonly results: ReadonlyArray<OperationResult>;
+} | {
+  readonly _tag: "Partial";
+  readonly operationId: string;
+  readonly results: ReadonlyArray<OperationResult>;
+} | {
+  readonly _tag: "Stale";
+  readonly message: string;
+} | Failure;
+interface CleanupTransport {
+  readonly plan: (input: {
+    readonly connectionId: string;
+    readonly domain: string;
+    readonly receiptId: string;
+  }) => Promise<CleanupPlan | Failure>;
+  readonly apply: (input: {
+    readonly connectionId: string;
+    readonly domain: string;
+    readonly planDigest: string;
+    readonly receiptId: string;
+  }) => Promise<CleanupResult>;
+}
+interface DomainKitTransport {
+  readonly cleanup: CleanupTransport;
+  readonly connection: ConnectionTransport;
+  readonly provisioning: ProvisioningTransport;
+  readonly verification: VerificationTransport;
+}
+declare namespace cleanup_d_exports {
+  export { Flow$3 as Flow, FlowProps$3 as FlowProps, State$3 as State, useController$3 as useController };
+}
+type State$3 = {
+  readonly _tag: "Idle";
+} | {
+  readonly _tag: "Planning";
+} | {
+  readonly _tag: "Review";
+  readonly plan: CleanupPlan;
+} | {
+  readonly _tag: "Cleaning";
+  readonly plan: CleanupPlan;
+} | {
+  readonly _tag: "Cleaned";
+  readonly result: Extract<CleanupResult, {
+    readonly _tag: "Cleaned";
+  }>;
+} | {
+  readonly _tag: "Partial";
+  readonly result: Extract<CleanupResult, {
+    readonly _tag: "Partial";
+  }>;
+} | {
+  readonly _tag: "Stale";
+  readonly message: string;
+} | Failure;
+declare function useController$3(connection: Connected, receiptId: string): {
+  readonly apply: () => Promise<void>;
+  readonly dismiss: () => void;
+  readonly plan: () => Promise<void>;
+  readonly state: State$3;
+};
+interface FlowProps$3 extends PartProps<"div", {
+  readonly status: State$3["_tag"];
+}> {
+  readonly connection: Connected;
+  readonly receiptId: string;
+}
+declare function Flow$3({ connection, receiptId, ...props }: FlowProps$3): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare namespace provider_d_exports {
+  export { Mark, MarkElementProps, MarkProps, MarkState, Marks, Provider };
+}
+type Marks = Readonly<Record<string, ReactNode | ((provider: Provider) => ReactNode)>>;
+interface MarkState extends Record<string, unknown> {
+  readonly providerId: string;
+}
+interface MarkProps extends PartProps<"span", MarkState> {
+  readonly provider: Provider;
+}
+declare function Mark({ provider, ...props }: MarkProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+type MarkElementProps = ComponentPropsWithoutRef<"span">;
+declare namespace connection_d_exports {
+  export { ActionState, Connected, Controller$1 as Controller, Dialog$1 as Dialog, DialogProps, DisconnectAction, DisconnectActionProps, DisconnectState, Flow$2 as Flow, FlowProps$2 as FlowProps, OAuthAction, OAuthActionProps, RetryAction, RetryActionProps, ReuseAction, ReuseActionProps, Root$2 as Root, RootProps$2 as RootProps, RootState$1 as RootState, State$2 as State, Status$2 as Status, StatusProps$2 as StatusProps, StatusState, TokenAction, TokenActionProps, Trigger, TriggerProps, useController$2 as useController, useDisconnect };
+}
+type State$2 = {
+  readonly _tag: "Loading";
+} | ConnectionSnapshot | {
+  readonly _tag: "Submitting";
+  readonly snapshot: Disconnected;
+} | {
+  readonly _tag: "Redirecting";
+  readonly snapshot: Disconnected;
+};
+type Disconnected = Extract<ConnectionSnapshot, {
+  readonly _tag: "Disconnected";
+}>;
+interface Controller$1 {
+  readonly connect: (method: "oauth" | "token", token?: string, parameters?: Readonly<Record<string, string>>) => Promise<void>;
+  readonly retry: () => void;
+  readonly reuse: () => Promise<void>;
+  readonly state: State$2;
+}
+declare function useController$2(domain: string): Controller$1;
+interface RootState$1 extends Record<string, unknown> {
+  readonly status: State$2["_tag"];
+}
+interface RootProps$2 extends PartProps<"div", RootState$1> {
+  readonly status?: State$2["_tag"];
+}
+declare function Root$2({ children, status, ...props }: RootProps$2): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface StatusState extends Record<string, unknown> {
+  readonly status: State$2["_tag"];
+}
+interface StatusProps$2 extends PartProps<"div", StatusState> {
+  readonly state: State$2;
+}
+declare function Status$2({ state, ...props }: StatusProps$2): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface TriggerProps extends ComponentPropsWithoutRef<typeof Dialog.Trigger> {
+  readonly provider: Provider;
+}
+declare function Trigger({ provider, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+interface ActionState extends Record<string, unknown> {
+  readonly authentication: "oauth" | "reuse" | "token";
+}
+interface OAuthActionProps extends PartProps<"button", ActionState> {
+  readonly controller: Controller$1;
+  readonly label: string;
+}
+declare function OAuthAction({ controller, label, ...props }: OAuthActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface ReuseActionProps extends PartProps<"button", ActionState> {
+  readonly controller: Controller$1;
+  readonly label: string;
+}
+declare function ReuseAction({ controller, label, ...props }: ReuseActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface TokenActionProps extends Omit<PartProps<"form", ActionState>, "method"> {
+  readonly controller: Controller$1;
+  readonly method: Extract<AuthenticationMethod, {
+    readonly _tag: "Token";
+  }>;
+}
+declare function TokenAction({ controller, method, ...props }: TokenActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface DialogProps {
+  readonly controller: Controller$1;
+  readonly snapshot: Disconnected;
+}
+declare function Dialog$1({ controller, snapshot }: DialogProps): import("react/jsx-runtime").JSX.Element;
+interface FlowProps$2 extends Omit<RootProps$2, "children"> {
+  readonly domain: string;
+}
+declare function Flow$2({ domain, ...props }: FlowProps$2): import("react/jsx-runtime").JSX.Element;
+interface RetryActionProps extends PartProps<"button", {
+  readonly status: "Failure";
+}> {
+  readonly controller: Controller$1;
+  readonly kind?: "after-user-action" | "retry";
+}
+declare function RetryAction({ controller, kind, ...props }: RetryActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+type DisconnectState = {
+  readonly _tag: "Idle";
+} | {
+  readonly _tag: "Disconnecting";
+} | RemoveDomainResult | Failure;
+declare function useDisconnect(connection: Connected): {
+  readonly disconnect: () => Promise<void>;
+  readonly state: DisconnectState;
+};
+interface DisconnectActionProps extends PartProps<"div", {
+  readonly status: DisconnectState["_tag"];
+}> {
+  readonly connection: Connected;
+}
+declare function DisconnectAction({ connection, ...props }: DisconnectActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare namespace domain_d_exports {
+  export { Flow$1 as Flow, FlowProps$1 as FlowProps };
+}
+interface FlowProps$1 {
+  readonly domain: string;
+  readonly receiptId?: string;
+  readonly records: ReadonlyArray<DnsRecord>;
+}
+declare function Flow$1({ domain, receiptId, records }: FlowProps$1): import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/icons.d.ts
+type Icons = {
+  readonly copied: ReactNode;
+  readonly copy: ReactNode;
+  readonly download: ReactNode;
+};
+declare namespace messages_d_exports {
+  export { Catalog, english, merge };
+}
+interface Catalog {
+  readonly applyCleanup: string;
+  readonly applyDns: string;
+  readonly applyingDns: string;
+  readonly automaticUnavailable: string;
+  readonly cancel: string;
+  readonly checkAgain: string;
+  readonly checkingDns: string;
+  readonly checkDns: string;
+  readonly cleanupComplete: string;
+  readonly cleanupConsent: string;
+  readonly cleanupPartial: string;
+  readonly cleaningDns: string;
+  readonly connectProvider: (provider: string) => string;
+  readonly connected: (provider: string) => string;
+  readonly connecting: string;
+  readonly close: string;
+  readonly detectingProvider: string;
+  readonly disconnectDomain: string;
+  readonly disconnecting: string;
+  readonly domainDisconnected: string;
+  readonly dialogDescription: (domain: string) => string;
+  readonly dialogTitle: (provider: string) => string;
+  readonly openingAuthorization: string;
+  readonly planConsent: string;
+  readonly planningCleanup: string;
+  readonly planningDns: string;
+  readonly recordsApplied: string;
+  readonly recordsPartiallyApplied: string;
+  readonly reviewCleanup: string;
+  readonly reviewDns: string;
+  readonly retry: string;
+  readonly reuseConnection: (connection: string) => string;
+  readonly tokenLabel: string;
+}
+declare const english: Catalog;
+declare const merge: (overrides?: Partial<Catalog>) => Catalog;
+declare namespace theme_d_exports {
+  export { Theme, toStyle };
+}
+interface Theme {
+  readonly accent?: string;
+  readonly accentContrast?: string;
+  readonly background?: string;
+  readonly border?: string;
+  readonly danger?: string;
+  readonly fill?: string;
+  readonly fontFamily?: string;
+  readonly muted?: string;
+  readonly radius?: string;
+  readonly shadow?: string;
+  readonly success?: string;
+  readonly text?: string;
+}
+declare function toStyle(theme?: Theme): CSSProperties;
+declare namespace domain_kit_d_exports {
+  export { Root$1 as Root, RootProps$1 as RootProps, RootState, useDomainKit };
+}
+interface RootState extends Record<string, unknown> {
+  readonly colorScheme: "dark" | "inherit" | "light";
+}
+interface RootProps$1 extends Omit<PartProps<"div", RootState>, "children"> {
+  readonly children: ReactNode;
+  readonly colorScheme?: RootState["colorScheme"];
+  readonly icons?: Partial<Icons>;
+  readonly messages?: Partial<Catalog>;
+  readonly marks?: Marks;
+  readonly navigate?: (url: string) => void;
+  readonly portalContainer?: HTMLElement | null;
+  readonly theme?: Theme;
+  readonly transport: DomainKitTransport;
+}
+interface ContextValue {
+  readonly colorScheme: RootState["colorScheme"];
+  readonly navigate: (url: string) => void;
+  readonly marks: Marks;
+  readonly messages: Catalog;
+  readonly portalContainer: RefObject<HTMLElement | null>;
+  readonly themeStyle: ReturnType<typeof toStyle>;
+  readonly transport: DomainKitTransport;
+}
+declare function Root$1({ children, colorScheme, icons, marks, messages, navigate, portalContainer, theme, transport, ...props }: RootProps$1): import("react/jsx-runtime").JSX.Element;
+declare function useDomainKit(): ContextValue;
+declare namespace provisioning_d_exports {
+  export { Controller, Flow, FlowProps, OperationList, State$1 as State, useController$1 as useController };
+}
+type State$1 = {
+  readonly _tag: "Idle";
+} | {
+  readonly _tag: "Planning";
+} | {
+  readonly _tag: "Review";
+  readonly plan: ProvisioningPlan;
+} | {
+  readonly _tag: "Applying";
+  readonly plan: ProvisioningPlan;
+} | {
+  readonly _tag: "Complete";
+  readonly result: Extract<ApplyResult, {
+    readonly _tag: "Applied";
+  }>;
+} | {
+  readonly _tag: "Partial";
+  readonly result: Extract<ApplyResult, {
+    readonly _tag: "Partial";
+  }>;
+} | {
+  readonly _tag: "Stale";
+  readonly message: string;
+} | Failure;
+interface Controller {
+  readonly apply: () => Promise<void>;
+  readonly dismiss: () => void;
+  readonly plan: () => Promise<void>;
+  readonly retry: () => Promise<void>;
+  readonly state: State$1;
+}
+declare function useController$1(connection: Connected, records: ReadonlyArray<DnsRecord>, onApplied?: (result: Extract<ApplyResult, {
+  readonly _tag: "Applied" | "Partial";
+}>) => void): Controller;
+interface FlowProps extends PartProps<"div", {
+  readonly status: State$1["_tag"];
+}> {
+  readonly connection: Connected;
+  readonly onApplied?: (result: Extract<ApplyResult, {
+    readonly _tag: "Applied" | "Partial";
+  }>) => void;
+  readonly records: ReadonlyArray<DnsRecord>;
+  readonly showRecords?: boolean;
+}
+declare function Flow({ connection, onApplied, records, showRecords, ...props }: FlowProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function OperationList({ plan }: {
+  readonly plan: ProvisioningPlan;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace records_d_exports {
+  export { Body, Caption, Card, CardContent, CardHeader, CardProps, CardTitle, Cell, CopyValue, CopyValueProps, DnsRecord, Footer, Head, Header, ObservationEvidence, Priority, PriorityProps, Root, RootProps, Row, Status$1 as Status, StatusProps$1 as StatusProps, Table, TableProps, Value, ZoneFile, ZoneFileProps, toZoneFile };
+}
+type LeafState = Record<string, unknown>;
+interface CopyValueProps extends PartProps<"span", {
+  readonly copied: boolean;
+}> {
+  readonly copiedIcon?: ReactNode;
+  readonly copiedLabel?: string;
+  readonly copyIcon?: ReactNode;
+  readonly copyLabel?: string;
+  readonly value: string;
+}
+declare function CopyValue({ copiedIcon, copiedLabel, copyIcon, copyLabel, value, ...props }: CopyValueProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface ZoneFileProps extends PartProps<"div", {
+  readonly count: number;
+}> {
+  readonly copiedIcon?: ReactNode;
+  readonly copiedLabel?: string;
+  readonly copyIcon?: ReactNode;
+  readonly copyLabel?: string;
+  readonly domain: string;
+  readonly downloadIcon?: ReactNode;
+  readonly downloadLabel?: string;
+  readonly records: ReadonlyArray<DnsRecord>;
+}
+declare function ZoneFile({ copiedIcon, copiedLabel, copyIcon, copyLabel, domain, downloadIcon, downloadLabel, records, ...props }: ZoneFileProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface StatusProps$1 extends PartProps<"span", {
+  readonly status: ObservationEvidence["_tag"];
+}> {
+  readonly evidence: ObservationEvidence;
+}
+declare function Status$1({ evidence, ...props }: StatusProps$1): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface PriorityProps extends PartProps<"span", {
+  readonly priority: number;
+}> {
+  readonly priority?: number;
+}
+declare function Priority({ children, priority, ...props }: PriorityProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare const Header: (props: PartProps<"thead", LeafState>) => ReactElement;
+declare const Body: (props: PartProps<"tbody", LeafState>) => ReactElement;
+declare const Footer: (props: PartProps<"tfoot", LeafState>) => ReactElement;
+declare const Row: (props: PartProps<"tr", LeafState>) => ReactElement;
+declare const Head: (props: PartProps<"th", LeafState>) => ReactElement;
+declare const Cell: (props: PartProps<"td", LeafState>) => ReactElement;
+declare const Caption: (props: PartProps<"caption", LeafState>) => ReactElement;
+declare const Value: (props: PartProps<"span", LeafState>) => ReactElement;
+declare const CardHeader: (props: PartProps<"div", LeafState>) => ReactElement;
+declare const CardTitle: (props: PartProps<"strong", LeafState>) => ReactElement;
+declare const CardContent: (props: PartProps<"dl", LeafState>) => ReactElement;
+interface RootProps extends PartProps<"table", {
+  readonly count: number;
+}> {
+  readonly count?: number;
+}
+declare function Root({ count, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+interface CardProps extends PartProps<"section", {
+  readonly recordId: string;
+}> {
+  readonly copiedIcon?: ReactNode;
+  readonly copyIcon?: ReactNode;
+  readonly evidence?: ReadonlyArray<ObservationEvidence>;
+  readonly record: DnsRecord;
+}
+declare function Card({ copiedIcon, copyIcon, evidence, record, ...props }: CardProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface TableProps extends PartProps<"table", {
+  readonly count: number;
+}> {
+  readonly copiedIcon?: ReactNode;
+  readonly copyIcon?: ReactNode;
+  readonly evidence?: ReadonlyArray<ObservationEvidence>;
+  readonly records: ReadonlyArray<DnsRecord>;
+}
+declare function Table({ copiedIcon, copyIcon, evidence, records, ...props }: TableProps): import("react/jsx-runtime").JSX.Element;
+declare const toZoneFile: (records: ReadonlyArray<DnsRecord>) => string;
+declare namespace testing_d_exports {
+  export { FakeOptions, FakeTransport, makeFakeTransport, provider$1 as provider };
+}
+interface FakeOptions {
+  readonly connect?: ConnectionResult;
+  readonly inspect: ConnectionSnapshot | ReadonlyArray<ConnectionSnapshot>;
+  readonly reuse?: Connected;
+  readonly removeDomain?: RemoveDomainResult;
+  readonly plan?: ProvisioningPlan;
+  readonly apply?: ApplyResult;
+  readonly observe?: Observation;
+  readonly cleanupPlan?: CleanupPlan;
+  readonly cleanupApply?: CleanupResult;
+}
+interface FakeTransport extends DomainKitTransport {
+  readonly calls: {
+    readonly connect: Array<Parameters<DomainKitTransport["connection"]["connect"]>[0]>;
+    readonly inspect: Array<Parameters<DomainKitTransport["connection"]["inspect"]>[0]>;
+    readonly reuse: Array<Parameters<DomainKitTransport["connection"]["reuse"]>[0]>;
+    readonly removeDomain: Array<Parameters<DomainKitTransport["connection"]["removeDomain"]>[0]>;
+    readonly plan: Array<Parameters<DomainKitTransport["provisioning"]["plan"]>[0]>;
+    readonly apply: Array<Parameters<DomainKitTransport["provisioning"]["apply"]>[0]>;
+    readonly observe: Array<Parameters<DomainKitTransport["verification"]["observe"]>[0]>;
+    readonly cleanupPlan: Array<Parameters<DomainKitTransport["cleanup"]["plan"]>[0]>;
+    readonly cleanupApply: Array<Parameters<DomainKitTransport["cleanup"]["apply"]>[0]>;
+  };
+}
+declare const provider$1: (overrides?: Partial<Provider>) => Provider;
+declare function makeFakeTransport(options: FakeOptions): FakeTransport;
+declare namespace verification_d_exports {
+  export { Observation, ObserveConfig, State, Status, StatusProps, useController };
+}
+type State = {
+  readonly _tag: "Idle";
+} | {
+  readonly _tag: "Observing";
+} | Observation | Failure;
+interface ObserveConfig {
+  readonly connection?: Connected;
+  readonly domain: string;
+  readonly records: ReadonlyArray<DnsRecord>;
+  readonly sources?: {
+    readonly provider?: boolean;
+    readonly publicDns?: boolean;
+  };
+}
+declare function useController(config: ObserveConfig): {
+  readonly observe: () => Promise<void>;
+  readonly state: State;
+};
+interface StatusProps extends PartProps<"div", {
+  readonly status: State["_tag"];
+}> {
+  readonly config: ObserveConfig;
+}
+declare function Status({ config, ...props }: StatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+//#endregion
+export { cleanup_d_exports as Cleanup, connection_d_exports as Connection, domain_d_exports as Domain, domain_kit_d_exports as DomainKit, messages_d_exports as Messages, provider_d_exports as Provider, provisioning_d_exports as Provisioning, records_d_exports as Records, testing_d_exports as Testing, theme_d_exports as Theme, transport_d_exports as Transport, verification_d_exports as Verification };
+//# sourceMappingURL=index.d.mts.map