@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/dns/neutral/GoogleDnsResultAnswer.d.ts

@@ -0,0 +1,8 @@
+import type { DnsRecordType } from './DnsRecordType.ts';
+export interface GoogleDnsResultAnswer {
+    TTL?: number;
+    data?: string;
+    name?: string;
+    type?: DnsRecordType;
+}
+//# sourceMappingURL=GoogleDnsResultAnswer.d.ts.map

package/dist/_pkg/dns/neutral/GoogleDnsResultQuestion.d.ts

@@ -0,0 +1,11 @@
+import type { DnsRecordType } from './DnsRecordType.ts';
+export interface GoogleDnsResultQuestion {
+    cd?: boolean;
+    ct?: string;
+    do?: boolean;
+    edns_client_subnet?: string;
+    name?: string;
+    random_padding?: string;
+    type?: DnsRecordType;
+}
+//# sourceMappingURL=GoogleDnsResultQuestion.d.ts.map

package/dist/_pkg/dns/neutral/domainExists.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if a domain exists (resolves using DNS)
+ * @param domain - string
+ * @returns boolean
+ */
+declare const domainExists: (domain?: string) => Promise<boolean>;
+export { domainExists };
+//# sourceMappingURL=domainExists.d.ts.map

package/dist/_pkg/dns/neutral/domainResolve.d.ts

@@ -0,0 +1,9 @@
+import { DnsRecordType } from './DnsRecordType.ts';
+/**
+ * Resolves DNS information (resolves using DNS)
+ * @param domain - string
+ * @returns GoogleDnsResult
+ */
+declare const domainResolve: (domain?: string, type?: DnsRecordType) => Promise<import("./GoogleDnsResult.ts").GoogleDnsResult | undefined>;
+export { domainResolve };
+//# sourceMappingURL=domainResolve.d.ts.map

package/dist/_pkg/dns/neutral/googleDnsOverHttps.d.ts

@@ -0,0 +1,5 @@
+import { DnsRecordType } from './DnsRecordType.ts';
+import type { GoogleDnsResult } from './GoogleDnsResult.ts';
+declare const googleDnsOverHttps: (name: string, type?: DnsRecordType) => Promise<GoogleDnsResult | undefined>;
+export { googleDnsOverHttps };
+//# sourceMappingURL=googleDnsOverHttps.d.ts.map

package/dist/_pkg/dns/neutral/index.d.ts

@@ -0,0 +1,9 @@
+export * from './DnsRecordType.ts';
+export * from './DnsReturnCode.ts';
+export * from './domainExists.ts';
+export * from './domainResolve.ts';
+export * from './googleDnsOverHttps.ts';
+export * from './GoogleDnsResult.ts';
+export * from './GoogleDnsResultAnswer.ts';
+export * from './GoogleDnsResultQuestion.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/dns/neutral/index.mjs

@@ -0,0 +1,61 @@
+// src/DnsRecordType.ts
+var DnsRecordType = {
+  A: 1,
+  AAAA: 28,
+  CAA: 257,
+  CNAME: 5,
+  DNAME: 39,
+  MX: 15,
+  NS: 2,
+  PTR: 12,
+  SOA: 6,
+  SPF: 99,
+  SRV: 33,
+  TXT: 16
+};
+
+// src/DnsReturnCode.ts
+var DnsReturnCode = {
+  NoError: 0,
+  QueryFormatError: 1,
+  ServerFailed: 2,
+  DomainDoesNotExist: 3,
+  NotImplemented: 4,
+  Refused: 5,
+  NameShouldNotExist: 6,
+  RRSetShouldNotExist: 7,
+  NotAuthoritative: 8,
+  NotInZone: 9
+};
+
+// src/domainResolve.ts
+import { isDefined } from "@xylabs/sdk";
+
+// src/googleDnsOverHttps.ts
+import { fetchJson } from "@xylabs/sdk";
+var googleDnsOverHttps = async (name, type = DnsRecordType.A) => {
+  const response = await fetchJson(`https://dns.google/resolve?name=${name}&type=${type}`);
+  return response.data ?? void 0;
+};
+
+// src/domainResolve.ts
+var domainResolve = async (domain, type = DnsRecordType.A) => {
+  if (isDefined(domain)) {
+    return await googleDnsOverHttps(domain, type);
+  }
+};
+
+// src/domainExists.ts
+var domainExists = async (domain) => {
+  if (domain === void 0) return false;
+  const dnsResult = await domainResolve(domain);
+  return dnsResult?.Status === DnsReturnCode.NoError;
+};
+export {
+  DnsRecordType,
+  DnsReturnCode,
+  domainExists,
+  domainResolve,
+  googleDnsOverHttps
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/domain-payload-plugin/neutral/DomainConfigPayload.d.ts

@@ -0,0 +1,219 @@
+import * as z from 'zod/mini';
+/**
+ * A domain's xyo config stored as an on-network payload, so it can be referenced from a
+ * DNS TXT record by hash (config={hash}). Shares its field set with DomainPayload.
+ */
+export declare const DomainConfigPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.domain.config" & {
+        readonly __schema: true;
+    }>;
+    additional: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    aliases: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+        huri: z.ZodMiniString<string>;
+        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>>>;
+    networks: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniCustom<{
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }, {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }>>>;
+    schemas: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+        $id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$loose>]>>>;
+}, z.core.$strip>;
+export type DomainConfigPayload = z.infer<typeof DomainConfigPayloadZod>;
+export declare const isDomainConfigPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.domain.config" & {
+        readonly __schema: true;
+    };
+    additional?: string[] | undefined;
+    aliases?: Record<string, {
+        huri: string;
+        name?: string | undefined;
+    }> | undefined;
+    networks?: {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }[] | undefined;
+    schemas?: Record<string, string | {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    }> | undefined;
+};
+export declare const asDomainConfigPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.domain.config" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.domain.config" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    };
+};
+export declare const toDomainConfigPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.domain.config" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.domain.config" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    };
+};
+//# sourceMappingURL=DomainConfigPayload.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/DomainConfigPlugin.d.ts

@@ -0,0 +1,33 @@
+export declare const DomainConfigPayloadPlugin: () => import("../../payload-plugin/neutral/index.ts").PayloadPlugin<{
+    schema: "network.xyo.domain.config" & {
+        readonly __schema: true;
+    };
+    additional?: string[] | undefined;
+    aliases?: Record<string, {
+        huri: string;
+        name?: string | undefined;
+    }> | undefined;
+    networks?: {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }[] | undefined;
+    schemas?: Record<string, string | {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    }> | undefined;
+}>;
+//# sourceMappingURL=DomainConfigPlugin.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/DomainConfigSchema.d.ts

@@ -0,0 +1,5 @@
+export declare const DomainConfigSchema: "network.xyo.domain.config" & {
+    readonly __schema: true;
+};
+export type DomainConfigSchema = typeof DomainConfigSchema;
+//# sourceMappingURL=DomainConfigSchema.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/DomainConfigTemplate.d.ts

@@ -0,0 +1,3 @@
+import type { DomainConfigPayload } from './DomainConfigPayload.ts';
+export declare const domainConfigPayloadTemplate: () => DomainConfigPayload;
+//# sourceMappingURL=DomainConfigTemplate.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/Payload.d.ts

@@ -0,0 +1,282 @@
+import * as z from 'zod/mini';
+export declare const AliasZod: z.ZodMiniObject<{
+    huri: z.ZodMiniString<string>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export type Alias = z.infer<typeof AliasZod>;
+/**
+ * An inline JSON Schema (draft-07) definition body. If $id is present it must equal the
+ * schemas map key; resolvers overwrite $id from the key (the key is authoritative).
+ */
+export declare const SchemaDefinitionZod: z.ZodMiniObject<{
+    $id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$loose>;
+export type SchemaDefinition = z.infer<typeof SchemaDefinitionZod>;
+/**
+ * One entry in the schemas map: a string is a hash (or HURI href) of a
+ * network.xyo.schema payload; an object is an inline JSON Schema definition.
+ */
+export declare const SchemaMapEntryZod: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+    $id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$loose>]>;
+export type SchemaMapEntry = z.infer<typeof SchemaMapEntryZod>;
+export declare const DomainConfigFieldsZod: z.ZodMiniObject<{
+    additional: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    aliases: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+        huri: z.ZodMiniString<string>;
+        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>>>;
+    networks: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniCustom<{
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }, {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }>>>;
+    schemas: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+        $id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$loose>]>>>;
+}, z.core.$strip>;
+export type DomainConfigFields = z.infer<typeof DomainConfigFieldsZod>;
+export declare const DomainPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.domain" & {
+        readonly __schema: true;
+    }>;
+    additional: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    aliases: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+        huri: z.ZodMiniString<string>;
+        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>>>;
+    networks: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniCustom<{
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }, {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }>>>;
+    schemas: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+        $id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$loose>]>>>;
+}, z.core.$strip>;
+export type DomainPayload = z.infer<typeof DomainPayloadZod>;
+export declare const isDomainPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.domain" & {
+        readonly __schema: true;
+    };
+    additional?: string[] | undefined;
+    aliases?: Record<string, {
+        huri: string;
+        name?: string | undefined;
+    }> | undefined;
+    networks?: {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }[] | undefined;
+    schemas?: Record<string, string | {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    }> | undefined;
+};
+export declare const asDomainPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.domain" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.domain" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    };
+};
+export declare const toDomainPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.domain" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.domain" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    };
+};
+//# sourceMappingURL=Payload.d.ts.map