@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/account-model/neutral/Jwt/types.d.ts

@@ -0,0 +1,56 @@
+export interface JwtHeader {
+    alg: string;
+    kid: string;
+    pub: string;
+    typ: string;
+}
+export interface JwtClaims {
+    aud: string;
+    exp: number;
+    iat: number;
+    iss: string;
+    nbf?: number;
+    nonce?: string;
+}
+export interface JwtPayload extends JwtClaims {
+    [key: string]: unknown;
+    schema: string;
+}
+export interface JwtParts {
+    header: JwtHeader;
+    headerB64: string;
+    payload: JwtPayload;
+    payloadB64: string;
+    signature: Uint8Array;
+    signatureB64: string;
+}
+export interface SignJwtOptions {
+    audience: string;
+    claims?: Record<string, unknown>;
+    exp?: number;
+    now?: number;
+    schema?: string;
+    ttl?: number;
+}
+export interface SignJwtResult {
+    header: JwtHeader;
+    payload: JwtPayload;
+    token: string;
+}
+export interface VerifyJwtOptions {
+    audience?: string;
+    now?: number;
+}
+export interface VerifyJwtSuccess {
+    header: JwtHeader;
+    ok: true;
+    payload: JwtPayload;
+}
+export interface VerifyJwtFailure {
+    header?: JwtHeader;
+    ok: false;
+    payload?: JwtPayload;
+    reasons: string[];
+}
+export type VerifyJwtResult = VerifyJwtSuccess | VerifyJwtFailure;
+//# sourceMappingURL=types.d.ts.map

package/dist/_pkg/account-model/neutral/VerifierRegistry.d.ts

@@ -0,0 +1,6 @@
+import type { AccountAlgorithm } from './Algorithm.ts';
+export type VerifySignatureFn = (address: string, hash: ArrayBufferLike, signature: ArrayBufferLike) => Promise<boolean>;
+export declare function registerVerifier(algorithm: AccountAlgorithm, fn: VerifySignatureFn): void;
+export declare function getVerifier(algorithm: AccountAlgorithm): VerifySignatureFn | undefined;
+export declare function verifySignature(address: string, hash: ArrayBufferLike, signature: ArrayBufferLike): Promise<boolean>;
+//# sourceMappingURL=VerifierRegistry.d.ts.map

package/dist/_pkg/account-model/neutral/addressTo20Bytes.d.ts

@@ -0,0 +1,2 @@
+export declare function addressTo20Bytes(address: string): ArrayBufferLike;
+//# sourceMappingURL=addressTo20Bytes.d.ts.map

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

@@ -0,0 +1,6 @@
+export * from './Account.ts';
+export * from './addressTo20Bytes.ts';
+export * from './Algorithm.ts';
+export * from './Jwt/index.ts';
+export * from './VerifierRegistry.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,100 @@
+// src/Account.ts
+import { isArrayBuffer } from "@xylabs/sdk";
+var ethMessagePrefix = "Ethereum Signed Message:\n";
+var isPhraseInitializationConfig = (value) => {
+  if (typeof value === "object" && value !== null) {
+    return typeof value.phrase === "string";
+  }
+  return false;
+};
+var isPrivateKeyInitializationConfig = (value) => {
+  if (typeof value === "object" && value !== null) {
+    return isArrayBuffer(value.privateKey);
+  }
+  return false;
+};
+var isMnemonicInitializationConfig = (value) => {
+  if (typeof value === "object" && value !== null) {
+    return typeof value.mnemonic === "string" && typeof (value.path ?? "") === "string";
+  }
+  return false;
+};
+var isInitializationConfig = (value) => {
+  return isPhraseInitializationConfig(value) || isPrivateKeyInitializationConfig(value) || isMnemonicInitializationConfig(value);
+};
+var isAccountInstance = (account) => {
+  if (typeof account !== "object" || account === null) return false;
+  return typeof account.address === "string";
+};
+
+// src/addressTo20Bytes.ts
+import { toUint8Array } from "@xylabs/sdk";
+import { tryDecodeQuantAddress } from "../../address/neutral/index.mjs";
+function addressTo20Bytes(address) {
+  const decoded = tryDecodeQuantAddress(address);
+  return (decoded === void 0 ? toUint8Array(address, 20) : decoded.bytes).buffer;
+}
+
+// src/Algorithm.ts
+import { tryDecodeQuantAddress as tryDecodeQuantAddress2 } from "../../address/neutral/index.mjs";
+var AlgorithmHrpEntries = [
+  ["ml-dsa-65", "qm65"]
+];
+var AccountAlgorithmHrp = Object.fromEntries(AlgorithmHrpEntries);
+var HrpToAlgorithm = Object.fromEntries(
+  AlgorithmHrpEntries.map(([algorithm, hrp]) => [hrp, algorithm])
+);
+function hrpForAlgorithm(algorithm) {
+  return AccountAlgorithmHrp[algorithm];
+}
+function algorithmFromAddress(address) {
+  const decoded = tryDecodeQuantAddress2(address);
+  if (decoded === void 0) return "secp256k1";
+  const algorithm = HrpToAlgorithm[decoded.hrp];
+  if (algorithm === void 0) {
+    throw new Error(`Unknown address algorithm HRP [${decoded.hrp}]`);
+  }
+  return algorithm;
+}
+
+// src/Jwt/constants.ts
+import { Enum } from "@xylabs/sdk";
+var JwtAlg = Enum({ ES256K: "ES256K" });
+var JwtTyp = Enum({ JWT: "JWT" });
+var JwtSchema = Enum({ Signin: "network.xyo.auth.signin" });
+
+// src/VerifierRegistry.ts
+var registry = {};
+function registerVerifier(algorithm, fn) {
+  registry[algorithm] = fn;
+}
+function getVerifier(algorithm) {
+  return registry[algorithm];
+}
+async function verifySignature(address, hash, signature) {
+  const algorithm = algorithmFromAddress(address);
+  const fn = registry[algorithm];
+  if (!fn) {
+    throw new Error(`No verifier registered for algorithm [${algorithm}]. Did you import the account package?`);
+  }
+  return await fn(address, hash, signature);
+}
+export {
+  AccountAlgorithmHrp,
+  JwtAlg,
+  JwtSchema,
+  JwtTyp,
+  addressTo20Bytes,
+  algorithmFromAddress,
+  ethMessagePrefix,
+  getVerifier,
+  hrpForAlgorithm,
+  isAccountInstance,
+  isInitializationConfig,
+  isMnemonicInitializationConfig,
+  isPhraseInitializationConfig,
+  isPrivateKeyInitializationConfig,
+  registerVerifier,
+  verifySignature
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/address/neutral/XyoAddress.d.ts

@@ -0,0 +1,38 @@
+import * as z from 'zod/mini';
+export declare const XyoAddressRegEx: RegExp;
+export declare const XyoAddressZod: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+    readonly __hex: true;
+} & {
+    readonly __address: true;
+}, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./XyoQuantAddress.ts").XyoQuantAddress, string>>]>;
+export type XyoAddress = z.infer<typeof XyoAddressZod>;
+export declare const isXyoAddress: <T>(value: T) => value is T & ((Lowercase<string> & {
+    readonly __hex: true;
+} & {
+    readonly __address: true;
+}) | import("./XyoQuantAddress.ts").XyoQuantAddress);
+export declare const asXyoAddress: {
+    <T>(value: T): (T & ((Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("./XyoQuantAddress.ts").XyoQuantAddress)) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & ((Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("./XyoQuantAddress.ts").XyoQuantAddress);
+};
+export declare const toXyoAddress: {
+    <T>(value: T): (T & ((Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("./XyoQuantAddress.ts").XyoQuantAddress)) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & ((Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("./XyoQuantAddress.ts").XyoQuantAddress);
+};
+//# sourceMappingURL=XyoAddress.d.ts.map

package/dist/_pkg/address/neutral/XyoLegacyAddress.d.ts

@@ -0,0 +1,37 @@
+import type { Address } from '@xylabs/sdk';
+export declare const XyoLegacyAddressZod: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+    readonly __hex: true;
+} & {
+    readonly __address: true;
+}, string>>;
+export type XyoLegacyAddress = Address;
+export declare const isXyoLegacyAddress: <T>(value: T) => value is T & Lowercase<string> & {
+    readonly __hex: true;
+} & {
+    readonly __address: true;
+};
+export declare const asXyoLegacyAddress: {
+    <T>(value: T): (T & Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    };
+};
+export declare const toXyoLegacyAddress: {
+    <T>(value: T): (T & Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    };
+};
+//# sourceMappingURL=XyoLegacyAddress.d.ts.map

package/dist/_pkg/address/neutral/XyoQuantAddress.d.ts

@@ -0,0 +1,33 @@
+import type { Brand } from '@xylabs/sdk';
+import * as z from 'zod/mini';
+export declare const XyoQuantAddressByteLength = 20;
+export type XyoQuantAddress = Brand<string, {
+    readonly __xyoQuantAddress: true;
+}>;
+export interface DecodedQuantAddress {
+    bytes: Uint8Array;
+    hrp: string;
+}
+export declare function encodeQuantAddress(hrp: string, bytes: ArrayBufferLike): XyoQuantAddress;
+export declare function tryDecodeQuantAddress(address: string): DecodedQuantAddress | undefined;
+export declare const XyoQuantAddressZod: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<XyoQuantAddress, string>>;
+export declare const isXyoQuantAddress: <T>(value: T) => value is T & string & {
+    readonly __xyoQuantAddress: true;
+};
+export declare const asXyoQuantAddress: {
+    <T>(value: T): (T & string & {
+        readonly __xyoQuantAddress: true;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & string & {
+        readonly __xyoQuantAddress: true;
+    };
+};
+export declare const toXyoQuantAddress: {
+    <T>(value: T): (T & string & {
+        readonly __xyoQuantAddress: true;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & string & {
+        readonly __xyoQuantAddress: true;
+    };
+};
+//# sourceMappingURL=XyoQuantAddress.d.ts.map

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

@@ -0,0 +1,4 @@
+export * from './XyoAddress.ts';
+export * from './XyoLegacyAddress.ts';
+export * from './XyoQuantAddress.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,75 @@
+// src/XyoAddress.ts
+import {
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@xylabs/sdk";
+import * as z2 from "zod/mini";
+
+// src/XyoLegacyAddress.ts
+import {
+  AddressZod,
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+var XyoLegacyAddressZod = AddressZod;
+var isXyoLegacyAddress = zodIsFactory(XyoLegacyAddressZod);
+var asXyoLegacyAddress = zodAsFactory(XyoLegacyAddressZod, "asXyoLegacyAddress");
+var toXyoLegacyAddress = zodToFactory(XyoLegacyAddressZod, "toXyoLegacyAddress");
+
+// src/XyoQuantAddress.ts
+import { bech32m } from "@scure/base";
+import {
+  toUint8Array,
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk";
+import * as z from "zod/mini";
+var XyoQuantAddressByteLength = 20;
+function encodeQuantAddress(hrp, bytes) {
+  return bech32m.encodeFromBytes(hrp, toUint8Array(bytes));
+}
+function tryDecodeQuantAddress(address) {
+  if (address !== address.toLowerCase()) return void 0;
+  try {
+    const { bytes, prefix } = bech32m.decodeToBytes(address);
+    return bytes.length === XyoQuantAddressByteLength ? { bytes, hrp: prefix } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var XyoQuantAddressZod = z.pipe(
+  z.string().check(z.refine((v) => tryDecodeQuantAddress(v) !== void 0)),
+  z.transform((v) => v)
+);
+var isXyoQuantAddress = zodIsFactory2(XyoQuantAddressZod);
+var asXyoQuantAddress = zodAsFactory2(XyoQuantAddressZod, "asXyoQuantAddress");
+var toXyoQuantAddress = zodToFactory2(XyoQuantAddressZod, "toXyoQuantAddress");
+
+// src/XyoAddress.ts
+var XyoAddressRegEx = /^(?:[0-9a-f]{40}|[a-z0-9]{1,83}1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38})$/;
+var XyoAddressZod = z2.union([XyoLegacyAddressZod, XyoQuantAddressZod]);
+var isXyoAddress = zodIsFactory3(XyoAddressZod);
+var asXyoAddress = zodAsFactory3(XyoAddressZod, "asXyoAddress");
+var toXyoAddress = zodToFactory3(XyoAddressZod, "toXyoAddress");
+export {
+  XyoAddressRegEx,
+  XyoAddressZod,
+  XyoLegacyAddressZod,
+  XyoQuantAddressByteLength,
+  XyoQuantAddressZod,
+  asXyoAddress,
+  asXyoLegacyAddress,
+  asXyoQuantAddress,
+  encodeQuantAddress,
+  isXyoAddress,
+  isXyoLegacyAddress,
+  isXyoQuantAddress,
+  toXyoAddress,
+  toXyoLegacyAddress,
+  toXyoQuantAddress,
+  tryDecodeQuantAddress
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/api/neutral/Api/Api.d.ts

@@ -0,0 +1,8 @@
+import type { ApiConfig } from '../../../api-models/neutral/index.ts';
+import { Huri } from '../../../huri/neutral/index.ts';
+import type { Payload } from '../../../payload-model/neutral/index.ts';
+import { ApiSimple } from '../Simple.ts';
+export declare class ArchivistApi<C extends ApiConfig = ApiConfig> extends ApiSimple<Payload[], C> {
+    huri(huri: Huri | string): ApiSimple<Payload, Payload, import("../../../payload-model/neutral/index.ts").PayloadFindFilter, ApiConfig>;
+}
+//# sourceMappingURL=Api.d.ts.map

package/dist/_pkg/api/neutral/Api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Api.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/api/neutral/Base.d.ts

@@ -0,0 +1,32 @@
+import { FetchJsonClient } from '@xylabs/sdk';
+import type { ApiConfig, ApiEnvelope, ApiError, ApiReportable, ApiResponse, ApiResponseBody, ApiResponseTuple } from '../../api-models/neutral/index.ts';
+export declare class ApiBase<C extends ApiConfig = ApiConfig> implements ApiReportable {
+    readonly config: C;
+    protected fetchClient: FetchJsonClient;
+    constructor(config: C);
+    private static resolveResponse;
+    private static shapeResponse;
+    private resolveRoot;
+    get authenticated(): boolean;
+    protected get headers(): Record<string, string>;
+    protected get query(): string;
+    protected get root(): string;
+    onError(error: ApiError, depth?: number): void;
+    onFailure(response: ApiResponse, depth?: number): void;
+    onSuccess(response: ApiResponse, depth?: number): void;
+    protected deleteEndpoint<T = unknown>(endPoint?: string): Promise<ApiResponseBody<T>>;
+    protected deleteEndpoint<T = unknown>(endPoint?: string, responseType?: 'body'): Promise<ApiResponseBody<T>>;
+    protected deleteEndpoint<T = unknown>(endPoint?: string, responseType?: 'tuple'): Promise<ApiResponseTuple<T>>;
+    protected getEndpoint<T = unknown>(endPoint?: string): Promise<ApiResponseBody<T>>;
+    protected getEndpoint<T = unknown>(endPoint?: string, responseType?: 'body'): Promise<ApiResponseBody<T>>;
+    protected getEndpoint<T = unknown>(endPoint?: string, responseType?: 'tuple'): Promise<ApiResponseTuple<T>>;
+    protected handleMonitorResponseError<T>(error: unknown, trapFetchException: boolean): ApiResponse<ApiEnvelope<T>> | undefined;
+    protected monitorResponse<T>(closure: () => Promise<ApiResponse<ApiEnvelope<T>>>): Promise<ApiResponse<ApiEnvelope<T>> | undefined>;
+    protected postEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D): Promise<ApiResponseBody<T>>;
+    protected postEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D, responseType?: 'body'): Promise<ApiResponseBody<T>>;
+    protected postEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D, responseType?: 'tuple'): Promise<ApiResponseTuple<T>>;
+    protected putEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D): Promise<ApiResponseBody<T>>;
+    protected putEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D, responseType?: 'body'): Promise<ApiResponseBody<T>>;
+    protected putEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D, responseType?: 'tuple'): Promise<ApiResponseTuple<T>>;
+}
+//# sourceMappingURL=Base.d.ts.map

package/dist/_pkg/api/neutral/Simple.d.ts

@@ -0,0 +1,22 @@
+import type { ApiConfig, ApiResponseBody, ApiResponseTuple } from '../../api-models/neutral/index.ts';
+import type { Payload, PayloadFindFilter } from '../../payload-model/neutral/index.ts';
+import { ApiBase } from './Base.ts';
+export type ApiSimpleQuery = PayloadFindFilter;
+export declare class ApiSimple<T = Payload, D = T, Q extends ApiSimpleQuery = ApiSimpleQuery, C extends ApiConfig = ApiConfig> extends ApiBase<C> {
+    delete(): Promise<ApiResponseBody<T>>;
+    delete(responseType?: 'body'): Promise<ApiResponseBody<T>>;
+    delete(responseType?: 'tuple'): Promise<ApiResponseTuple<T>>;
+    find(query?: Q): Promise<ApiResponseBody<T>>;
+    find(query?: Q, responseType?: 'body'): Promise<ApiResponseBody<T>>;
+    find(query?: Q, responseType?: 'tuple'): Promise<ApiResponseTuple<T>>;
+    get(): Promise<ApiResponseBody<T>>;
+    get(responseType?: 'body'): Promise<ApiResponseBody<T>>;
+    get(responseType?: 'tuple'): Promise<ApiResponseTuple<T>>;
+    post(data?: D): Promise<ApiResponseBody<T>>;
+    post(data?: D, responseType?: 'body'): Promise<ApiResponseBody<T>>;
+    post(data?: D, responseType?: 'tuple'): Promise<ApiResponseTuple<T>>;
+    put(data?: D): Promise<ApiResponseBody<T>>;
+    put(data?: D, responseType?: 'body'): Promise<ApiResponseBody<T>>;
+    put(data?: D, responseType?: 'tuple'): Promise<ApiResponseTuple<T>>;
+}
+//# sourceMappingURL=Simple.d.ts.map

package/dist/_pkg/api/neutral/WithArchive.d.ts

@@ -0,0 +1,4 @@
+export declare type WithArchive<ArchivistApiConfig> = ArchivistApiConfig & {
+    _archive?: string;
+};
+//# sourceMappingURL=WithArchive.d.ts.map

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

@@ -0,0 +1,6 @@
+export * from './Api/index.ts';
+export * from './Base.ts';
+export * from './models/index.ts';
+export * from './Simple.ts';
+export * from './WithArchive.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,187 @@
+// src/Api/Api.ts
+import { Huri } from "../../huri/neutral/index.mjs";
+
+// src/Base.ts
+import {
+  FetchClientError,
+  FetchJsonClient,
+  isString
+} from "@xylabs/sdk";
+var ApiBase = class _ApiBase {
+  config;
+  fetchClient;
+  constructor(config) {
+    this.config = config;
+    this.fetchClient = new FetchJsonClient({ ...this.config, headers: this.headers });
+  }
+  static resolveResponse(result) {
+    return [result?.data?.data, result?.data, result];
+  }
+  static shapeResponse(response, responseType) {
+    const resolvedResponse = this.resolveResponse(response);
+    return responseType === "tuple" ? resolvedResponse : resolvedResponse[0];
+  }
+  resolveRoot() {
+    return `${this.config.apiDomain}${this.root}`;
+  }
+  get authenticated() {
+    return isString(this.config.apiKey) || isString(this.config.jwtToken);
+  }
+  get headers() {
+    const headers = {};
+    if (isString(this.config.jwtToken)) {
+      headers.Authorization = `Bearer ${this.config.jwtToken}`;
+    }
+    if (isString(this.config.apiKey)) {
+      headers["x-api-key"] = this.config.apiKey;
+    }
+    return headers;
+  }
+  get query() {
+    return this.config.query ?? "";
+  }
+  get root() {
+    return this.config.root ?? "/";
+  }
+  onError(error, depth = 0) {
+    this.config.reportableParent?.onError?.(error, depth + 1);
+    this.config.onError?.(error, depth);
+  }
+  onFailure(response, depth = 0) {
+    this.config.reportableParent?.onFailure?.(response, depth + 1);
+    this.config.onFailure?.(response, depth);
+  }
+  onSuccess(response, depth = 0) {
+    this.config.reportableParent?.onSuccess?.(response, depth + 1);
+    this.config.onSuccess?.(response, depth);
+  }
+  async deleteEndpoint(endPoint = "", responseType) {
+    const response = await this.monitorResponse(async () => {
+      return await this.fetchClient.delete(`${this.resolveRoot()}${endPoint}${this.query}`);
+    });
+    return _ApiBase.shapeResponse(response, responseType);
+  }
+  async getEndpoint(endPoint = "", responseType) {
+    const response = await this.monitorResponse(async () => {
+      return await this.fetchClient.get(`${this.resolveRoot()}${endPoint}${this.query}`);
+    });
+    return _ApiBase.shapeResponse(response, responseType);
+  }
+  handleMonitorResponseError(error, trapFetchException) {
+    if (!(error instanceof FetchClientError)) {
+      throw error;
+    }
+    if (trapFetchException) {
+      this.onFailure(error.response);
+      if (this.config.throwFailure === true) {
+        throw error;
+      }
+      return error.response;
+    }
+  }
+  async monitorResponse(closure) {
+    let trapFetchException = true;
+    try {
+      const response = await closure();
+      trapFetchException = false;
+      if (response.status < 300) {
+        this.onSuccess(response);
+      } else {
+        this.onFailure(response);
+      }
+      return response;
+    } catch (error) {
+      this.handleMonitorResponseError(error, trapFetchException);
+    }
+  }
+  async postEndpoint(endPoint = "", data, responseType) {
+    const response = await this.monitorResponse(async () => {
+      return await this.fetchClient.post(`${this.resolveRoot()}${endPoint}${this.query}`, data);
+    });
+    return _ApiBase.shapeResponse(response, responseType);
+  }
+  async putEndpoint(endPoint = "", data, responseType) {
+    const response = await this.monitorResponse(async () => {
+      return await this.fetchClient.put(`${this.resolveRoot()}${endPoint}${this.query}`, data);
+    });
+    return _ApiBase.shapeResponse(response, responseType);
+  }
+};
+
+// src/objToQuery.ts
+var objToQuery = (obj) => {
+  return `?${Object.entries(obj).map(([key, value]) => {
+    return `${key}=${value}`;
+  }).filter((value) => value !== void 0).join("&")}`;
+};
+
+// src/Simple.ts
+var ApiSimple = class extends ApiBase {
+  async delete(responseType) {
+    switch (responseType) {
+      case "tuple": {
+        return await this.deleteEndpoint(void 0, "tuple");
+      }
+      default: {
+        return await this.deleteEndpoint();
+      }
+    }
+  }
+  async find(query = {}, responseType) {
+    switch (responseType) {
+      case "tuple": {
+        return await this.getEndpoint(objToQuery(query), "tuple");
+      }
+      default: {
+        return await this.getEndpoint(objToQuery(query));
+      }
+    }
+  }
+  async get(responseType) {
+    switch (responseType) {
+      case "tuple": {
+        return await this.getEndpoint(void 0, "tuple");
+      }
+      default: {
+        return await this.getEndpoint();
+      }
+    }
+  }
+  async post(data, responseType) {
+    switch (responseType) {
+      case "tuple": {
+        return await this.postEndpoint(void 0, data, "tuple");
+      }
+      default: {
+        return await this.postEndpoint(void 0, data);
+      }
+    }
+  }
+  async put(data, responseType) {
+    switch (responseType) {
+      case "tuple": {
+        return await this.putEndpoint(void 0, data, "tuple");
+      }
+      default: {
+        return await this.putEndpoint(void 0, data);
+      }
+    }
+  }
+};
+
+// src/Api/Api.ts
+var ArchivistApi = class extends ApiSimple {
+  huri(huri) {
+    const huriObj = typeof huri === "string" ? new Huri(huri) : huri;
+    return new ApiSimple({
+      ...this.config,
+      root: `${this.root}${huriObj.href}/`
+    });
+  }
+};
+export {
+  ApiBase,
+  ApiSimple,
+  ArchivistApi
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/api/neutral/models/ArchivePath.d.ts

@@ -0,0 +1,4 @@
+export interface ArchivePath {
+    archive: string;
+}
+//# sourceMappingURL=ArchivePath.d.ts.map

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

@@ -0,0 +1,2 @@
+export * from './ArchivePath.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/api/neutral/objToQuery.d.ts

@@ -0,0 +1,2 @@
+export declare const objToQuery: (obj: Record<string, string | number | undefined>) => string;
+//# sourceMappingURL=objToQuery.d.ts.map