@xyo-network/sdk 2.102.4 → 7.0.3

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Queries/LocationQuadkeyHeatmapQuery/LocationQuadkeyHeatmapQuery.d.ts

@@ -0,0 +1,20 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import * as z from 'zod/mini';
+import { LocationWitnessSchema } from '../../Witnesses/index.ts';
+export declare const LocationQuadkeyHeatmapQuerySchema: 'network.xyo.location.heatmap.quadkey.query' & {
+    readonly __schema: true;
+};
+export type LocationQuadkeyHeatmapQuerySchema = typeof LocationQuadkeyHeatmapQuerySchema;
+export declare const LocationQuadkeyHeatmapAnswerSchema: 'network.xyo.location.heatmap.quadkey.answer' & {
+    readonly __schema: true;
+};
+export type LocationQuadkeyHeatmapAnswerSchema = typeof LocationQuadkeyHeatmapAnswerSchema;
+export declare const LocationQuadkeyHeatmapQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<LocationWitnessSchema>;
+    startTime: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    stopTime: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export type LocationQuadkeyHeatmapQuery = z.infer<typeof LocationQuadkeyHeatmapQueryZod>;
+export declare const isLocationQuadkeyHeatmapQuery: ReturnType<typeof zodIsFactory<LocationQuadkeyHeatmapQuery>>;
+export declare const asLocationQuadkeyHeatmapQuery: ReturnType<typeof zodAsFactory<LocationQuadkeyHeatmapQuery>>;
+export declare const toLocationQuadkeyHeatmapQuery: ReturnType<typeof zodToFactory<LocationQuadkeyHeatmapQuery>>;

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Queries/LocationQuadkeyHeatmapQuery/index.d.ts

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

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Queries/LocationQueryCreationRequest.d.ts

@@ -0,0 +1,17 @@
+import type { ApiConfig } from '../../../../sdk-protocol/neutral/index.ts';
+import type { LocationHeatmapQuery, LocationHeatmapQuerySchema } from './LocationHeatmapQuery/index.ts';
+import type { LocationQuadkeyHeatmapQuery, LocationQuadkeyHeatmapQuerySchema } from './LocationQuadkeyHeatmapQuery/index.ts';
+import type { LocationQuerySchema } from './LocationQuerySchema.ts';
+import type { LocationTimeRangeQuery, LocationTimeRangeQuerySchema } from './LocationTimeRangeQuery/index.ts';
+export interface LocationQueryCreationRequest<TSchema extends LocationQuerySchema = LocationQuerySchema, TQuery extends object = object> {
+    query: TQuery;
+    resultArchive: string;
+    resultArchivist: ApiConfig;
+    schema: TSchema;
+    sourceArchive: string;
+    sourceArchivist: ApiConfig;
+}
+export type LocationTimeRangeQueryCreationRequest = LocationQueryCreationRequest<LocationTimeRangeQuerySchema, LocationTimeRangeQuery>;
+export type LocationHeatmapQueryCreationRequest = LocationQueryCreationRequest<LocationHeatmapQuerySchema, LocationHeatmapQuery>;
+export type LocationQuadkeyHeatmapQueryCreationRequest = LocationQueryCreationRequest<LocationQuadkeyHeatmapQuerySchema, LocationQuadkeyHeatmapQuery>;
+export type SupportedLocationQueryCreationRequest = LocationTimeRangeQueryCreationRequest | LocationHeatmapQueryCreationRequest | LocationQuadkeyHeatmapQueryCreationRequest;

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Queries/LocationQueryCreationResponse.d.ts

@@ -0,0 +1,4 @@
+import type { LocationQueryCreationRequest } from './LocationQueryCreationRequest.ts';
+export interface LocationQueryCreationResponse extends LocationQueryCreationRequest {
+    hash: string;
+}

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Queries/LocationQuerySchema.d.ts

@@ -0,0 +1,6 @@
+import type { Schema } from '../../../../sdk-protocol/neutral/index.ts';
+import type { LocationHeatmapQuerySchema } from './LocationHeatmapQuery/index.ts';
+import type { LocationQuadkeyHeatmapQuerySchema } from './LocationQuadkeyHeatmapQuery/index.ts';
+import type { LocationTimeRangeQuerySchema } from './LocationTimeRangeQuery/index.ts';
+export type LocationQuerySchema = LocationQuadkeyHeatmapQuerySchema | LocationHeatmapQuerySchema | LocationTimeRangeQuerySchema;
+export declare const isSupportedLocationQuerySchema: (schema: Schema) => schema is LocationQuerySchema;

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Queries/LocationTimeRangeQuery/LocationTimeRangePointProperties.d.ts

@@ -0,0 +1,7 @@
+import type { LocationWitnessSchema } from '../../Witnesses/index.ts';
+export interface LocationTimeRangePointProperties {
+    _archive: string;
+    _client: string;
+    _timestamp: number;
+    schema: LocationWitnessSchema;
+}

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Queries/LocationTimeRangeQuery/LocationTimeRangeQuery.d.ts

@@ -0,0 +1,20 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import * as z from 'zod/mini';
+import { LocationWitnessSchema } from '../../Witnesses/index.ts';
+export declare const LocationTimeRangeQuerySchema: 'network.xyo.location.range.query' & {
+    readonly __schema: true;
+};
+export type LocationTimeRangeQuerySchema = typeof LocationTimeRangeQuerySchema;
+export declare const LocationTimeRangeAnswerSchema: 'network.xyo.location.range.answer' & {
+    readonly __schema: true;
+};
+export type LocationTimeRangeAnswerSchema = typeof LocationTimeRangeAnswerSchema;
+export declare const LocationTimeRangeQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<LocationWitnessSchema>;
+    startTime: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    stopTime: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export type LocationTimeRangeQuery = z.infer<typeof LocationTimeRangeQueryZod>;
+export declare const isLocationTimeRangeQuery: ReturnType<typeof zodIsFactory<LocationTimeRangeQuery>>;
+export declare const asLocationTimeRangeQuery: ReturnType<typeof zodAsFactory<LocationTimeRangeQuery>>;
+export declare const toLocationTimeRangeQuery: ReturnType<typeof zodToFactory<LocationTimeRangeQuery>>;

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Queries/LocationTimeRangeQuery/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LocationTimeRangePointProperties.ts';
+export * from './LocationTimeRangeQuery.ts';

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Queries/index.d.ts

@@ -0,0 +1,6 @@
+export * from './LocationHeatmapQuery/index.ts';
+export * from './LocationQuadkeyHeatmapQuery/index.ts';
+export * from './LocationQueryCreationRequest.ts';
+export * from './LocationQueryCreationResponse.ts';
+export * from './LocationQuerySchema.ts';
+export * from './LocationTimeRangeQuery/index.ts';

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Witnesses/CurrentLocationWitness.d.ts

@@ -0,0 +1,19 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import * as z from 'zod/mini';
+export declare const CurrentLocationWitnessSchema: 'co.coinapp.currentlocationwitness' & {
+    readonly __schema: true;
+};
+export type CurrentLocationWitnessSchema = typeof CurrentLocationWitnessSchema;
+export declare const CurrentLocationWitnessPayloadZod: z.ZodMiniObject<{
+    altitudeMeters: z.ZodMiniNumber<number>;
+    directionDegrees: z.ZodMiniNumber<number>;
+    latitude: z.ZodMiniNumber<number>;
+    longitude: z.ZodMiniNumber<number>;
+    quadkey: z.ZodMiniString<string>;
+    schema: z.ZodMiniLiteral<CurrentLocationWitnessSchema>;
+    speedKph: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type CurrentLocationWitnessPayload = z.infer<typeof CurrentLocationWitnessPayloadZod>;
+export declare const isCurrentLocationWitnessPayload: ReturnType<typeof zodIsFactory<CurrentLocationWitnessPayload>>;
+export declare const asCurrentLocationWitnessPayload: ReturnType<typeof zodAsFactory<CurrentLocationWitnessPayload>>;
+export declare const toCurrentLocationWitnessPayload: ReturnType<typeof zodToFactory<CurrentLocationWitnessPayload>>;

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Witnesses/LocationWitness.d.ts

@@ -0,0 +1,27 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import * as z from 'zod/mini';
+export declare const LocationWitnessSchema: 'network.xyo.location' & {
+    readonly __schema: true;
+};
+export type LocationWitnessSchema = typeof LocationWitnessSchema;
+export interface Coordinates {
+    accuracy: number | null;
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    latitude: number;
+    longitude: number;
+    speed: number | null;
+}
+export interface CurrentLocation {
+    coords: Coordinates;
+    timestamp: number;
+}
+export declare const LocationWitnessPayloadZod: z.ZodMiniObject<{
+    currentLocation: z.ZodMiniCustom<CurrentLocation, CurrentLocation>;
+    schema: z.ZodMiniLiteral<LocationWitnessSchema>;
+}, z.core.$strip>;
+export type LocationWitnessPayload = z.infer<typeof LocationWitnessPayloadZod>;
+export declare const isLocationWitnessPayload: ReturnType<typeof zodIsFactory<LocationWitnessPayload>>;
+export declare const asLocationWitnessPayload: ReturnType<typeof zodAsFactory<LocationWitnessPayload>>;
+export declare const toLocationWitnessPayload: ReturnType<typeof zodToFactory<LocationWitnessPayload>>;

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/Witnesses/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CurrentLocationWitness.ts';
+export * from './LocationWitness.ts';

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/index.d.ts

@@ -0,0 +1,4 @@
+export * from './LocationDivinerApi.ts';
+export * from './models.ts';
+export * from './Queries/index.ts';
+export * from './Witnesses/index.ts';

package/dist/_pkg/api-location-diviner/neutral/LocationDiviner/models.d.ts

@@ -0,0 +1,4 @@
+export interface GetLocationQueryResponse {
+    answerHash?: string;
+    queryHash: string;
+}

package/dist/_pkg/api-location-diviner/neutral/RemoteDivinerConfig.d.ts

@@ -0,0 +1,18 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import { DivinerConfigZod } from '../../diviner-model/neutral/index.ts';
+import type { ArchivistApi } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const RemoteDivinerConfigSchema: 'network.xyo.diviner.remote.config' & {
+    readonly __schema: true;
+};
+export type RemoteDivinerConfigSchema = typeof RemoteDivinerConfigSchema;
+export declare const RemoteDivinerConfigZod: z.ZodMiniObject<Omit<(typeof DivinerConfigZod)['shape'], 'schema'> & {
+    /** @deprecated use in params instead */
+    api: z.ZodMiniOptional<z.ZodMiniCustom<ArchivistApi, ArchivistApi>>;
+    archive: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    schema: z.ZodMiniLiteral<RemoteDivinerConfigSchema>;
+}, z.core.$strip>;
+export type RemoteDivinerConfig = z.infer<typeof RemoteDivinerConfigZod>;
+export declare const isRemoteDivinerConfig: ReturnType<typeof zodIsFactory<RemoteDivinerConfig>>;
+export declare const asRemoteDivinerConfig: ReturnType<typeof zodAsFactory<RemoteDivinerConfig>>;
+export declare const toRemoteDivinerConfig: ReturnType<typeof zodToFactory<RemoteDivinerConfig>>;

package/dist/_pkg/api-location-diviner/neutral/RemoteDivinerError.d.ts

@@ -0,0 +1,5 @@
+export declare class RemoteDivinerError extends Error {
+    isRemoteDivinerError: boolean;
+    constructor(action: string, error: Error['cause'], message?: string);
+    static isRemoteDivinerError(error: unknown): RemoteDivinerError | undefined;
+}

package/dist/_pkg/api-location-diviner/neutral/index.d.ts

@@ -0,0 +1,3 @@
+export * from './LocationDiviner/index.ts';
+export * from './RemoteDivinerConfig.ts';
+export * from './RemoteDivinerError.ts';

package/dist/_pkg/api-location-diviner/neutral/index.mjs

@@ -0,0 +1,192 @@
+// src/LocationDiviner/LocationDivinerApi.ts
+import { assertEx, fetchJsonClient } from "@xylabs/sdk";
+var LocationDivinerApi = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async getLocationQuery(hash) {
+    const response = await fetchJsonClient.get(`${this.config.apiDomain}/location/query/${hash}`);
+    return assertEx(response.data?.data, () => "LocationDivinerApi.getLocationQuery: missing response data");
+  }
+  async postLocationQuery(request) {
+    const response = await fetchJsonClient.post(`${this.config.apiDomain}/location/query`, { ...request });
+    return assertEx(response.data?.data, () => "LocationDivinerApi.postLocationQuery: missing response data");
+  }
+};
+
+// src/LocationDiviner/Queries/LocationHeatmapQuery/LocationHeatmapQuery.ts
+import {
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@xylabs/sdk";
+import { asSchema as asSchema3 } from "../../sdk-protocol/neutral/index.mjs";
+import * as z3 from "zod/mini";
+
+// src/LocationDiviner/Witnesses/CurrentLocationWitness.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { asSchema, PayloadZodOfSchema } from "../../sdk-protocol/neutral/index.mjs";
+import * as z from "zod/mini";
+var CurrentLocationWitnessSchema = asSchema("co.coinapp.currentlocationwitness", true);
+var CurrentLocationWitnessPayloadZod = z.extend(PayloadZodOfSchema(CurrentLocationWitnessSchema), {
+  altitudeMeters: z.number(),
+  directionDegrees: z.number(),
+  latitude: z.number(),
+  longitude: z.number(),
+  quadkey: z.string(),
+  speedKph: z.number()
+});
+var isCurrentLocationWitnessPayload = zodIsFactory(CurrentLocationWitnessPayloadZod);
+var asCurrentLocationWitnessPayload = zodAsFactory(CurrentLocationWitnessPayloadZod, "asCurrentLocationWitnessPayload");
+var toCurrentLocationWitnessPayload = zodToFactory(CurrentLocationWitnessPayloadZod, "toCurrentLocationWitnessPayload");
+
+// src/LocationDiviner/Witnesses/LocationWitness.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 LocationWitnessSchema = asSchema2("network.xyo.location", true);
+var LocationWitnessPayloadZod = z2.extend(PayloadZodOfSchema2(LocationWitnessSchema), { currentLocation: z2.custom() });
+var isLocationWitnessPayload = zodIsFactory2(LocationWitnessPayloadZod);
+var asLocationWitnessPayload = zodAsFactory2(LocationWitnessPayloadZod, "asLocationWitnessPayload");
+var toLocationWitnessPayload = zodToFactory2(LocationWitnessPayloadZod, "toLocationWitnessPayload");
+
+// src/LocationDiviner/Queries/LocationHeatmapQuery/LocationHeatmapQuery.ts
+var LocationHeatmapQuerySchema = asSchema3("network.xyo.location.heatmap.query", true);
+var LocationHeatmapAnswerSchema = asSchema3("network.xyo.location.heatmap.answer", true);
+var LocationHeatmapQueryZod = z3.object({
+  schema: z3.literal(LocationWitnessSchema),
+  startTime: z3.optional(z3.string()),
+  stopTime: z3.optional(z3.string())
+});
+var isLocationHeatmapQuery = zodIsFactory3(LocationHeatmapQueryZod);
+var asLocationHeatmapQuery = zodAsFactory3(LocationHeatmapQueryZod, "asLocationHeatmapQuery");
+var toLocationHeatmapQuery = zodToFactory3(LocationHeatmapQueryZod, "toLocationHeatmapQuery");
+
+// src/LocationDiviner/Queries/LocationQuadkeyHeatmapQuery/LocationQuadkeyHeatmapQuery.ts
+import {
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory4
+} from "@xylabs/sdk";
+import { asSchema as asSchema4 } from "../../sdk-protocol/neutral/index.mjs";
+import * as z4 from "zod/mini";
+var LocationQuadkeyHeatmapQuerySchema = asSchema4("network.xyo.location.heatmap.quadkey.query", true);
+var LocationQuadkeyHeatmapAnswerSchema = asSchema4("network.xyo.location.heatmap.quadkey.answer", true);
+var LocationQuadkeyHeatmapQueryZod = z4.object({
+  schema: z4.literal(LocationWitnessSchema),
+  startTime: z4.optional(z4.string()),
+  stopTime: z4.optional(z4.string())
+});
+var isLocationQuadkeyHeatmapQuery = zodIsFactory4(LocationQuadkeyHeatmapQueryZod);
+var asLocationQuadkeyHeatmapQuery = zodAsFactory4(LocationQuadkeyHeatmapQueryZod, "asLocationQuadkeyHeatmapQuery");
+var toLocationQuadkeyHeatmapQuery = zodToFactory4(LocationQuadkeyHeatmapQueryZod, "toLocationQuadkeyHeatmapQuery");
+
+// src/LocationDiviner/Queries/LocationQuerySchema.ts
+var locationQuerySchemas = {
+  "network.xyo.location.heatmap.quadkey.query": true,
+  "network.xyo.location.heatmap.query": true,
+  "network.xyo.location.range.query": true
+};
+var isSupportedLocationQuerySchema = (schema) => {
+  return locationQuerySchemas[schema] || false;
+};
+
+// src/LocationDiviner/Queries/LocationTimeRangeQuery/LocationTimeRangeQuery.ts
+import {
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory5
+} from "@xylabs/sdk";
+import { asSchema as asSchema5 } from "../../sdk-protocol/neutral/index.mjs";
+import * as z5 from "zod/mini";
+var LocationTimeRangeQuerySchema = asSchema5("network.xyo.location.range.query", true);
+var LocationTimeRangeAnswerSchema = asSchema5("network.xyo.location.range.answer", true);
+var LocationTimeRangeQueryZod = z5.object({
+  schema: z5.literal(LocationWitnessSchema),
+  startTime: z5.optional(z5.string()),
+  // TODO: Bounding rectangle, etc.
+  stopTime: z5.optional(z5.string())
+});
+var isLocationTimeRangeQuery = zodIsFactory5(LocationTimeRangeQueryZod);
+var asLocationTimeRangeQuery = zodAsFactory5(LocationTimeRangeQueryZod, "asLocationTimeRangeQuery");
+var toLocationTimeRangeQuery = zodToFactory5(LocationTimeRangeQueryZod, "toLocationTimeRangeQuery");
+
+// src/RemoteDivinerConfig.ts
+import {
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory6
+} from "@xylabs/sdk";
+import { DivinerConfigZod } from "../../diviner-model/neutral/index.mjs";
+import { asSchema as asSchema6 } from "../../sdk-protocol/neutral/index.mjs";
+import * as z6 from "zod/mini";
+var RemoteDivinerConfigSchema = asSchema6("network.xyo.diviner.remote.config", true);
+var RemoteDivinerConfigZod = z6.extend(DivinerConfigZod, {
+  /** @deprecated use in params instead */
+  api: z6.optional(z6.custom()),
+  archive: z6.optional(z6.string()),
+  schema: z6.literal(RemoteDivinerConfigSchema)
+});
+var isRemoteDivinerConfig = zodIsFactory6(RemoteDivinerConfigZod);
+var asRemoteDivinerConfig = zodAsFactory6(RemoteDivinerConfigZod, "asRemoteDivinerConfig");
+var toRemoteDivinerConfig = zodToFactory6(RemoteDivinerConfigZod, "toRemoteDivinerConfig");
+
+// src/RemoteDivinerError.ts
+import { isString } from "@xylabs/sdk";
+var RemoteDivinerError = class extends Error {
+  isRemoteDivinerError = true;
+  constructor(action, error, message) {
+    const messageString = isString(message) ? ` (${message})` : "";
+    super(`Remote Diviner [${action}] failed${messageString}`, { cause: error });
+  }
+  static isRemoteDivinerError(error) {
+    return error.isRemoteDivinerError ? error : void 0;
+  }
+};
+export {
+  CurrentLocationWitnessPayloadZod,
+  CurrentLocationWitnessSchema,
+  LocationDivinerApi,
+  LocationHeatmapAnswerSchema,
+  LocationHeatmapQuerySchema,
+  LocationHeatmapQueryZod,
+  LocationQuadkeyHeatmapAnswerSchema,
+  LocationQuadkeyHeatmapQuerySchema,
+  LocationQuadkeyHeatmapQueryZod,
+  LocationTimeRangeAnswerSchema,
+  LocationTimeRangeQuerySchema,
+  LocationTimeRangeQueryZod,
+  LocationWitnessPayloadZod,
+  LocationWitnessSchema,
+  RemoteDivinerConfigSchema,
+  RemoteDivinerConfigZod,
+  RemoteDivinerError,
+  asCurrentLocationWitnessPayload,
+  asLocationHeatmapQuery,
+  asLocationQuadkeyHeatmapQuery,
+  asLocationTimeRangeQuery,
+  asLocationWitnessPayload,
+  asRemoteDivinerConfig,
+  isCurrentLocationWitnessPayload,
+  isLocationHeatmapQuery,
+  isLocationQuadkeyHeatmapQuery,
+  isLocationTimeRangeQuery,
+  isLocationWitnessPayload,
+  isRemoteDivinerConfig,
+  isSupportedLocationQuerySchema,
+  toCurrentLocationWitnessPayload,
+  toLocationHeatmapQuery,
+  toLocationQuadkeyHeatmapQuery,
+  toLocationTimeRangeQuery,
+  toLocationWitnessPayload,
+  toRemoteDivinerConfig
+};

package/dist/_pkg/api-models/neutral/Config.d.ts

@@ -0,0 +1,24 @@
+import type { ApiReportable } from './Reportable.ts';
+interface ApiConfig extends ApiReportable {
+    /** @description The domain where the API is located */
+    apiDomain: string;
+    /** @description The apiKey used for authentication */
+    apiKey?: string;
+    /** @description Threshold for Content-Size to cause automatic gzip of request body [default = 1024] */
+    compressionThreshold?: number;
+    /** @description The jwtToken of the currently logged in user */
+    jwtToken?: string;
+    /** @description The query string, if any, that is added to the end of every request */
+    query?: string;
+    /** @description Parent that should also report events from this API */
+    reportableParent?: ApiReportable;
+    /** @description The location in the API tree where this API object is mounted */
+    root?: string;
+    /** @description Throw on error */
+    throwError?: boolean;
+    /** @description Throw on failures */
+    throwFailure?: boolean;
+    /** @deprecated use the jwtToken instead */
+    userid?: string;
+}
+export type { ApiConfig };

package/dist/_pkg/api-models/neutral/Envelope.d.ts

@@ -0,0 +1,14 @@
+import type { ApiError } from './Error.ts';
+import type { ApiWarning } from './Warning.ts';
+export interface ApiEnvelopeBase {
+    warning?: ApiWarning[];
+}
+export interface ApiEnvelopeSuccess<T> extends ApiEnvelopeBase {
+    data: T;
+    errors: never;
+}
+export interface ApiEnvelopeError extends ApiEnvelopeBase {
+    data: never;
+    errors: ApiError[];
+}
+export type ApiEnvelope<T> = ApiEnvelopeSuccess<T> | ApiEnvelopeError;

package/dist/_pkg/api-models/neutral/Error.d.ts

@@ -0,0 +1,4 @@
+import type { FetchClientError } from '@xylabs/sdk';
+export interface ApiError<T = unknown> extends FetchClientError<T> {
+    isError: true;
+}

package/dist/_pkg/api-models/neutral/Reportable.d.ts

@@ -0,0 +1,7 @@
+import type { ApiError } from './Error.ts';
+import type { ApiResponse } from './Response.ts';
+export interface ApiReportable {
+    onError?: (error: ApiError, depth: number) => void;
+    onFailure?: (response: ApiResponse, depth: number) => void;
+    onSuccess?: (response: ApiResponse, depth: number) => void;
+}

package/dist/_pkg/api-models/neutral/Response.d.ts

@@ -0,0 +1,7 @@
+import type { FetchJsonResponse } from '@xylabs/sdk';
+import type { ApiEnvelope } from './Envelope.ts';
+export type ApiResponse<T = unknown> = FetchJsonResponse<T>;
+export type ApiResponseBody<T> = T | undefined;
+export type ApiResponseTuple<T> = [T | undefined, ApiEnvelope<T | undefined>, ApiResponse<ApiEnvelope<T | undefined>>];
+export type ApiResponseTupleOrBody<T> = ApiResponseTuple<T> | ApiResponseBody<T>;
+export type ApiResponseType = 'body' | 'tuple';

package/dist/_pkg/api-models/neutral/Warning.d.ts

@@ -0,0 +1 @@
+export type ApiWarning = Error;

package/dist/_pkg/api-models/neutral/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Config.ts';
+export * from './Envelope.ts';
+export * from './Error.ts';
+export * from './Reportable.ts';
+export * from './Response.ts';
+export * from './Warning.ts';

package/dist/_pkg/api-models/neutral/index.mjs

@@ -0,0 +1 @@
+

package/dist/_pkg/archivist/neutral/abstract.d.ts

@@ -0,0 +1 @@
+export * from '../../archivist-abstract/neutral/index.ts';

package/dist/_pkg/archivist/neutral/abstract.mjs

@@ -0,0 +1,2 @@
+// src/abstract.ts
+export * from "../../archivist-abstract/neutral/index.mjs";

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

@@ -0,0 +1,4 @@
+export * from '../../archivist-abstract/neutral/index.ts';
+export * from '../../archivist-memory/neutral/index.ts';
+export * from '../../archivist-model/neutral/index.ts';
+export * from '../../archivist-wrapper/neutral/index.ts';

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

@@ -0,0 +1,5 @@
+// src/index.ts
+export * from "../../archivist-abstract/neutral/index.mjs";
+export * from "../../archivist-memory/neutral/index.mjs";
+export * from "../../archivist-model/neutral/index.mjs";
+export * from "../../archivist-wrapper/neutral/index.mjs";

package/dist/_pkg/archivist/neutral/model.d.ts

@@ -0,0 +1 @@
+export * from '../../archivist-model/neutral/index.ts';

package/dist/_pkg/archivist/neutral/model.mjs

@@ -0,0 +1,2 @@
+// src/model.ts
+export * from "../../archivist-model/neutral/index.mjs";

package/dist/_pkg/archivist/neutral/wrapper.d.ts

@@ -0,0 +1 @@
+export * from '../../archivist-wrapper/neutral/index.ts';

package/dist/_pkg/archivist/neutral/wrapper.mjs

@@ -0,0 +1,2 @@
+// src/wrapper.ts
+export * from "../../archivist-wrapper/neutral/index.mjs";

package/dist/_pkg/archivist-abstract/neutral/AbstractArchivist.d.ts

@@ -0,0 +1,82 @@
+import type { Attributes, Gauge, Meter } from '@opentelemetry/api';
+import type { Hash, Promisable, PromisableArray } from '@xylabs/sdk';
+import type { ArchivistInstance, ArchivistModuleEventData, ArchivistNextOptions, ArchivistParams, ArchivistSnapshotPayload, ArchivistStatsPayload, AttachableArchivistInstance, ReadArchivist } from '../../archivist-model/neutral/index.ts';
+import { AbstractModuleInstance } from '../../module-abstract/neutral/index.ts';
+import type { ModuleConfig, ModuleIdentifier, ModuleQueryHandlerResult, ModuleQueryResult } from '../../module-model/neutral/index.ts';
+import type { AccountInstance, BoundWitness, Payload, QueryBoundWitness, Schema, WithStorageMeta } from '../../sdk-protocol/neutral/index.ts';
+import { QueryBoundWitnessWrapper } from '../../sdk-protocol/neutral/index.ts';
+export interface ActionConfig {
+    emitEvents?: boolean;
+}
+export interface InsertConfig extends ActionConfig {
+    writeToParents?: boolean;
+}
+interface ArchivistParentInstanceMap {
+    commit?: Partial<Record<ModuleIdentifier, ArchivistInstance>>;
+    read?: Partial<Record<ModuleIdentifier, ArchivistInstance>>;
+    write?: Partial<Record<ModuleIdentifier, ArchivistInstance>>;
+}
+export declare abstract class AbstractArchivist<TParams extends ArchivistParams = ArchivistParams, TEventData extends ArchivistModuleEventData = ArchivistModuleEventData> extends AbstractModuleInstance<TParams, TEventData> implements AttachableArchivistInstance<TParams, TEventData, Payload> {
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    static readonly labels: {
+        'network.xyo.storage.class': string;
+    };
+    static readonly uniqueName: string;
+    protected static defaultNextLimitSetting: number;
+    private _getCache?;
+    private _parentArchivists?;
+    private _payloadCountGauge?;
+    private _payloadCountMeter?;
+    static get defaultNextLimit(): number;
+    get queries(): Schema[];
+    get requireAllParents(): boolean;
+    protected get payloadCountGauge(): Gauge<Attributes> | null | undefined;
+    protected get payloadCountMeter(): Meter | null;
+    protected get storeParentReads(): boolean;
+    /** @deprecated use next or snapshot instead */
+    all(): Promise<WithStorageMeta<Payload>[]>;
+    /** deprecated use nextQuery or snapshotQuery instead */
+    allQuery(account: AccountInstance): Promise<ModuleQueryResult>;
+    clear(): Promise<void>;
+    clearQuery(account: AccountInstance): Promise<ModuleQueryResult>;
+    commit(): Promise<BoundWitness[]>;
+    commitQuery(account: AccountInstance): Promise<ModuleQueryResult>;
+    delete(hashes: Hash[]): Promise<WithStorageMeta<Payload>[]>;
+    deleteQuery(hashes: Hash[], account?: AccountInstance): Promise<ModuleQueryResult>;
+    get(hashes: Hash[]): Promise<WithStorageMeta<Payload>[]>;
+    getQuery(hashes: Hash[], account?: AccountInstance): Promise<ModuleQueryResult>;
+    insert(payloads: Payload[]): Promise<WithStorageMeta<Payload>[]>;
+    insertQuery(payloads: Payload[], account?: AccountInstance): Promise<ModuleQueryResult>;
+    next(options?: ArchivistNextOptions): Promise<WithStorageMeta<Payload>[]>;
+    nextQuery(options?: ArchivistNextOptions, account?: AccountInstance): Promise<ModuleQueryResult>;
+    snapshot(): Promise<ArchivistSnapshotPayload<WithStorageMeta<Payload>, Hash>[]>;
+    snapshotQuery(account?: AccountInstance): Promise<ModuleQueryResult>;
+    protected allHandler(): PromisableArray<WithStorageMeta<Payload>>;
+    protected clearHandler(): Promisable<void>;
+    protected commitHandler(): Promisable<BoundWitness[]>;
+    protected deleteHandler(_hashes: Hash[]): PromisableArray<WithStorageMeta<Payload>>;
+    protected deleteWithConfig(hashes: Hash[], config?: ActionConfig): Promise<WithStorageMeta<Payload>[]>;
+    protected generateStats(): Promisable<ArchivistStatsPayload>;
+    protected getFromParent(hashes: Hash[], archivist: ReadArchivist): Promise<[WithStorageMeta<Payload>[], Hash[]]>;
+    protected getFromParents(hashes: Hash[]): Promise<[WithStorageMeta<Payload>[], Hash[]]>;
+    protected getHandler(_hashes: Hash[]): Promisable<WithStorageMeta<Payload>[]>;
+    protected getWithConfig(hashes: Hash[], _config?: InsertConfig): Promise<WithStorageMeta<Payload>[]>;
+    protected insertHandler(_payloads: WithStorageMeta<Payload>[]): Promisable<WithStorageMeta<Payload>[]>;
+    protected insertQueryHandler<T extends QueryBoundWitnessWrapper = QueryBoundWitnessWrapper>(query: T, payloads?: Payload[]): Promise<WithStorageMeta<Payload>[]>;
+    protected insertWithConfig(payloads: Payload[], config?: InsertConfig): Promise<WithStorageMeta<Payload>[]>;
+    protected nextHandler(_options?: ArchivistNextOptions): Promisable<WithStorageMeta<Payload>[]>;
+    protected nextWithConfig(options?: ArchivistNextOptions, _config?: InsertConfig): Promise<WithStorageMeta<Payload>[]>;
+    protected parentArchivists(): Promise<ArchivistParentInstanceMap>;
+    protected payloadCountHandler(): number;
+    protected queryHandler<T extends QueryBoundWitness = QueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(query: T, payloads: Payload[], queryConfig?: TConfig): Promise<ModuleQueryHandlerResult>;
+    protected reportPayloadCount(): void;
+    protected snapshotHandler(): PromisableArray<ArchivistSnapshotPayload<WithStorageMeta<Payload>, Hash>>;
+    protected startHandler(): Promise<void>;
+    protected stateHandler(): Promise<Payload[]>;
+    protected writeToParent(parent: ArchivistInstance, payloads: Payload[]): Promise<Payload[]>;
+    protected writeToParents(payloads: Payload[]): Promise<Payload[]>;
+    private omitClientMetaForDataHashes;
+    private resolveArchivists;
+}
+export {};

package/dist/_pkg/archivist-abstract/neutral/StorageClassLabel.d.ts

@@ -0,0 +1,2 @@
+export declare const StorageClassLabel = "network.xyo.storage.class";
+export type StorageClassLabelValue = 'memory' | 'disk' | 'network' | 'proxy' | 'unknown';

package/dist/_pkg/archivist-abstract/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AbstractArchivist.ts';
+export * from './StorageClassLabel.ts';