@degenerate/generic 0.2.6 → 0.3.2

package/dist/models/share-data/share-data-crypto-models.d.ts

@@ -0,0 +1,307 @@
+import { z } from 'zod';
+/**
+ * This contains the interface for the share data initial crypto data schema
+ */
+export declare const IShareDataInitialCryptoDataSchema: z.ZodObject<{
+    publicKey: z.ZodString;
+    shareDataHash: z.ZodString;
+    shareDataSignature: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareDataInitialCryptoData = z.infer<typeof IShareDataInitialCryptoDataSchema>;
+/**
+ * This contains the interface for the share data crypto proof schema.
+ *
+ * `purpose` identifies what this proof attests to (e.g. `'deposit'`,
+ * `'rule-balance'`, `'seed-function'`). It is folded into the canonical
+ * signed string so two proofs taken over the same share-data state at the
+ * same moment but tagged with different purposes produce different
+ * signatures. Verifiers consume `purpose` directly from the proof — the
+ * proof is self-describing, so the structural-add boundary
+ * (`addFunction` / `addRule`) does not need a separate purpose argument.
+ */
+export declare const IShareDataCryptoProofSchema: z.ZodObject<{
+    publicKey: z.ZodString;
+    shareDataHash: z.ZodString;
+    shareDataPreviousHash: z.ZodString;
+    shareDataSignature: z.ZodString;
+    timestamp: z.ZodNumber;
+    purpose: z.ZodString;
+}, z.core.$strip>;
+export type IShareDataCryptoProof = z.infer<typeof IShareDataCryptoProofSchema>;
+/**
+ * A bundle of structural proofs keyed by their `purpose`, used as the
+ * wire-format input to ShareBlock factories when the client (rather than
+ * the server) signs each registration. Matches how `_structuralProofs`
+ * end up shaped on a constructed ShareData — one proof per
+ * `addFunction` / `addRule` call.
+ */
+export declare const ShareDataProofsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    publicKey: z.ZodString;
+    shareDataHash: z.ZodString;
+    shareDataPreviousHash: z.ZodString;
+    shareDataSignature: z.ZodString;
+    timestamp: z.ZodNumber;
+    purpose: z.ZodString;
+}, z.core.$strip>>;
+export type ShareDataProofs = z.infer<typeof ShareDataProofsSchema>;
+/**
+ * This contains the interface for the share data property config
+ * for creating strings from the object to ensure that signatures and
+ * hashes are consistent
+ */
+export declare const IShareDataPropertyConfigSchema: z.ZodObject<{
+    key: z.ZodString;
+    process: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodString>>;
+}, z.core.$strip>;
+export type IShareDataPropertyConfig = z.infer<typeof IShareDataPropertyConfigSchema>;
+/**
+ * This contains the interface for the share data config array
+ * for creating strings from the object to ensure that signatures and
+ * hashes are consistent
+ */
+export declare const IShareDataConfigSchema: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    process: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodString>>;
+}, z.core.$strip>>;
+export type IShareDataConfig = z.infer<typeof IShareDataConfigSchema>;
+/**
+ * This contains the interface for additional data to include in the share data string.
+ *
+ * `purpose` is required and identifies what this signed snapshot is attesting to
+ * (e.g. `'deposit'`, `'rule-balance'`, `'seed-function'`). It is folded into the
+ * canonical string `calculateShareDataString` produces, so two proofs taken
+ * over the same share-data state at the same moment but tagged with different
+ * purposes produce different hashes and therefore different signatures. This
+ * structurally prevents replaying a proof signed for one purpose as a proof
+ * for another.
+ */
+export declare const IShareDataAdditionalValuesToIncludeSchema: z.ZodObject<{
+    purpose: z.ZodString;
+    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        currentDataConditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"TYPEOF">;
+            conditionValue: z.ZodEnum<{
+                NULL: "NULL";
+                STRING: "STRING";
+                NUMBER: "NUMBER";
+                INTEGER: "INTEGER";
+                BOOLEAN: "BOOLEAN";
+                OBJECT: "OBJECT";
+                ARRAY: "ARRAY";
+                UNDEFINED: "UNDEFINED";
+                FUNCTION: "FUNCTION";
+                BIGINT: "BIGINT";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"EQUAL">;
+            conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+                GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+                LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+            }>;
+            conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"CONTAINS">;
+            conditionValue: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                STARTS_WITH: "STARTS_WITH";
+                ENDS_WITH: "ENDS_WITH";
+            }>;
+            conditionValue: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"NULL">;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                TRUE: "TRUE";
+                FALSE: "FALSE";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"EMPTY">;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                PATTERN: "PATTERN";
+            }>;
+            conditionValue: z.ZodString;
+        }, z.core.$strip>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        proposedDataConditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"TYPEOF">;
+            conditionValue: z.ZodEnum<{
+                NULL: "NULL";
+                STRING: "STRING";
+                NUMBER: "NUMBER";
+                INTEGER: "INTEGER";
+                BOOLEAN: "BOOLEAN";
+                OBJECT: "OBJECT";
+                ARRAY: "ARRAY";
+                UNDEFINED: "UNDEFINED";
+                FUNCTION: "FUNCTION";
+                BIGINT: "BIGINT";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"EQUAL">;
+            conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+                GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+                LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+            }>;
+            conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"CONTAINS">;
+            conditionValue: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                STARTS_WITH: "STARTS_WITH";
+                ENDS_WITH: "ENDS_WITH";
+            }>;
+            conditionValue: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"NULL">;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                TRUE: "TRUE";
+                FALSE: "FALSE";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"EMPTY">;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                PATTERN: "PATTERN";
+            }>;
+            conditionValue: z.ZodString;
+        }, z.core.$strip>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        targettedProperty: z.ZodString;
+    }, z.core.$strip>>>;
+    functions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        groupingId: z.ZodString;
+        groupingName: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        hash: z.ZodString;
+        stringifiedFunction: z.ZodString;
+    }, z.core.$strip>>>;
+    transactionHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ruleOutcome: z.ZodBoolean;
+        ruleFailures: z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+        }, z.core.$strip>>;
+        transactionFunction: z.ZodObject<{
+            input: z.ZodAny;
+            func: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+            output: z.ZodAny;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        shareData: z.ZodArray<z.ZodObject<{
+            shareDataId: z.ZodString;
+            functionId: z.ZodString;
+            shareDataInputs: z.ZodArray<z.ZodString>;
+            inputs: z.ZodAny;
+        }, z.core.$strip>>;
+        processingType: z.ZodEnum<{
+            parallel: "parallel";
+            linear: "linear";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type IShareDataAdditionalValuesToInclude = z.infer<typeof IShareDataAdditionalValuesToIncludeSchema>;
+//# sourceMappingURL=share-data-crypto-models.d.ts.map

package/dist/models/share-data/share-data-crypto-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-data-crypto-models.d.ts","sourceRoot":"","sources":["../../../src/models/share-data/share-data-crypto-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;iBAK5C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F;;;;;;;;;;GAUG;AASH,eAAO,MAAM,2BAA2B;;;;;;;iBAOtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;;kBAAoD,CAAC;AAEvF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAMpE;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;kBAA0C,CAAC;AAE9E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAMtE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMpD,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC"}

package/dist/models/share-data/share-data-crypto-models.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IShareDataAdditionalValuesToIncludeSchema = exports.IShareDataConfigSchema = exports.IShareDataPropertyConfigSchema = exports.ShareDataProofsSchema = exports.IShareDataCryptoProofSchema = exports.IShareDataInitialCryptoDataSchema = void 0;
+const zod_1 = require("zod");
+const share_rule_models_1 = require("../rules/share-rule-models");
+const share_data_models_1 = require("./share-data-models");
+const share_event_models_1 = require("../events/share-event-models");
+// This contains models that are used in the share data specifically around crypto
+//#region Share Data Crypto Schemas
+/**
+ * This contains the interface for the share data initial crypto data schema
+ */
+exports.IShareDataInitialCryptoDataSchema = zod_1.z.object({
+    publicKey: zod_1.z.string(), // the public key of the share data
+    shareDataHash: zod_1.z.string(), // the share data hash
+    shareDataSignature: zod_1.z.string(), // the share data signature
+    timestamp: zod_1.z.number(), // the timestamp of the initial crypto data (in milliseconds)
+});
+/**
+ * This contains the interface for the share data crypto proof schema.
+ *
+ * `purpose` identifies what this proof attests to (e.g. `'deposit'`,
+ * `'rule-balance'`, `'seed-function'`). It is folded into the canonical
+ * signed string so two proofs taken over the same share-data state at the
+ * same moment but tagged with different purposes produce different
+ * signatures. Verifiers consume `purpose` directly from the proof — the
+ * proof is self-describing, so the structural-add boundary
+ * (`addFunction` / `addRule`) does not need a separate purpose argument.
+ */
+// Field declaration order here is load-bearing, NOT cosmetic. Zod
+// reconstructs a parsed object in *schema-declaration* order, and the
+// canonical share-data hash folds structural proofs in via order-sensitive
+// `JSON.stringify` (see `getArrayString` / `calculateShareDataString`). So a
+// proof that round-trips through `.parse()` (wire load, HTTP create) must come
+// back with the SAME key order a freshly-minted proof has, or its hash
+// diverges and structural-proof verification fails. This order must therefore
+// mirror the object literal in `createShareDataProposalProof` exactly.
+exports.IShareDataCryptoProofSchema = zod_1.z.object({
+    publicKey: zod_1.z.string(), // the public key of the share data
+    shareDataHash: zod_1.z.string(), // the share data hash
+    shareDataPreviousHash: zod_1.z.string(), // the previous share data hash
+    shareDataSignature: zod_1.z.string(), // the share data signature
+    timestamp: zod_1.z.number(), // the timestamp of the initial crypto data (in milliseconds)
+    purpose: zod_1.z.string().min(1), // what this proof attests to (e.g. 'deposit', 'rule-balance')
+});
+/**
+ * A bundle of structural proofs keyed by their `purpose`, used as the
+ * wire-format input to ShareBlock factories when the client (rather than
+ * the server) signs each registration. Matches how `_structuralProofs`
+ * end up shaped on a constructed ShareData — one proof per
+ * `addFunction` / `addRule` call.
+ */
+exports.ShareDataProofsSchema = zod_1.z.record(zod_1.z.string(), exports.IShareDataCryptoProofSchema);
+//#endregion Share Data Crypto Schemas
+//#region Stringify Configurations
+/**
+ * This contains the interface for the share data property config
+ * for creating strings from the object to ensure that signatures and
+ * hashes are consistent
+ */
+exports.IShareDataPropertyConfigSchema = zod_1.z.object({
+    key: zod_1.z.string(),
+    process: zod_1.z.function({ input: zod_1.z.tuple([zod_1.z.any()]), output: zod_1.z.string() }).optional(), // Simplified process type
+});
+/**
+ * This contains the interface for the share data config array
+ * for creating strings from the object to ensure that signatures and
+ * hashes are consistent
+ */
+exports.IShareDataConfigSchema = zod_1.z.array(exports.IShareDataPropertyConfigSchema);
+//#endregion Stringify Configurations
+//#region Additional Data to include
+/**
+ * This contains the interface for additional data to include in the share data string.
+ *
+ * `purpose` is required and identifies what this signed snapshot is attesting to
+ * (e.g. `'deposit'`, `'rule-balance'`, `'seed-function'`). It is folded into the
+ * canonical string `calculateShareDataString` produces, so two proofs taken
+ * over the same share-data state at the same moment but tagged with different
+ * purposes produce different hashes and therefore different signatures. This
+ * structurally prevents replaying a proof signed for one purpose as a proof
+ * for another.
+ */
+exports.IShareDataAdditionalValuesToIncludeSchema = zod_1.z.object({
+    purpose: zod_1.z.string().min(1),
+    rules: zod_1.z.array(share_rule_models_1.IShareRuleAppliedSchema).optional(),
+    functions: zod_1.z.array(share_data_models_1.IShareFunctionRecordSchema).optional(),
+    transactionHistory: zod_1.z.array(share_data_models_1.IShareDataTransactionBaseSchema).optional(),
+    events: zod_1.z.array(share_event_models_1.IShareDataEventSchema).optional(),
+});
+//#endregion Additional Data to include

package/dist/models/share-data/share-data-models.d.ts

@@ -0,0 +1,114 @@
+import z from 'zod';
+import type { IShareDataCryptoProof } from './share-data-crypto-models';
+/**
+ * This contains the data for the share data object
+ */
+export declare enum ShareDataTypes {
+    AUTHORIZATION = "AUTHORIZATION",
+    RULE = "RULE",
+    FUNCTION = "FUNCTION",
+    TRANSACTION_HISTORY = "TRANSACTION_HISTORY",
+    DATA = "DATA"
+}
+export declare const ShareDataTypesSchema: z.ZodEnum<{
+    FUNCTION: "FUNCTION";
+    AUTHORIZATION: "AUTHORIZATION";
+    RULE: "RULE";
+    TRANSACTION_HISTORY: "TRANSACTION_HISTORY";
+    DATA: "DATA";
+}>;
+/**
+ * This contains the interface for a data in a share data object
+ */
+export declare const IShareDataSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+export type IShareData = z.infer<typeof IShareDataSchema>;
+/**
+ * This contains the interface for a share function record in the share data object
+ */
+export declare const IShareFunctionRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    groupingId: z.ZodString;
+    groupingName: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    hash: z.ZodString;
+    stringifiedFunction: z.ZodString;
+}, z.core.$strip>;
+export type IShareFunctionRecord = z.infer<typeof IShareFunctionRecordSchema>;
+/**
+ * This contains the interface for a share function in the share data object
+ */
+export declare const IShareFunctionSchema: z.ZodObject<{
+    input: z.ZodAny;
+    func: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    output: z.ZodAny;
+}, z.core.$strip>;
+export interface IShareFunction<TInput, TFunction extends (...args: any[]) => any, TOutput> {
+    /**
+     * Stable identifier the host application can use to refer to this
+     * function from outside the runtime — e.g., when a client submits a
+     * `propose` over the realtime transport and needs to name which
+     * registered function should evaluate the proposal.
+     *
+     * Optional today for backwards compatibility with existing
+     * constructions that don't set it. Functions without an id are
+     * invisible to id-based lookup (see `createIdBasedFunctionResolver`
+     * in `@degenerate/realtime`); the host can still resolve them via a
+     * custom `FunctionResolver`.
+     */
+    id?: string;
+    input: TInput;
+    func: TFunction;
+    output: TOutput;
+}
+/**
+ * This contains the interface for the rule failures in the share data object
+ */
+export declare const IShareDataRuleFailuresSchema: z.ZodObject<{
+    ruleId: z.ZodString;
+}, z.core.$strip>;
+export type IShareDataRuleFailures = z.infer<typeof IShareDataRuleFailuresSchema>;
+/**
+ * This contains the interface for the share transaction history in the share data object
+ */
+export declare const IShareDataTransactionBaseSchema: z.ZodObject<{
+    ruleOutcome: z.ZodBoolean;
+    ruleFailures: z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+    }, z.core.$strip>>;
+    transactionFunction: z.ZodObject<{
+        input: z.ZodAny;
+        func: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        output: z.ZodAny;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IShareDataTransactionBase = z.infer<typeof IShareDataTransactionBaseSchema>;
+/**
+ * This contains the interface for the share transaction history in the share data object
+ * This is done for storage
+ */
+export declare const IShareDataTransactionHistorySchema: z.ZodObject<{
+    ruleOutcome: z.ZodBoolean;
+    ruleFailures: z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+    }, z.core.$strip>>;
+    transactionFunction: z.ZodObject<{
+        input: z.ZodAny;
+        func: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        output: z.ZodAny;
+    }, z.core.$strip>;
+    transactionId: z.ZodString;
+    transactionTime: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * `proof` is the transaction proposal proof that authorized this state change
+ * (present for transactions applied through the signed `addTransaction` path;
+ * absent for legacy/internal applies). It makes the audit log itself carry the
+ * signature, not just the function + rule outcome. Typed here rather than in
+ * the Zod schema to avoid a module load-time cycle — see the `import type` note
+ * at the top of this file.
+ */
+export type IShareDataTransactionHistory = z.infer<typeof IShareDataTransactionHistorySchema> & {
+    proof?: IShareDataCryptoProof;
+};
+//# sourceMappingURL=share-data-models.d.ts.map

package/dist/models/share-data/share-data-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-data-models.d.ts","sourceRoot":"","sources":["../../../src/models/share-data/share-data-models.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAOpB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAGxE;;GAEG;AACH,oBAAY,cAAc;IACtB,aAAa,kBAAkB;IAC/B,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,mBAAmB,wBAAwB;IAC3C,IAAI,SAAS;CAChB;AAED,eAAO,MAAM,oBAAoB;;;;;;EAM/B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,oCAAgC,CAAC;AAC9D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;iBAQrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;iBAI/B,CAAC;AAGH,MAAM,WAAW,cAAc,CAAC,MAAM,EAAE,SAAS,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,OAAO;IACtF;;;;;;;;;;;OAWG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CACnB;AAGD;;GAEG;AACH,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;iBAI1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;;GAGG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;iBAG7C,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,GAAG;IAC5F,KAAK,CAAC,EAAE,qBAAqB,CAAC;CACjC,CAAC"}

package/dist/models/share-data/{share-data.js → share-data-models.js}

@@ -29,7 +29,7 @@ exports.ShareDataTypesSchema = zod_1.default.enum([
 /**
  * This contains the interface for a data in a share data object
  */
-exports.IShareDataSchema = zod_1.default.record(zod_1.default.any());
+exports.IShareDataSchema = zod_1.default.record(zod_1.default.string(), zod_1.default.any());
 /**
  * This contains the interface for a share function record in the share data object
  */