@degenerate/generic 0.1.9 → 0.1.11

package/dist/models/events/share-event-models.js

@@ -1,9 +1,10 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareDataEventSchema = exports.IShareDataEventSchema = exports.ShareDataAndFunctionEventSchema = exports.ShareDataEventProcessingTypeSchema = exports.ShareDataEventProcessingType = exports.EventSourceTruthProofTypeSchema = exports.EventSourceTruthProofType = exports.EventSourceTruthTypeSchema = exports.EventSourceTruthType = exports.ShareEventTypeSchema = exports.ShareEventType = void 0;
+const zod_1 = require("zod");
 /**
  * This contains the interfaces for all event data types that can be run on the network.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShareDataEventProcessingType = exports.EventSourceTruthProofType = exports.EventSourceTruthType = exports.ShareEventType = void 0;
 //#region Share Event Data Enums
 /**
  * This is the types of events that can be run on the network.
@@ -14,6 +15,11 @@ var ShareEventType;
     ShareEventType["DataChange"] = "DataChange";
     ShareEventType["Scheduled"] = "Scheduled";
 })(ShareEventType || (exports.ShareEventType = ShareEventType = {}));
+exports.ShareEventTypeSchema = zod_1.z.enum([
+    'Application',
+    'DataChange',
+    'Scheduled',
+]);
 /**
  * All sources of event trusts
  */
@@ -23,6 +29,11 @@ var EventSourceTruthType;
     EventSourceTruthType["Oauth"] = "Oauth";
     EventSourceTruthType["ShareBlock"] = "ShareBlock";
 })(EventSourceTruthType || (exports.EventSourceTruthType = EventSourceTruthType = {}));
+exports.EventSourceTruthTypeSchema = zod_1.z.enum([
+    'Crypto',
+    'Oauth',
+    'ShareBlock',
+]);
 /**
  * All the types of proofs that can be sent from the sources of event execution truths.
  */
@@ -31,6 +42,10 @@ var EventSourceTruthProofType;
     EventSourceTruthProofType["Hash"] = "Hash";
     EventSourceTruthProofType["Signature"] = "Signature";
 })(EventSourceTruthProofType || (exports.EventSourceTruthProofType = EventSourceTruthProofType = {}));
+exports.EventSourceTruthProofTypeSchema = zod_1.z.enum([
+    'Hash',
+    'Signature',
+]);
 /**
  * This is the type of processing that can be done on the share data event.
  */
@@ -39,6 +54,42 @@ var ShareDataEventProcessingType;
     ShareDataEventProcessingType["Parallel"] = "parallel";
     ShareDataEventProcessingType["Linear"] = "linear";
 })(ShareDataEventProcessingType || (exports.ShareDataEventProcessingType = ShareDataEventProcessingType = {}));
+exports.ShareDataEventProcessingTypeSchema = zod_1.z.enum([
+    'parallel',
+    'linear',
+]);
+//#endregion Share Event Data Enums
+/**
+ * This is all data that is required to find the sharedata and function to execute.
+ */
+exports.ShareDataAndFunctionEventSchema = zod_1.z.object({
+    shareDataId: zod_1.z.string(),
+    functionId: zod_1.z.string(),
+    shareDataInputs: zod_1.z.array(zod_1.z.string()),
+    inputs: zod_1.z.any(),
+});
+/**
+ * This is the interface for the share data event.
+ */
+exports.IShareDataEventSchema = zod_1.z.object({
+    shareData: zod_1.z.array(exports.ShareDataAndFunctionEventSchema), // the data required to find an execute a function in the network. These run in order of the items in the array.
+    processingType: exports.ShareDataEventProcessingTypeSchema, // specifies whether to process the shareData in parallel or linear order.
+});
+/**
+ * This is the interface for the share data event.
+ */
+exports.ShareDataEventSchema = zod_1.z.object({
+    eventId: zod_1.z.string(),
+    locked: zod_1.z.boolean(),
+    eventType: exports.ShareEventTypeSchema,
+    eventSource: zod_1.z.string(),
+    eventSourceTruthType: exports.EventSourceTruthTypeSchema,
+    eventSourceTruthProofType: exports.EventSourceTruthProofTypeSchema,
+    eventSourceTruthProof: zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.instanceof(Buffer)]),
+    triggerCondition: zod_1.z.function().args(zod_1.z.any()).returns(zod_1.z.boolean()),
+    shareDataEventInformation: zod_1.z.array(exports.IShareDataEventSchema),
+    eventContext: zod_1.z.record(zod_1.z.any()),
+});
 // const applicationEvent: ShareDataEvent = {
 //     eventId: 'appEvent123',
 //     eventType: 'Application',

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

@@ -1,86 +1,305 @@
+import { z } from 'zod';
 /**
- * This contains the data for the sahre functions
+ * This contains the data for the share functions
  */
-/**
- * This is the incoming object for the share functions.
- */
-export interface ITargetObject {
-    [key: string]: unknown;
-}
 /**
  * This contains all the proof types that exist for the network.
  */
 export declare enum INetworkProofType {
     CRYPTOGRAPHIC_SIGNATURE = "CRYPTOGRAPHIC_SIGNATURE"
 }
+export declare const INetworkProofTypeSchema: z.ZodEnum<["CRYPTOGRAPHIC_SIGNATURE"]>;
 /**
- * This contains the network proof for the share data network functions.
+ * This is the incoming object for the share functions.
  */
-export type INetworkProof = ICryptographicSignatureProof;
+export declare const ITargetObjectSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type ITargetObject = Record<string, unknown>;
 /**
  * This contains the cryptographic signature proof for the share data network functions.
  */
-export interface ICryptographicSignatureProof {
+export declare const ICryptographicSignatureProofSchema: z.ZodObject<{
+    publicKey: z.ZodString;
+    signature: z.ZodString;
+}, "strip", z.ZodTypeAny, {
     publicKey: string;
     signature: string;
-}
+}, {
+    publicKey: string;
+    signature: string;
+}>;
+export type ICryptographicSignatureProof = z.infer<typeof ICryptographicSignatureProofSchema>;
+/**
+ * This contains the network proof for the share data network functions.
+ */
+export declare const INetworkProofSchema: z.ZodObject<{
+    publicKey: z.ZodString;
+    signature: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    publicKey: string;
+    signature: string;
+}, {
+    publicKey: string;
+    signature: string;
+}>;
+export type INetworkProof = z.infer<typeof INetworkProofSchema>;
 /**
  * This contains the data for a share data network function without the signature
  */
-export interface IShareDataFunctionBasic {
+export declare const IShareDataFunctionBasicSchema: z.ZodObject<{
+    createdAt: z.ZodNumber;
+    previousHash: z.ZodString;
+    stringifiedFunction: z.ZodString;
+    currentHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
     createdAt: number;
     previousHash: string;
     stringifiedFunction: string;
     currentHash: string;
-}
+}, {
+    createdAt: number;
+    previousHash: string;
+    stringifiedFunction: string;
+    currentHash: string;
+}>;
+export type IShareDataFunctionBasic = z.infer<typeof IShareDataFunctionBasicSchema>;
 /**
- * This contains the data for a share data network function.
+ * This contains a share data function
  */
-export interface IShareDataFunction extends IShareDataFunctionBasic {
-    proof: INetworkProof;
-    proofType: INetworkProofType;
-}
+export declare const IShareDataFunctionSchema: z.ZodObject<{
+    proof: z.ZodObject<{
+        publicKey: z.ZodString;
+        signature: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        publicKey: string;
+        signature: string;
+    }, {
+        publicKey: string;
+        signature: string;
+    }>;
+    proofType: z.ZodEnum<["CRYPTOGRAPHIC_SIGNATURE"]>;
+    createdAt: z.ZodNumber;
+    previousHash: z.ZodString;
+    stringifiedFunction: z.ZodString;
+    currentHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    createdAt: number;
+    previousHash: string;
+    stringifiedFunction: string;
+    currentHash: string;
+    proof: {
+        publicKey: string;
+        signature: string;
+    };
+    proofType: "CRYPTOGRAPHIC_SIGNATURE";
+}, {
+    createdAt: number;
+    previousHash: string;
+    stringifiedFunction: string;
+    currentHash: string;
+    proof: {
+        publicKey: string;
+        signature: string;
+    };
+    proofType: "CRYPTOGRAPHIC_SIGNATURE";
+}>;
+export type IShareDataFunction = z.infer<typeof IShareDataFunctionSchema>;
 /**
  * This contains a share data network function
  */
-export interface IShareDataNetworkFunction {
+export declare const IShareDataNetworkFunctionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    shareDataFunctions: z.ZodArray<z.ZodObject<{
+        proof: z.ZodObject<{
+            publicKey: z.ZodString;
+            signature: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            publicKey: string;
+            signature: string;
+        }, {
+            publicKey: string;
+            signature: string;
+        }>;
+        proofType: z.ZodEnum<["CRYPTOGRAPHIC_SIGNATURE"]>;
+        createdAt: z.ZodNumber;
+        previousHash: z.ZodString;
+        stringifiedFunction: z.ZodString;
+        currentHash: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        createdAt: number;
+        previousHash: string;
+        stringifiedFunction: string;
+        currentHash: string;
+        proof: {
+            publicKey: string;
+            signature: string;
+        };
+        proofType: "CRYPTOGRAPHIC_SIGNATURE";
+    }, {
+        createdAt: number;
+        previousHash: string;
+        stringifiedFunction: string;
+        currentHash: string;
+        proof: {
+            publicKey: string;
+            signature: string;
+        };
+        proofType: "CRYPTOGRAPHIC_SIGNATURE";
+    }>, "many">;
+    proof: z.ZodObject<{
+        publicKey: z.ZodString;
+        signature: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        publicKey: string;
+        signature: string;
+    }, {
+        publicKey: string;
+        signature: string;
+    }>;
+    proofType: z.ZodEnum<["CRYPTOGRAPHIC_SIGNATURE"]>;
+}, "strip", z.ZodTypeAny, {
+    proof: {
+        publicKey: string;
+        signature: string;
+    };
+    proofType: "CRYPTOGRAPHIC_SIGNATURE";
     id: string;
     name: string;
     description: string;
-    shareDataFunctions: IShareDataFunction[];
-    proof: INetworkProof;
-    proofType: INetworkProofType;
-}
-export interface IShareDataNetworkFunctionDescriptor {
+    shareDataFunctions: {
+        createdAt: number;
+        previousHash: string;
+        stringifiedFunction: string;
+        currentHash: string;
+        proof: {
+            publicKey: string;
+            signature: string;
+        };
+        proofType: "CRYPTOGRAPHIC_SIGNATURE";
+    }[];
+}, {
+    proof: {
+        publicKey: string;
+        signature: string;
+    };
+    proofType: "CRYPTOGRAPHIC_SIGNATURE";
+    id: string;
+    name: string;
+    description: string;
+    shareDataFunctions: {
+        createdAt: number;
+        previousHash: string;
+        stringifiedFunction: string;
+        currentHash: string;
+        proof: {
+            publicKey: string;
+            signature: string;
+        };
+        proofType: "CRYPTOGRAPHIC_SIGNATURE";
+    }[];
+}>;
+export type IShareDataNetworkFunction = z.infer<typeof IShareDataNetworkFunctionSchema>;
+/**
+ * This contains the data for a share data network function descriptor.
+ */
+export declare const IShareDataNetworkFunctionDescriptorSchema: z.ZodObject<{
+    functionNumber: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
     functionNumber: number;
+}, {
     name: string;
     description: string;
-}
+    functionNumber: number;
+}>;
+export type IShareDataNetworkFunctionDescriptor = z.infer<typeof IShareDataNetworkFunctionDescriptorSchema>;
 /**
  * This contains the data for a share data network rule that is the basic shape.
  */
-export interface IShareDataRuleBasic {
+export declare const IShareDataRuleBasicSchema: z.ZodObject<{
+    createdAt: z.ZodNumber;
+    previousHash: z.ZodString;
+    stringifiedRule: z.ZodString;
+    currentHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
     createdAt: number;
     previousHash: string;
+    currentHash: string;
     stringifiedRule: string;
+}, {
+    createdAt: number;
+    previousHash: string;
     currentHash: string;
-}
+    stringifiedRule: string;
+}>;
+export type IShareDataRuleBasic = z.infer<typeof IShareDataRuleBasicSchema>;
 /**
  * This contains the interface for a share function record in the share data object
  */
-export interface IShareDataNetworkRule {
+export declare const IShareDataNetworkRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    shareDataRules: z.ZodArray<z.ZodObject<{
+        createdAt: z.ZodNumber;
+        previousHash: z.ZodString;
+        stringifiedRule: z.ZodString;
+        currentHash: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        createdAt: number;
+        previousHash: string;
+        currentHash: string;
+        stringifiedRule: string;
+    }, {
+        createdAt: number;
+        previousHash: string;
+        currentHash: string;
+        stringifiedRule: string;
+    }>, "many">;
+    applicationId: z.ZodString;
+    applicationIdProof: z.ZodString;
+}, "strip", z.ZodTypeAny, {
     id: string;
-    shareDataRules: IShareDataRule[];
+    shareDataRules: {
+        createdAt: number;
+        previousHash: string;
+        currentHash: string;
+        stringifiedRule: string;
+    }[];
     applicationId: string;
     applicationIdProof: string;
-}
+}, {
+    id: string;
+    shareDataRules: {
+        createdAt: number;
+        previousHash: string;
+        currentHash: string;
+        stringifiedRule: string;
+    }[];
+    applicationId: string;
+    applicationIdProof: string;
+}>;
+export type IShareDataNetworkRule = z.infer<typeof IShareDataNetworkRuleSchema>;
 /**
  * This contains the data for a share data network rule.
  */
-export interface IShareDataRule {
+export declare const IShareDataRuleSchema: z.ZodObject<{
+    createdAt: z.ZodNumber;
+    previousHash: z.ZodString;
+    stringifiedRule: z.ZodString;
+    currentHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
     createdAt: number;
     previousHash: string;
+    currentHash: string;
     stringifiedRule: string;
+}, {
+    createdAt: number;
+    previousHash: string;
     currentHash: string;
-}
+    stringifiedRule: string;
+}>;
+export type IShareDataRule = z.infer<typeof IShareDataRuleSchema>;
 //# sourceMappingURL=share-data-function-models.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"share-data-function-models.d.ts","sourceRoot":"","sources":["../../../src/models/functions/share-data-function-models.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,oBAAY,iBAAiB;IACzB,uBAAuB,4BAA4B;CACtD;AACD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,4BAA4B,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,4BAA4B;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACrB;AACD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,uBAAuB;IAC/D,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,iBAAiB,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,kBAAkB,EAAE,CAAC;IACzC,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,iBAAiB,CAAC;CAChC;AAED,MAAM,WAAW,mCAAmC;IAChD,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACvB;AAGD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,cAAc,EAAE,CAAC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACvB"}
+{"version":3,"file":"share-data-function-models.d.ts","sourceRoot":"","sources":["../../../src/models/functions/share-data-function-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB;;GAEG;AAKH;;GAEG;AACH,oBAAY,iBAAiB;IACzB,uBAAuB,4BAA4B;CACtD;AAED,eAAO,MAAM,uBAAuB,wCAElC,CAAC;AAIH;;GAEG;AACH,eAAO,MAAM,mBAAmB,wCAAwB,CAAC;AACzD,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;EAG7C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;EAAqC,CAAC;AACtE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;EAKxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAiBpF;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;GAEG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;EAIpD,CAAC;AAEH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAE5G;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EAKpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAK/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/models/functions/share-data-function-models.js

@@ -1,9 +1,11 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IShareDataRuleSchema = exports.IShareDataNetworkRuleSchema = exports.IShareDataRuleBasicSchema = exports.IShareDataNetworkFunctionDescriptorSchema = exports.IShareDataNetworkFunctionSchema = exports.IShareDataFunctionSchema = exports.IShareDataFunctionBasicSchema = exports.INetworkProofSchema = exports.ICryptographicSignatureProofSchema = exports.ITargetObjectSchema = exports.INetworkProofTypeSchema = exports.INetworkProofType = void 0;
+const zod_1 = require("zod");
 /**
- * This contains the data for the sahre functions
+ * This contains the data for the share functions
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.INetworkProofType = void 0;
+//#region enum
 /**
  * This contains all the proof types that exist for the network.
  */
@@ -11,6 +13,101 @@ var INetworkProofType;
 (function (INetworkProofType) {
     INetworkProofType["CRYPTOGRAPHIC_SIGNATURE"] = "CRYPTOGRAPHIC_SIGNATURE";
 })(INetworkProofType || (exports.INetworkProofType = INetworkProofType = {}));
+exports.INetworkProofTypeSchema = zod_1.z.enum([
+    'CRYPTOGRAPHIC_SIGNATURE',
+]);
+//#endregion enum
+/**
+ * This is the incoming object for the share functions.
+ */
+exports.ITargetObjectSchema = zod_1.z.record(zod_1.z.unknown());
+/**
+ * This contains the cryptographic signature proof for the share data network functions.
+ */
+exports.ICryptographicSignatureProofSchema = zod_1.z.object({
+    publicKey: zod_1.z.string(), // the public key of the signature
+    signature: zod_1.z.string(), // the cryptographic signature
+});
+/**
+ * This contains the network proof for the share data network functions.
+ */
+exports.INetworkProofSchema = exports.ICryptographicSignatureProofSchema;
+/**
+ * This contains the data for a share data network function without the signature
+ */
+exports.IShareDataFunctionBasicSchema = zod_1.z.object({
+    createdAt: zod_1.z.number(), // the time the function was created (in milliseconds)
+    previousHash: zod_1.z.string(), // the previous hash of the function
+    stringifiedFunction: zod_1.z.string(), // the stringified function
+    currentHash: zod_1.z.string(), // the hash of the stringified function + previous hash
+});
+// const shareDataFunction: IShareDataFunction = {
+// createdAt: 1234567890,
+// previousHash: 'example-previous-hash',
+// stringifiedFunction: 'example-stringified-function',
+// currentHash: 'example-current-hash',
+//     // Properties specific to IShareDataFunction
+//     proof: {
+//         signature: 'example-signature',
+//         publicKey: 'example-public-key',
+//         // Add other properties of ICryptographicSignatureProof as needed
+//     },
+//     proofType: INetworkProofType.CRYPTOGRAPHIC_SIGNATURE,
+// };
+/**
+ * This contains a share data function
+ */
+exports.IShareDataFunctionSchema = zod_1.z.object({
+    ...exports.IShareDataFunctionBasicSchema.shape,
+    proof: exports.INetworkProofSchema, // the proof that the function is valid
+    proofType: exports.INetworkProofTypeSchema, // the type of proof
+});
+/**
+ * This contains a share data network function
+ */
+exports.IShareDataNetworkFunctionSchema = zod_1.z.object({
+    id: zod_1.z.string(), // the id of the function (this will be the original hex representation of the following fields)
+    name: zod_1.z.string(), // the name of the function
+    description: zod_1.z.string(), // the description of the function
+    shareDataFunctions: zod_1.z.array(exports.IShareDataFunctionSchema), // the stringified function
+    proof: exports.INetworkProofSchema, // the proof that the function is valid
+    proofType: exports.INetworkProofTypeSchema, // the type of proof
+});
+/**
+ * This contains the data for a share data network function descriptor.
+ */
+exports.IShareDataNetworkFunctionDescriptorSchema = zod_1.z.object({
+    functionNumber: zod_1.z.number(), // the number of the function in the list
+    name: zod_1.z.string(), // the name of the function
+    description: zod_1.z.string(), // the description of the function
+});
+/**
+ * This contains the data for a share data network rule that is the basic shape.
+ */
+exports.IShareDataRuleBasicSchema = zod_1.z.object({
+    createdAt: zod_1.z.number(), // the time the rule was created (in milliseconds)
+    previousHash: zod_1.z.string(), // the previous hash of the rule
+    stringifiedRule: zod_1.z.string(), // the stringified rule
+    currentHash: zod_1.z.string(), // the hash of the stringified rule + previous hash
+});
+/**
+ * This contains the interface for a share function record in the share data object
+ */
+exports.IShareDataNetworkRuleSchema = zod_1.z.object({
+    id: zod_1.z.string(), // the id of the rule (this will be the original hex representation of the following fields)
+    shareDataRules: zod_1.z.array(exports.IShareDataRuleBasicSchema), // the stringified rule
+    applicationId: zod_1.z.string(), // the application id that owns the rule
+    applicationIdProof: zod_1.z.string(), // the proof that the application id owns the rule
+});
+/**
+ * This contains the data for a share data network rule.
+ */
+exports.IShareDataRuleSchema = zod_1.z.object({
+    createdAt: zod_1.z.number(), // the time the rule was created (in milliseconds)
+    previousHash: zod_1.z.string(), // the previous hash of the rule
+    stringifiedRule: zod_1.z.string(), // the stringified rule
+    currentHash: zod_1.z.string(), // the hash of the stringified rule + previous hash
+});
 /// Use of user defined function in the share data
 /// Storage / Retrieval of the user defined functions in the network. (logic library)
 // Use of user defined rules in the share data (product)

package/dist/models/generic/request-response-models.d.ts

@@ -1,8 +1,16 @@
+import { z } from 'zod';
 /**
  * This contains a generic response of the application when complex or other data is not required.
  */
-export interface IGenericResponse {
+export declare const IGenericResponseSchema: z.ZodObject<{
+    successful: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
     successful: boolean;
-    error?: string;
-}
+    error?: string | undefined;
+}, {
+    successful: boolean;
+    error?: string | undefined;
+}>;
+export type IGenericResponse = z.infer<typeof IGenericResponseSchema>;
 //# sourceMappingURL=request-response-models.d.ts.map

package/dist/models/generic/request-response-models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-response-models.d.ts","sourceRoot":"","sources":["../../../src/models/generic/request-response-models.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB"}
+{"version":3,"file":"request-response-models.d.ts","sourceRoot":"","sources":["../../../src/models/generic/request-response-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/models/generic/request-response-models.js

@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGenericResponseSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * This contains a generic response of the application when complex or other data is not required.
+ */
+exports.IGenericResponseSchema = zod_1.z.object({
+    successful: zod_1.z.boolean(), // whether the request was successful
+    error: zod_1.z.string().optional(), // the error of the request
+});

package/dist/models/index.d.ts

@@ -7,7 +7,8 @@ export * from './dynamic-execution/dynamic-execution-models';
 export * from './events/share-event-models';
 export * from './functions/share-data-function-models';
 export * from './generic/request-response-models';
-export * from './rules/share-rule-models';
+export * from './safe/rules/share-rule-models';
+export * from './safe/transactions/authorities-transactions-models';
 export * from './safe/safe-transaction-models';
 export * from './share-data/share-data';
 //# sourceMappingURL=index.d.ts.map

package/dist/models/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AAEA,cAAc,sDAAsD,CAAC;AACrE,cAAc,yCAAyC,CAAC;AACxD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,8CAA8C,CAAC;AAC7D,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AAEA,cAAc,sDAAsD,CAAC;AACrE,cAAc,yCAAyC,CAAC;AACxD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,8CAA8C,CAAC;AAC7D,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,mCAAmC,CAAC;AAElD,cAAc,gCAAgC,CAAC;AAE/C,cAAc,qDAAqD,CAAC;AAEpE,cAAc,gCAAgC,CAAC;AAG/C,cAAc,yBAAyB,CAAC"}

package/dist/models/index.js

@@ -24,6 +24,11 @@ __exportStar(require("./dynamic-execution/dynamic-execution-models"), exports);
 __exportStar(require("./events/share-event-models"), exports);
 __exportStar(require("./functions/share-data-function-models"), exports);
 __exportStar(require("./generic/request-response-models"), exports);
-__exportStar(require("./rules/share-rule-models"), exports);
+//#region safe
+__exportStar(require("./safe/rules/share-rule-models"), exports);
+//#region transactions
+__exportStar(require("./safe/transactions/authorities-transactions-models"), exports);
 __exportStar(require("./safe/safe-transaction-models"), exports);
+//#endregion transactions
+//#endregion safe
 __exportStar(require("./share-data/share-data"), exports);