@xyo-network/sdk 2.102.4 → 7.0.3

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

@@ -0,0 +1,11 @@
+import type { TypeCheck } from '@xylabs/sdk';
+import type { ArchivistInstance } from './Instance.ts';
+import type { ArchivistModuleInstance } from './ModuleInstance.ts';
+export declare const isArchivistInstance: TypeCheck<ArchivistInstance>;
+export declare const isArchivistModule: TypeCheck<ArchivistModuleInstance>;
+export declare const asArchivistModule: import("@xylabs/sdk").AsTypeFunction<ArchivistModuleInstance<import("../../module-model/neutral/index.ts").QueryableModuleParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").ArchivistConfig>>, import("./EventData.ts").ArchivistModuleEventData>>;
+export declare const asArchivistInstance: import("@xylabs/sdk").AsTypeFunction<ArchivistInstance<import("./Instance.ts").ArchivistParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").ArchivistConfig>>, import("./EventData.ts").ArchivistModuleEventData, import("../../sdk-protocol/neutral/index.ts").Payload>>;
+/** @deprecated use narrowing instead [ if(is) ] */
+export declare const withArchivistModule: <R>(mod: any, closure: (mod: ArchivistModuleInstance<import("../../module-model/neutral/index.ts").QueryableModuleParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").ArchivistConfig>>, import("./EventData.ts").ArchivistModuleEventData>) => R) => R | undefined;
+/** @deprecated use narrowing instead [ if(is) ] */
+export declare const withArchivistInstance: <R>(mod: any, closure: (mod: ArchivistInstance<import("./Instance.ts").ArchivistParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").ArchivistConfig>>, import("./EventData.ts").ArchivistModuleEventData, import("../../sdk-protocol/neutral/index.ts").Payload>) => R) => R | undefined;

package/dist/_pkg/archivist-view/neutral/ViewArchivist.d.ts

@@ -0,0 +1,44 @@
+import type { Hash, Promisable } from '@xylabs/sdk';
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import { AbstractArchivist } from '../../archivist-abstract/neutral/index.ts';
+import type { ArchivistConfig, ArchivistInstance, ArchivistModuleEventData, ArchivistNextOptions, ArchivistParams } from '../../archivist-model/neutral/index.ts';
+import { ArchivistConfigZod } from '../../archivist-model/neutral/index.ts';
+import type { AnyConfigSchema, ModuleIdentifier, ModuleInstance } from '../../module-model/neutral/index.ts';
+import type { Payload, Schema, WithStorageMeta } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const ViewArchivistConfigSchema: 'network.xyo.archivist.view.config' & {
+    readonly __schema: true;
+};
+export type ViewArchivistConfigSchema = typeof ViewArchivistConfigSchema;
+export declare const ViewArchivistConfigZod: z.ZodMiniObject<Omit<(typeof ArchivistConfigZod)['shape'], 'schema'> & {
+    originArchivist: z.ZodMiniOptional<z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>>;
+    schema: z.ZodMiniLiteral<ViewArchivistConfigSchema>;
+}, z.core.$strip>;
+export type ViewArchivistConfigBase = z.infer<typeof ViewArchivistConfigZod>;
+export declare const isViewArchivistConfig: ReturnType<typeof zodIsFactory<ViewArchivistConfigBase>>;
+export declare const asViewArchivistConfig: ReturnType<typeof zodAsFactory<ViewArchivistConfigBase>>;
+export declare const toViewArchivistConfig: ReturnType<typeof zodToFactory<ViewArchivistConfigBase>>;
+export type ViewArchivistConfig = ArchivistConfig<{
+    originArchivist?: ModuleIdentifier;
+}, ViewArchivistConfigSchema>;
+export type ViewArchivistParams<TConfig extends AnyConfigSchema<ViewArchivistConfig> = AnyConfigSchema<ViewArchivistConfig>> = ArchivistParams<TConfig>;
+export declare class ViewArchivist<TParams extends ViewArchivistParams<AnyConfigSchema<ViewArchivistConfig>> = ViewArchivistParams, TEventData extends ArchivistModuleEventData = ArchivistModuleEventData> extends AbstractArchivist<TParams, TEventData> implements ArchivistInstance, ModuleInstance {
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    static readonly labels: {
+        'ModuleLimitationLabelName': string;
+        'network.xyo.storage.class': string;
+    };
+    private _originArchivistInstance?;
+    get originArchivist(): string | (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    });
+    get queries(): Schema[];
+    originArchivistInstance(): Promise<ArchivistInstance<ArchivistParams<AnyConfigSchema<ArchivistConfig>>, ArchivistModuleEventData, Payload>>;
+    /** @deprecated use next instead */
+    protected allHandler(): Promisable<WithStorageMeta<Payload>[]>;
+    protected getHandler(hashes: Hash[]): Promise<WithStorageMeta<Payload>[]>;
+    protected nextHandler(options?: ArchivistNextOptions): Promise<WithStorageMeta<Payload>[]>;
+}

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

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

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

@@ -0,0 +1,82 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getProtoOf = Object.getPrototypeOf;
+var __reflectGet = Reflect.get;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
+
+// src/ViewArchivist.ts
+import {
+  assertEx,
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { AbstractArchivist, StorageClassLabel } from "../../archivist-abstract/neutral/index.mjs";
+import {
+  ArchivistAllQuerySchema,
+  ArchivistConfigZod,
+  ArchivistGetQuerySchema,
+  ArchivistNextQuerySchema,
+  isArchivistInstance
+} from "../../archivist-model/neutral/index.mjs";
+import {
+  labeledCreatableModule,
+  ModuleLimitationViewLabel
+} from "../../module-model/neutral/index.mjs";
+import { asSchema } from "../../sdk-protocol/neutral/index.mjs";
+import * as z from "zod/mini";
+var ViewArchivistConfigSchema = asSchema("network.xyo.archivist.view.config", true);
+var ViewArchivistConfigZod = z.extend(ArchivistConfigZod, {
+  originArchivist: z.optional(z.custom()),
+  schema: z.literal(ViewArchivistConfigSchema)
+});
+var isViewArchivistConfig = zodIsFactory(ViewArchivistConfigZod);
+var asViewArchivistConfig = zodAsFactory(ViewArchivistConfigZod, "asViewArchivistConfig");
+var toViewArchivistConfig = zodToFactory(ViewArchivistConfigZod, "toViewArchivistConfig");
+var ViewArchivist = class extends AbstractArchivist {
+  _originArchivistInstance;
+  get originArchivist() {
+    return assertEx(this.config.originArchivist, () => "originArchivist not configured");
+  }
+  get queries() {
+    return [ArchivistGetQuerySchema, ArchivistAllQuerySchema, ArchivistNextQuerySchema, ...super.queries];
+  }
+  async originArchivistInstance() {
+    this._originArchivistInstance = this._originArchivistInstance ?? assertEx(await this.resolve(this.originArchivist, { identity: isArchivistInstance, required: true }));
+    return this._originArchivistInstance;
+  }
+  /** @deprecated use next instead */
+  allHandler() {
+    throw new Error("allHandler is deprecated, use nextHandler instead");
+  }
+  async getHandler(hashes) {
+    return await (await this.originArchivistInstance()).get(hashes);
+  }
+  async nextHandler(options) {
+    return await (await this.originArchivistInstance()).next?.(options) ?? [];
+  }
+};
+__publicField(ViewArchivist, "configSchemas", [...__superGet(ViewArchivist, ViewArchivist, "configSchemas"), ViewArchivistConfigSchema]);
+__publicField(ViewArchivist, "defaultConfigSchema", ViewArchivistConfigSchema);
+__publicField(ViewArchivist, "labels", { ...ModuleLimitationViewLabel, [StorageClassLabel]: "proxy" });
+ViewArchivist = __decorateClass([
+  labeledCreatableModule()
+], ViewArchivist);
+export {
+  ViewArchivist,
+  ViewArchivistConfigSchema,
+  ViewArchivistConfigZod,
+  asViewArchivistConfig,
+  isViewArchivistConfig,
+  toViewArchivistConfig
+};

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

@@ -0,0 +1,26 @@
+import type { Hash, TypeCheck } from '@xylabs/sdk';
+import type { ArchivistConfig, ArchivistInstance, ArchivistModuleEventData, ArchivistModuleInstance, ArchivistNextOptions, ArchivistParams, ArchivistSnapshotPayload, AttachableArchivistInstance } from '../../archivist-model/neutral/index.ts';
+import type { AnyConfigSchema, ModuleQueryResult, QueryableModuleParams } from '../../module-model/neutral/index.ts';
+import { ModuleWrapper } from '../../module-wrapper/neutral/index.ts';
+import type { AccountInstance, Payload, WithStorageMeta } from '../../sdk-protocol/neutral/index.ts';
+export declare class ArchivistWrapper<TWrappedModule extends ArchivistModuleInstance = ArchivistModuleInstance> extends ModuleWrapper<TWrappedModule> implements AttachableArchivistInstance<ArchivistModuleInstance['params']> {
+    static readonly instanceIdentityCheck: TypeCheck<ArchivistInstance<ArchivistParams<AnyConfigSchema<ArchivistConfig>>, ArchivistModuleEventData, Payload>>;
+    static readonly moduleIdentityCheck: TypeCheck<ArchivistModuleInstance<QueryableModuleParams<AnyConfigSchema<ArchivistConfig>>, ArchivistModuleEventData>>;
+    static readonly requiredQueries: string[];
+    all(): Promise<WithStorageMeta<Payload>[]>;
+    allQuery(account?: AccountInstance): Promise<ModuleQueryResult>;
+    clear(): Promise<void>;
+    clearQuery(account?: AccountInstance): Promise<ModuleQueryResult>;
+    commit(): Promise<Payload[]>;
+    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(options?: {}): Promise<ArchivistSnapshotPayload<WithStorageMeta<Payload>, Hash>[]>;
+    snapshotQuery(options?: {}, account?: AccountInstance): Promise<ModuleQueryResult>;
+}

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

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

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

@@ -0,0 +1,87 @@
+// src/ArchivistWrapper.ts
+import {
+  ArchivistAllQuerySchema,
+  ArchivistClearQuerySchema,
+  ArchivistCommitQuerySchema,
+  ArchivistDeleteQuerySchema,
+  ArchivistGetQuerySchema,
+  ArchivistInsertQuerySchema,
+  ArchivistNextQuerySchema,
+  ArchivistSnapshotQuerySchema,
+  isArchivistInstance,
+  isArchivistModule
+} from "../../archivist-model/neutral/index.mjs";
+import { constructableModuleWrapper, ModuleWrapper } from "../../module-wrapper/neutral/index.mjs";
+constructableModuleWrapper();
+var ArchivistWrapper = class extends ModuleWrapper {
+  static instanceIdentityCheck = isArchivistInstance;
+  static moduleIdentityCheck = isArchivistModule;
+  static requiredQueries = [ArchivistGetQuerySchema, ...super.requiredQueries];
+  async all() {
+    const queryPayload = { schema: ArchivistAllQuerySchema };
+    return await this.sendQuery(queryPayload);
+  }
+  async allQuery(account) {
+    const queryPayload = { schema: ArchivistAllQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async clear() {
+    const queryPayload = { schema: ArchivistClearQuerySchema };
+    await this.sendQuery(queryPayload);
+  }
+  async clearQuery(account) {
+    const queryPayload = { schema: ArchivistClearQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async commit() {
+    const queryPayload = { schema: ArchivistCommitQuerySchema };
+    return await this.sendQuery(queryPayload);
+  }
+  async commitQuery(account) {
+    const queryPayload = { schema: ArchivistCommitQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async delete(hashes) {
+    const queryPayload = { hashes, schema: ArchivistDeleteQuerySchema };
+    return await this.sendQuery(queryPayload);
+  }
+  async deleteQuery(hashes, account) {
+    const queryPayload = { hashes, schema: ArchivistDeleteQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async get(hashes) {
+    const queryPayload = { hashes, schema: ArchivistGetQuerySchema };
+    return await this.sendQuery(queryPayload);
+  }
+  async getQuery(hashes, account) {
+    const queryPayload = { hashes, schema: ArchivistGetQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async insert(payloads) {
+    const queryPayload = { schema: ArchivistInsertQuerySchema };
+    return await this.sendQuery(queryPayload, payloads);
+  }
+  async insertQuery(payloads, account) {
+    const queryPayload = { schema: ArchivistInsertQuerySchema };
+    return await this.sendQueryRaw(queryPayload, payloads, account);
+  }
+  async next(options) {
+    const queryPayload = { ...options, schema: ArchivistNextQuerySchema };
+    return await this.sendQuery(queryPayload);
+  }
+  async nextQuery(options, account) {
+    const queryPayload = { schema: ArchivistNextQuerySchema, ...options };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async snapshot(options) {
+    const queryPayload = { ...options, schema: ArchivistSnapshotQuerySchema };
+    return await this.sendQuery(queryPayload);
+  }
+  async snapshotQuery(options, account) {
+    const queryPayload = { schema: ArchivistSnapshotQuerySchema, ...options };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+};
+export {
+  ArchivistWrapper
+};

package/dist/_pkg/boundwitness/neutral/builder.d.ts

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

package/dist/_pkg/boundwitness/neutral/builder.mjs

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

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

@@ -0,0 +1,4 @@
+export * from '../../boundwitness-builder/neutral/index.ts';
+export * from '../../boundwitness-model/neutral/index.ts';
+export * from '../../boundwitness-validator/neutral/index.ts';
+export * from '../../boundwitness-wrapper/neutral/index.ts';

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

@@ -0,0 +1,5 @@
+// src/index.ts
+export * from "../../boundwitness-builder/neutral/index.mjs";
+export * from "../../boundwitness-model/neutral/index.mjs";
+export * from "../../boundwitness-validator/neutral/index.mjs";
+export * from "../../boundwitness-wrapper/neutral/index.mjs";

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

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

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

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

package/dist/_pkg/boundwitness/neutral/validator.d.ts

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

package/dist/_pkg/boundwitness/neutral/validator.mjs

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

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

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

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

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

package/dist/_pkg/boundwitness-builder/neutral/BoundWitnessBuilder.d.ts

@@ -0,0 +1,47 @@
+import type { Hash, Hex } from '@xylabs/sdk';
+import type { AccountInstance } from '../../account-model/neutral/index.ts';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { BoundWitness, PossiblySigned, Signed, Unsigned } from '../../boundwitness-model/neutral/index.ts';
+import type { PayloadBuilderOptions } from '../../payload-builder/neutral/index.ts';
+import { PayloadBuilder } from '../../payload-builder/neutral/index.ts';
+import type { ModuleError, Payload, Schema, WithoutClientMeta, WithoutMeta, WithoutSchema, WithoutStorageMeta } from '../../payload-model/neutral/index.ts';
+import { GeneratedBoundWitnessFields } from './GeneratedBoundWitnessFields.ts';
+export declare class BoundWitnessBuilder<TBoundWitness extends BoundWitness = BoundWitness, TPayload extends Payload = Payload> extends PayloadBuilder<TBoundWitness, Promise<[PossiblySigned<TBoundWitness>, TPayload[], ModuleError[]]>> {
+    private static readonly _buildMutex;
+    private _accounts;
+    private _errorHashes?;
+    private _errors;
+    private _payloadHashes?;
+    private _payloadSchemas?;
+    private _payloads;
+    constructor(options?: Omit<PayloadBuilderOptions, 'schema'>);
+    private static validateGeneratedFields;
+    protected static linkingFields<T extends BoundWitness>(accounts: AccountInstance[], payloads?: Payload[]): Promise<Pick<T, GeneratedBoundWitnessFields>>;
+    protected static signature<T extends BoundWitness>(payload: T, address: XyoAddress): import("@xylabs/sdk").BrandedHex | null;
+    protected static signatures(accounts: AccountInstance[], dataHash: Hash): Promise<string[]>;
+    static addressIndex<T extends BoundWitness>(payload: T, address: XyoAddress): number;
+    static previousHash<T extends BoundWitness>(boundWitness: T, address: XyoAddress): string | undefined;
+    protected get addresses(): XyoAddress[];
+    protected get payloadSchemas(): string[];
+    protected get previousHashBytes(): (ArrayBufferLike | null)[];
+    protected get previousHashes(): (Hash | null)[];
+    protected sign(): Promise<Hex[]>;
+    build(): Promise<[Signed<TBoundWitness>, TPayload[], ModuleError[]]>;
+    build(sign: false): Promise<[Unsigned<TBoundWitness>, TPayload[], ModuleError[]]>;
+    build(sign: true): Promise<[Signed<TBoundWitness>, TPayload[], ModuleError[]]>;
+    dataHash(): Promise<import("@xylabs/sdk").BrandedHash>;
+    dataHashableFields(): Promise<WithoutMeta<TBoundWitness>>;
+    error(payload?: ModuleError): this;
+    errors(errors?: (ModuleError | null)[]): this;
+    fields(fields: WithoutSchema<Omit<WithoutStorageMeta<WithoutClientMeta<TBoundWitness>>, 'addresses' | 'payload_hashes' | 'payload_schemas' | 'previous_hashes'>>): this;
+    hashes(hashes: Hash[], schema: Schema[]): this;
+    payload(payload?: TPayload): this;
+    payloads(payloads?: (TPayload | null)[]): this;
+    signer(account: AccountInstance): this;
+    signers(accounts: AccountInstance[]): this;
+    sourceQuery(sourceQuery: Hash): this;
+    /** @deprecated use signer instead */
+    witness(account: AccountInstance): this;
+    /** @deprecated use signers instead */
+    witnesses(accounts: AccountInstance[]): this;
+}

package/dist/_pkg/boundwitness-builder/neutral/GeneratedBoundWitnessFields.d.ts

@@ -0,0 +1,2 @@
+export declare const GeneratedBoundWitnessFields: readonly ["addresses", "payload_hashes", "payload_schemas", "previous_hashes"];
+export type GeneratedBoundWitnessFields = typeof GeneratedBoundWitnessFields[number];

package/dist/_pkg/boundwitness-builder/neutral/Query/QueryBoundWitnessBuilder.d.ts

@@ -0,0 +1,8 @@
+import type { QueryBoundWitness } from '../../../boundwitness-model/neutral/index.ts';
+import type { Query, WithoutMeta } from '../../../payload-model/neutral/index.ts';
+import { BoundWitnessBuilder } from '../BoundWitnessBuilder.ts';
+export declare class QueryBoundWitnessBuilder<TBoundWitness extends QueryBoundWitness = QueryBoundWitness, TQuery extends Query = Query> extends BoundWitnessBuilder<TBoundWitness> {
+    private _query;
+    dataHashableFields(): Promise<WithoutMeta<TBoundWitness>>;
+    query<T extends TQuery>(query: T): this;
+}

package/dist/_pkg/boundwitness-builder/neutral/Query/index.d.ts

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

package/dist/_pkg/boundwitness-builder/neutral/combinationsByBoundwitness.d.ts

@@ -0,0 +1,9 @@
+import type { BoundWitness } from '../../boundwitness-model/neutral/index.ts';
+import type { Payload } from '../../payload-model/neutral/index.ts';
+/**
+ * Returns tuples of bound witnesses and their payloads from the supplied payloads. Omits
+ * bound witnesses where the payloads were not included in the supplied payloads.
+ * @param payloads An array of bound witnesses and payloads
+ * @returns An array of tuples of bound witnesses and their payloads
+ */
+export declare const combinationsByBoundwitness: (payloads: Payload[]) => Promise<[BoundWitness, ...Payload[]][]>;

package/dist/_pkg/boundwitness-builder/neutral/index.d.ts

@@ -0,0 +1,4 @@
+export * from './BoundWitnessBuilder.ts';
+export * from './combinationsByBoundwitness.ts';
+export * from './intraBoundwitnessSchemaCombinations.ts';
+export * from './Query/index.ts';