@xyo-network/sdk 2.102.4 → 7.0.2

package/dist/_pkg/sentinel-model/neutral/Config.d.ts

@@ -0,0 +1,31 @@
+import type { WithAdditional } from '@xylabs/sdk';
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { ModuleConfig } from '../../module-model/neutral/index.ts';
+import { ModuleConfigZod } from '../../module-model/neutral/index.ts';
+import { type Payload, type Schema } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+import type { SentinelAutomationPayload } from './Automation.ts';
+import type { Task } from './Task.ts';
+export declare const SentinelConfigSchema: 'network.xyo.sentinel.config' & {
+    readonly __schema: true;
+};
+export type SentinelConfigSchema = typeof SentinelConfigSchema;
+export declare const SentinelConfigZod: z.ZodMiniObject<Omit<(typeof ModuleConfigZod)['shape'], 'schema'> & {
+    schema: z.ZodMiniLiteral<SentinelConfigSchema>;
+} & {
+    automations: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniCustom<SentinelAutomationPayload, SentinelAutomationPayload>>>;
+    synchronous: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    tasks: z.ZodMiniArray<z.ZodMiniCustom<Task, Task>>;
+    throwErrors: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strip>;
+export type SentinelConfigBase = z.infer<typeof SentinelConfigZod>;
+export declare const isSentinelConfig: ReturnType<typeof zodIsFactory<SentinelConfigBase>>;
+export declare const asSentinelConfig: ReturnType<typeof zodAsFactory<SentinelConfigBase>>;
+export declare const toSentinelConfig: ReturnType<typeof zodToFactory<SentinelConfigBase>>;
+export type SentinelConfig<TConfig extends Payload | void = void, TSchema extends Schema | void = void> = ModuleConfig<WithAdditional<{
+    automations?: SentinelAutomationPayload[];
+    schema: TConfig extends Payload ? TConfig['schema'] : SentinelConfigSchema;
+    synchronous?: boolean;
+    tasks: Task[];
+    throwErrors?: boolean;
+}, TConfig>, TSchema>;

package/dist/_pkg/sentinel-model/neutral/EventData.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleEventData, QueryableModule } from '../../module-model/neutral/index.ts';
+import type { JobEndEventData, JobStartEventData, ReportEndEventData, ReportStartEventData, TaskEndEventData, TaskStartEventData } from './EventsModels/index.ts';
+export interface SentinelModuleEventData<T extends QueryableModule = QueryableModule> extends TaskEndEventData<T>, TaskStartEventData<T>, JobEndEventData<T>, JobStartEventData<T>, ReportEndEventData<T>, ReportStartEventData<T>, ModuleEventData<T> {
+}

package/dist/_pkg/sentinel-model/neutral/EventsModels/JobEnd.d.ts

@@ -0,0 +1,10 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+import type { Payload, XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+export type JobEndEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    finalResult?: Record<XyoAddress, Payload[]>;
+    inPayloads?: Payload[];
+}>;
+export interface JobEndEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    jobEnd: JobEndEventArgs<T>;
+}

package/dist/_pkg/sentinel-model/neutral/EventsModels/JobStart.d.ts

@@ -0,0 +1,9 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+import type { Payload } from '../../../sdk-protocol/neutral/index.ts';
+export type JobStartEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    inPayloads?: Payload[];
+}>;
+export interface JobStartEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    jobStart: JobStartEventArgs<T>;
+}

package/dist/_pkg/sentinel-model/neutral/EventsModels/ReportEnd.d.ts

@@ -0,0 +1,11 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+import type { BoundWitness, Payload } from '../../../sdk-protocol/neutral/index.ts';
+export type ReportEndEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    boundwitness?: BoundWitness;
+    inPayloads?: Payload[];
+    outPayloads?: Payload[];
+}>;
+export interface ReportEndEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    reportEnd: ReportEndEventArgs<T>;
+}

package/dist/_pkg/sentinel-model/neutral/EventsModels/ReportStart.d.ts

@@ -0,0 +1,9 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+import type { Payload } from '../../../sdk-protocol/neutral/index.ts';
+export type ReportStartEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    inPayloads?: Payload[];
+}>;
+export interface ReportStartEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    reportStart: ReportStartEventArgs<T>;
+}

package/dist/_pkg/sentinel-model/neutral/EventsModels/TaskEnd.d.ts

@@ -0,0 +1,12 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+import type { Payload, XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+export type TaskEndEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    address: XyoAddress;
+    inPayloads?: Payload[];
+    name?: string;
+    outPayloads?: Payload[];
+}>;
+export interface TaskEndEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    taskEnd: TaskEndEventArgs<T>;
+}

package/dist/_pkg/sentinel-model/neutral/EventsModels/TaskStart.d.ts

@@ -0,0 +1,11 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+import type { Payload, XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+export type TaskStartEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    address: XyoAddress;
+    inPayloads?: Payload[];
+    name?: string;
+}>;
+export interface TaskStartEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    taskStart: TaskStartEventArgs<T>;
+}

package/dist/_pkg/sentinel-model/neutral/EventsModels/index.d.ts

@@ -0,0 +1,6 @@
+export * from './JobEnd.ts';
+export * from './JobStart.ts';
+export * from './ReportEnd.ts';
+export * from './ReportStart.ts';
+export * from './TaskEnd.ts';
+export * from './TaskStart.ts';

package/dist/_pkg/sentinel-model/neutral/Instance.d.ts

@@ -0,0 +1,9 @@
+import type { ModuleInstance } from '../../module-model/neutral/index.ts';
+import type { SentinelModuleEventData } from './EventData.ts';
+import type { CustomSentinelModule, SentinelModule } from './Module.ts';
+import type { SentinelParams } from './Params.ts';
+import type { Sentinel } from './Sentinel.ts';
+export interface SentinelInstance<TParams extends SentinelParams = SentinelParams, TEventData extends SentinelModuleEventData = SentinelModuleEventData> extends SentinelModule<TParams, TEventData>, Sentinel, ModuleInstance<TParams, TEventData> {
+}
+export interface CustomSentinelInstance<TParams extends SentinelParams = SentinelParams, TEvents extends SentinelModuleEventData<SentinelInstance<TParams>> = SentinelModuleEventData<SentinelInstance<TParams>>> extends CustomSentinelModule<TParams, TEvents>, Sentinel, SentinelInstance<TParams, TEvents> {
+}

package/dist/_pkg/sentinel-model/neutral/Job.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedTask } from './ResolvedTask.ts';
+export interface SentinelJob {
+    tasks: ResolvedTask[][];
+}

package/dist/_pkg/sentinel-model/neutral/Module.d.ts

@@ -0,0 +1,7 @@
+import type { QueryableModule } from '../../module-model/neutral/index.ts';
+import type { SentinelModuleEventData } from './EventData.ts';
+import type { SentinelParams } from './Params.ts';
+export interface SentinelModule<TParams extends SentinelParams = SentinelParams, TEventData extends SentinelModuleEventData = SentinelModuleEventData> extends QueryableModule<TParams, TEventData> {
+}
+export interface CustomSentinelModule<TParams extends SentinelParams = SentinelParams, TEvents extends SentinelModuleEventData<SentinelModule<TParams>> = SentinelModuleEventData<SentinelModule<TParams>>> extends QueryableModule<TParams, TEvents> {
+}

package/dist/_pkg/sentinel-model/neutral/Params.d.ts

@@ -0,0 +1,4 @@
+import type { AnyConfigSchema, QueryableModuleParams } from '../../module-model/neutral/index.ts';
+import type { SentinelConfig } from './Config.ts';
+export interface SentinelParams<TConfig extends AnyConfigSchema<SentinelConfig> = AnyConfigSchema<SentinelConfig>> extends QueryableModuleParams<TConfig> {
+}

package/dist/_pkg/sentinel-model/neutral/Queries/Report.d.ts

@@ -0,0 +1,14 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const SentinelReportQuerySchema: 'network.xyo.query.sentinel.report' & {
+    readonly __schema: true;
+};
+export type SentinelReportQuerySchema = typeof SentinelReportQuerySchema;
+export declare const SentinelReportQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<SentinelReportQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
+export type SentinelReportQuery = z.infer<typeof SentinelReportQueryZod>;
+export declare const isSentinelReportQuery: ReturnType<typeof zodIsFactory<SentinelReportQuery>>;
+export declare const asSentinelReportQuery: ReturnType<typeof zodAsFactory<SentinelReportQuery>>;
+export declare const toSentinelReportQuery: ReturnType<typeof zodToFactory<SentinelReportQuery>>;

package/dist/_pkg/sentinel-model/neutral/Queries/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Report.ts';
+import type { ModuleQueries } from '../../../module-model/neutral/index.ts';
+import type { SentinelReportQuery } from './Report.ts';
+export type SentinelQueries = SentinelReportQuery;
+export type SentinelModuleQueries = ModuleQueries | SentinelQueries;

package/dist/_pkg/sentinel-model/neutral/ResolvedTask.d.ts

@@ -0,0 +1,13 @@
+import type { ArchivistInstance } from '../../archivist-model/neutral/index.ts';
+import type { DivinerInstance } from '../../diviner-model/neutral/index.ts';
+import type { ModuleInstance } from '../../module-model/neutral/index.ts';
+import type { WitnessInstance } from '../../witness-model/neutral/index.ts';
+import type { ArchivistTask, DivinerTask, ModuleTask, WitnessTask } from './Task.ts';
+export type ResolvedModuleTask<TTask extends ModuleTask = ModuleTask, TInstance extends ModuleInstance = ModuleInstance> = Omit<TTask, 'mod'> & {
+    /** @field the modules that performs the task */
+    mod: TInstance;
+};
+export type ResolvedArchivistTask = ResolvedModuleTask<ArchivistTask, ArchivistInstance>;
+export type ResolvedDivinerTask = ResolvedModuleTask<DivinerTask, DivinerInstance>;
+export type ResolvedWitnessTask = ResolvedModuleTask<WitnessTask, WitnessInstance>;
+export type ResolvedTask = ResolvedArchivistTask | ResolvedDivinerTask | ResolvedWitnessTask | ResolvedModuleTask;

package/dist/_pkg/sentinel-model/neutral/Sentinel.d.ts

@@ -0,0 +1,7 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { ModuleQueryResult } from '../../module-model/neutral/index.ts';
+import type { AccountInstance, Payload } from '../../sdk-protocol/neutral/index.ts';
+export interface Sentinel<TIn extends Payload = Payload, TOut extends Payload = Payload> {
+    report: (payloads?: TIn[]) => Promisable<TOut[]>;
+    reportQuery: (payloads?: TIn[], account?: AccountInstance) => Promisable<ModuleQueryResult<TOut>>;
+}

package/dist/_pkg/sentinel-model/neutral/Task.d.ts

@@ -0,0 +1,14 @@
+import type { ModuleIdentifier } from '../../module-model/neutral/index.ts';
+export interface ModuleTask<TEndpoints extends string = string> {
+    /** @field the name of the endPoint that is being called.  If not specified, the default endPoint is used */
+    endPoint?: TEndpoints;
+    /** @field determines what inputs are sent to each module - if string, that is the output from other module (name/address) */
+    input?: boolean | ModuleIdentifier | ModuleIdentifier[];
+    /** @field the modules that performs the task */
+    mod: ModuleIdentifier;
+    required?: boolean;
+}
+export type ArchivistTask = ModuleTask<'all' | 'clear' | 'commit' | 'delete' | 'get' | 'insert'>;
+export type DivinerTask = ModuleTask<'divine'>;
+export type WitnessTask = ModuleTask<'observe'>;
+export type Task = WitnessTask | DivinerTask | ArchivistTask | ModuleTask;

package/dist/_pkg/sentinel-model/neutral/attachable/AttachableInstance.d.ts

@@ -0,0 +1,12 @@
+import type { TypeCheck } from '@xylabs/sdk';
+import { IsObjectFactory } from '@xylabs/sdk';
+import type { AttachableModuleInstance } from '../../../module-model/neutral/index.ts';
+import type { SentinelModuleEventData } from '../EventData.ts';
+import type { SentinelInstance } from '../Instance.ts';
+import type { SentinelModule } from '../Module.ts';
+import type { SentinelParams } from '../Params.ts';
+export interface AttachableSentinelInstance<TParams extends SentinelParams = SentinelParams, TEventData extends SentinelModuleEventData = SentinelModuleEventData> extends SentinelModule<TParams, TEventData>, AttachableModuleInstance<TParams, TEventData>, SentinelInstance<TParams, TEventData> {
+}
+export type AttachableSentinelInstanceTypeCheck<T extends AttachableSentinelInstance = AttachableSentinelInstance> = TypeCheck<T>;
+export declare class IsAttachableSentinelInstanceFactory<T extends AttachableSentinelInstance = AttachableSentinelInstance> extends IsObjectFactory<T> {
+}

package/dist/_pkg/sentinel-model/neutral/attachable/asAttachableInstance.d.ts

@@ -0,0 +1 @@
+export declare const asAttachableSentinelInstance: import("@xylabs/sdk").AsTypeFunction<import("./AttachableInstance.ts").AttachableSentinelInstance<import("../Params.ts").SentinelParams<import("../../../module-model/neutral/index.ts").AnyConfigSchema<import("../Config.ts").SentinelConfig>>, import("../EventData.ts").SentinelModuleEventData<import("../../../module-model/neutral/index.ts").QueryableModule<import("../../../module-model/neutral/index.ts").QueryableModuleParams<import("../../../module-model/neutral/index.ts").AnyConfigSchema<import("../../../module-model/neutral/index.ts").ModuleConfig>>, import("../../../module-model/neutral/index.ts").ModuleEventData<object>>>>>;

package/dist/_pkg/sentinel-model/neutral/attachable/index.d.ts

@@ -0,0 +1,3 @@
+export * from './asAttachableInstance.ts';
+export * from './AttachableInstance.ts';
+export * from './isAttachableInstance.ts';

package/dist/_pkg/sentinel-model/neutral/attachable/isAttachableInstance.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectTypeShape, TypeCheck } from '@xylabs/sdk';
+import type { AttachableSentinelInstance } from './AttachableInstance.ts';
+export declare const requiredAttachableSentinelInstanceFunctions: ObjectTypeShape;
+export declare const isAttachableSentinelInstance: TypeCheck<AttachableSentinelInstance>;

package/dist/_pkg/sentinel-model/neutral/index.d.ts

@@ -0,0 +1,14 @@
+export * from './attachable/index.ts';
+export * from './Automation.ts';
+export * from './Config.ts';
+export * from './EventData.ts';
+export * from './EventsModels/index.ts';
+export * from './Instance.ts';
+export * from './Job.ts';
+export * from './Module.ts';
+export * from './Params.ts';
+export * from './Queries/index.ts';
+export * from './ResolvedTask.ts';
+export * from './Sentinel.ts';
+export * from './Task.ts';
+export * from './typeChecks.ts';

package/dist/_pkg/sentinel-model/neutral/index.mjs

@@ -0,0 +1,150 @@
+// src/attachable/asAttachableInstance.ts
+import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/sdk";
+
+// src/attachable/isAttachableInstance.ts
+import { IsObjectFactory } from "@xylabs/sdk";
+import { isAttachableModuleInstance } from "../../module-model/neutral/index.mjs";
+
+// src/typeChecks.ts
+import { AsObjectFactory } from "@xylabs/sdk";
+import {
+  IsInstanceFactory,
+  isModuleInstance,
+  IsQueryableModuleFactory,
+  WithFactory
+} from "../../module-model/neutral/index.mjs";
+
+// src/Queries/Report.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import {
+  asSchema,
+  PayloadZodOfSchema,
+  QueryFieldsZod
+} from "../../sdk-protocol/neutral/index.mjs";
+import * as z from "zod/mini";
+var SentinelReportQuerySchema = asSchema("network.xyo.query.sentinel.report", true);
+var SentinelReportQueryZod = z.extend(PayloadZodOfSchema(SentinelReportQuerySchema), { ...QueryFieldsZod.shape });
+var isSentinelReportQuery = zodIsFactory(SentinelReportQueryZod);
+var asSentinelReportQuery = zodAsFactory(SentinelReportQueryZod, "asSentinelReportQuery");
+var toSentinelReportQuery = zodToFactory(SentinelReportQueryZod, "toSentinelReportQuery");
+
+// src/typeChecks.ts
+var isSentinelInstance = new IsInstanceFactory().create({ report: "function" }, [isModuleInstance]);
+var isSentinelModule = new IsQueryableModuleFactory().create([SentinelReportQuerySchema]);
+var asSentinelModule = AsObjectFactory.create(isSentinelModule);
+var asSentinelInstance = AsObjectFactory.create(isSentinelInstance);
+var withSentinelModule = WithFactory.create(isSentinelModule);
+var withSentinelInstance = WithFactory.create(isSentinelInstance);
+
+// src/attachable/isAttachableInstance.ts
+var requiredAttachableSentinelInstanceFunctions = {};
+var factory = new IsObjectFactory();
+var isAttachableSentinelInstance = factory.create(requiredAttachableSentinelInstanceFunctions, [
+  isSentinelInstance,
+  isAttachableModuleInstance
+]);
+
+// src/attachable/asAttachableInstance.ts
+var asAttachableSentinelInstance = AsObjectFactory2.create(isAttachableSentinelInstance);
+
+// src/attachable/AttachableInstance.ts
+import { IsObjectFactory as IsObjectFactory2 } from "@xylabs/sdk";
+var IsAttachableSentinelInstanceFactory = class extends IsObjectFactory2 {
+};
+
+// src/Automation.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk";
+import { asSchema as asSchema2, PayloadZodOfSchema as PayloadZodOfSchema2 } from "../../sdk-protocol/neutral/index.mjs";
+import * as z2 from "zod/mini";
+var SentinelAutomationSchema = asSchema2("network.xyo.automation", true);
+var SentinelIntervalAutomationSchema = asSchema2("network.xyo.automation.interval", true);
+var SentinelModuleEventAutomationSchema = asSchema2("network.xyo.automation.event.module", true);
+var SentinelIntervalAutomationZod = z2.extend(PayloadZodOfSchema2(SentinelIntervalAutomationSchema), {
+  /** Epoch after which any reoccurrence stops */
+  end: z2.optional(z2.number()),
+  /** Time between triggers [non-repeating if undefined] */
+  frequency: z2.optional(z2.number()),
+  /** Units for frequency field [hour if undefined] */
+  frequencyUnits: z2.optional(z2.union([z2.literal("second"), z2.literal("minute"), z2.literal("hour"), z2.literal("day"), z2.literal("millis")])),
+  /** Remaining triggers [infinite if undefined] */
+  remaining: z2.optional(z2.number()),
+  /** Epoch of the next trigger */
+  start: z2.optional(z2.number()),
+  /** The type of automation */
+  type: z2.literal("interval")
+});
+var isSentinelIntervalAutomation = zodIsFactory2(SentinelIntervalAutomationZod);
+var asSentinelIntervalAutomation = zodAsFactory2(SentinelIntervalAutomationZod, "asSentinelIntervalAutomation");
+var toSentinelIntervalAutomation = zodToFactory2(SentinelIntervalAutomationZod, "toSentinelIntervalAutomation");
+var SentinelModuleEventAutomationZod = z2.extend(PayloadZodOfSchema2(SentinelModuleEventAutomationSchema), {
+  eventName: z2.custom(),
+  source: z2.custom(),
+  type: z2.literal("event")
+});
+var isSentinelModuleEventAutomation = zodIsFactory2(SentinelModuleEventAutomationZod);
+var asSentinelModuleEventAutomation = zodAsFactory2(SentinelModuleEventAutomationZod, "asSentinelModuleEventAutomation");
+var toSentinelModuleEventAutomation = zodToFactory2(SentinelModuleEventAutomationZod, "toSentinelModuleEventAutomation");
+
+// src/Config.ts
+import {
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@xylabs/sdk";
+import { ModuleConfigZod } from "../../module-model/neutral/index.mjs";
+import {
+  asSchema as asSchema3
+} from "../../sdk-protocol/neutral/index.mjs";
+import * as z3 from "zod/mini";
+var SentinelConfigSchema = asSchema3("network.xyo.sentinel.config", true);
+var SentinelConfigZod = z3.extend(ModuleConfigZod, {
+  schema: z3.literal(SentinelConfigSchema),
+  automations: z3.optional(z3.array(z3.custom())),
+  synchronous: z3.optional(z3.boolean()),
+  tasks: z3.array(z3.custom()),
+  throwErrors: z3.optional(z3.boolean())
+});
+var isSentinelConfig = zodIsFactory3(SentinelConfigZod);
+var asSentinelConfig = zodAsFactory3(SentinelConfigZod, "asSentinelConfig");
+var toSentinelConfig = zodToFactory3(SentinelConfigZod, "toSentinelConfig");
+export {
+  IsAttachableSentinelInstanceFactory,
+  SentinelAutomationSchema,
+  SentinelConfigSchema,
+  SentinelConfigZod,
+  SentinelIntervalAutomationSchema,
+  SentinelIntervalAutomationZod,
+  SentinelModuleEventAutomationSchema,
+  SentinelModuleEventAutomationZod,
+  SentinelReportQuerySchema,
+  SentinelReportQueryZod,
+  asAttachableSentinelInstance,
+  asSentinelConfig,
+  asSentinelInstance,
+  asSentinelIntervalAutomation,
+  asSentinelModule,
+  asSentinelModuleEventAutomation,
+  asSentinelReportQuery,
+  isAttachableSentinelInstance,
+  isSentinelConfig,
+  isSentinelInstance,
+  isSentinelIntervalAutomation,
+  isSentinelModule,
+  isSentinelModuleEventAutomation,
+  isSentinelReportQuery,
+  requiredAttachableSentinelInstanceFunctions,
+  toSentinelConfig,
+  toSentinelIntervalAutomation,
+  toSentinelModuleEventAutomation,
+  toSentinelReportQuery,
+  withSentinelInstance,
+  withSentinelModule
+};

package/dist/_pkg/sentinel-model/neutral/typeChecks.d.ts

@@ -0,0 +1,10 @@
+import type { SentinelInstance } from './Instance.ts';
+import type { SentinelModule } from './Module.ts';
+export declare const isSentinelInstance: import("@xylabs/sdk").TypeCheck<SentinelInstance<import("./Params.ts").SentinelParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").SentinelConfig>>, import("./EventData.ts").SentinelModuleEventData<import("../../module-model/neutral/index.ts").QueryableModule<import("../../module-model/neutral/index.ts").QueryableModuleParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("../../module-model/neutral/index.ts").ModuleConfig>>, import("../../module-model/neutral/index.ts").ModuleEventData<object>>>>>;
+export declare const isSentinelModule: import("../../module-model/neutral/index.ts").QueryableModuleTypeCheck<SentinelModule<import("./Params.ts").SentinelParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").SentinelConfig>>, import("./EventData.ts").SentinelModuleEventData<import("../../module-model/neutral/index.ts").QueryableModule<import("../../module-model/neutral/index.ts").QueryableModuleParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("../../module-model/neutral/index.ts").ModuleConfig>>, import("../../module-model/neutral/index.ts").ModuleEventData<object>>>>>;
+export declare const asSentinelModule: import("@xylabs/sdk").AsTypeFunction<SentinelModule<import("./Params.ts").SentinelParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").SentinelConfig>>, import("./EventData.ts").SentinelModuleEventData<import("../../module-model/neutral/index.ts").QueryableModule<import("../../module-model/neutral/index.ts").QueryableModuleParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("../../module-model/neutral/index.ts").ModuleConfig>>, import("../../module-model/neutral/index.ts").ModuleEventData<object>>>>>;
+export declare const asSentinelInstance: import("@xylabs/sdk").AsTypeFunction<SentinelInstance<import("./Params.ts").SentinelParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").SentinelConfig>>, import("./EventData.ts").SentinelModuleEventData<import("../../module-model/neutral/index.ts").QueryableModule<import("../../module-model/neutral/index.ts").QueryableModuleParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("../../module-model/neutral/index.ts").ModuleConfig>>, import("../../module-model/neutral/index.ts").ModuleEventData<object>>>>>;
+/** @deprecated use narrowing instead [ if(is) ] */
+export declare const withSentinelModule: <R>(mod: any, closure: (mod: SentinelModule<import("./Params.ts").SentinelParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").SentinelConfig>>, import("./EventData.ts").SentinelModuleEventData<import("../../module-model/neutral/index.ts").QueryableModule<import("../../module-model/neutral/index.ts").QueryableModuleParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("../../module-model/neutral/index.ts").ModuleConfig>>, import("../../module-model/neutral/index.ts").ModuleEventData<object>>>>) => R) => R | undefined;
+/** @deprecated use narrowing instead [ if(is) ] */
+export declare const withSentinelInstance: <R>(mod: any, closure: (mod: SentinelInstance<import("./Params.ts").SentinelParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").SentinelConfig>>, import("./EventData.ts").SentinelModuleEventData<import("../../module-model/neutral/index.ts").QueryableModule<import("../../module-model/neutral/index.ts").QueryableModuleParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("../../module-model/neutral/index.ts").ModuleConfig>>, import("../../module-model/neutral/index.ts").ModuleEventData<object>>>>) => R) => R | undefined;

package/dist/_pkg/sentinel-wrapper/neutral/Wrapper.d.ts

@@ -0,0 +1,16 @@
+import type { TypeCheck } from '@xylabs/sdk';
+import type { ArchivistInstance } from '../../archivist-model/neutral/index.ts';
+import type { ModuleQueryResult, QueryableModuleTypeCheck } from '../../module-model/neutral/index.ts';
+import { ModuleWrapper } from '../../module-wrapper/neutral/index.ts';
+import type { AccountInstance, Payload } from '../../sdk-protocol/neutral/index.ts';
+import type { SentinelInstance, SentinelModule } from '../../sentinel-model/neutral/index.ts';
+import type { WitnessInstance } from '../../witness-model/neutral/index.ts';
+export declare class SentinelWrapper<TModule extends SentinelModule = SentinelModule> extends ModuleWrapper<TModule> implements SentinelInstance<TModule['params']> {
+    static readonly instanceIdentityCheck: TypeCheck<SentinelInstance>;
+    static readonly moduleIdentityCheck: QueryableModuleTypeCheck<SentinelModule>;
+    static readonly requiredQueries: string[];
+    archivists(): Promise<ArchivistInstance[]>;
+    report(payloads?: Payload[]): Promise<Payload[]>;
+    reportQuery(payloads?: Payload[], account?: AccountInstance): Promise<ModuleQueryResult>;
+    witnesses(): Promise<WitnessInstance[]>;
+}

package/dist/_pkg/sentinel-wrapper/neutral/index.d.ts

@@ -0,0 +1 @@
+export * from './Wrapper.ts';

package/dist/_pkg/sentinel-wrapper/neutral/index.mjs

@@ -0,0 +1,30 @@
+// src/Wrapper.ts
+import { constructableModuleWrapper, ModuleWrapper } from "../../module-wrapper/neutral/index.mjs";
+import {
+  isSentinelInstance,
+  isSentinelModule,
+  SentinelReportQuerySchema
+} from "../../sentinel-model/neutral/index.mjs";
+constructableModuleWrapper();
+var SentinelWrapper = class extends ModuleWrapper {
+  static instanceIdentityCheck = isSentinelInstance;
+  static moduleIdentityCheck = isSentinelModule;
+  static requiredQueries = [SentinelReportQuerySchema, ...super.requiredQueries];
+  archivists() {
+    throw new Error("Not supported");
+  }
+  async report(payloads) {
+    const queryPayload = { schema: SentinelReportQuerySchema };
+    return await this.sendQuery(queryPayload, payloads);
+  }
+  async reportQuery(payloads, account) {
+    const queryPayload = { schema: SentinelReportQuerySchema };
+    return await this.sendQueryRaw(queryPayload, payloads, account);
+  }
+  witnesses() {
+    throw new Error("Not supported");
+  }
+};
+export {
+  SentinelWrapper
+};

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

@@ -0,0 +1,45 @@
+import type { JsonValue } from '@xylabs/sdk';
+import * as z from 'zod/mini';
+export declare const ValuePayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.value" & {
+        readonly __schema: true;
+    }>;
+    value: z.ZodMiniCustom<unknown, unknown>;
+}, z.core.$strip>;
+export type Value<T extends JsonValue = JsonValue> = z.infer<typeof ValuePayloadZod> & {
+    value: T;
+};
+export declare const isValuePayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.value" & {
+        readonly __schema: true;
+    };
+    value: unknown;
+};
+export declare const asValuePayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.value" & {
+            readonly __schema: true;
+        };
+        value: unknown;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.value" & {
+            readonly __schema: true;
+        };
+        value: unknown;
+    };
+};
+export declare const toValuePayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.value" & {
+            readonly __schema: true;
+        };
+        value: unknown;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.value" & {
+            readonly __schema: true;
+        };
+        value: unknown;
+    };
+};

package/dist/_pkg/value-payload-plugin/neutral/Plugin.d.ts

@@ -0,0 +1,2 @@
+import type { Value } from './Payload.ts';
+export declare const ValuePayloadPlugin: () => import("../../payload-plugin/neutral/index.ts").PayloadPlugin<Value>;

package/dist/_pkg/value-payload-plugin/neutral/Schema.d.ts

@@ -0,0 +1,4 @@
+export declare const ValueSchema: "network.xyo.value" & {
+    readonly __schema: true;
+};
+export type ValueSchema = typeof ValueSchema;

package/dist/_pkg/value-payload-plugin/neutral/Template.d.ts

@@ -0,0 +1,2 @@
+import type { Value } from './Payload.ts';
+export declare const valuePayloadTemplate: () => Value;

package/dist/_pkg/value-payload-plugin/neutral/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Payload.ts';
+export { ValuePayloadPlugin as default, ValuePayloadPlugin } from './Plugin.ts';
+export * from './Schema.ts';
+export * from './Template.ts';

package/dist/_pkg/value-payload-plugin/neutral/index.mjs

@@ -0,0 +1,43 @@
+// src/Payload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { PayloadZodOfSchema } from "../../payload-model/neutral/index.mjs";
+import * as z from "zod/mini";
+
+// src/Schema.ts
+import { asSchema } from "../../payload-model/neutral/index.mjs";
+var ValueSchema = asSchema("network.xyo.value", true);
+
+// src/Payload.ts
+var ValuePayloadZod = z.extend(PayloadZodOfSchema(ValueSchema), { value: z.custom() });
+var isValuePayload = zodIsFactory(ValuePayloadZod);
+var asValuePayload = zodAsFactory(ValuePayloadZod, "asValuePayload");
+var toValuePayload = zodToFactory(ValuePayloadZod, "toValuePayload");
+
+// src/Plugin.ts
+import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
+
+// src/Template.ts
+var valuePayloadTemplate = () => ({
+  schema: ValueSchema,
+  value: null
+});
+
+// src/Plugin.ts
+var ValuePayloadPlugin = () => createPayloadPlugin({
+  schema: ValueSchema,
+  template: valuePayloadTemplate
+});
+export {
+  ValuePayloadPlugin,
+  ValuePayloadZod,
+  ValueSchema,
+  asValuePayload,
+  ValuePayloadPlugin as default,
+  isValuePayload,
+  toValuePayload,
+  valuePayloadTemplate
+};

package/dist/_pkg/wallet/neutral/HDWallet.d.ts

@@ -0,0 +1,37 @@
+import type { Hex } from '@xylabs/sdk';
+import { Account } from '../../account/neutral/index.ts';
+import type { AccountConfig } from '../../account-model/neutral/index.ts';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { PrivateKeyInstance } from '../../key-model/neutral/index.ts';
+import type { WalletInstance } from '../../wallet-model/neutral/index.ts';
+import { HDNodeWallet, Mnemonic } from 'ethers';
+export declare class HDWallet extends Account implements WalletInstance {
+    static readonly uniqueName: string;
+    protected static _addressMap: Record<XyoAddress, WeakRef<WalletInstance>>;
+    protected readonly node: HDNodeWallet;
+    neuter: () => HDWallet;
+    constructor(key: symbol, node: HDNodeWallet, privateKey: PrivateKeyInstance);
+    protected static createFromNodeInternal(node: HDNodeWallet, previousHash?: string): Promise<WalletInstance>;
+    protected static getCachedWalletOrCacheNewWallet(createdWallet: WalletInstance): WalletInstance;
+    static create(opts?: AccountConfig): Promise<WalletInstance>;
+    static createFromNode(node: HDNodeWallet, previousHash?: string): Promise<WalletInstance>;
+    static fromExtendedKey(key: string): Promise<WalletInstance>;
+    static fromMnemonic(mnemonic: Mnemonic, path?: string): Promise<WalletInstance>;
+    static fromPhrase(phrase: string, path?: string): Promise<WalletInstance>;
+    static fromSeed(seed: string | ArrayBufferLike): Promise<WalletInstance>;
+    static generateMnemonic(wordlist?: string[], strength?: number): string;
+    static random(): Promise<WalletInstance>;
+    get address(): XyoAddress;
+    get addressBytes(): ArrayBufferLike;
+    get chainCode(): string;
+    get depth(): number;
+    get extendedKey(): string;
+    get fingerprint(): string;
+    get index(): number;
+    get mnemonic(): Mnemonic | null;
+    get parentFingerprint(): string;
+    get path(): string | null;
+    get privateKey(): Hex;
+    get publicKey(): Hex;
+    derivePath(path: string): Promise<WalletInstance>;
+}