@degenerate/endpoints 0.0.10 → 0.0.12

package/dist/schema/transactions.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.schema.d.ts","sourceRoot":"","sources":["../../src/schema/transactions.schema.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAC;AAKpB,eAAO,MAAM,yBAAyB,oFAOpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,+BAA+B,wCAI1C,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASrC,CAAC"}

package/dist/schema/transactions.schema.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISAFETransactionBaseSchema = exports.SAFETransactionActionTypeSchema = exports.SAFETransactionTypeSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+//#region Enums
+// This is the schema for the authority data.
+exports.SAFETransactionTypeSchema = zod_1.default.enum([
+    'AUTHORITY',
+    'SHAREDATA',
+    'FUNCTIONS',
+    'RULES',
+    'EVENTS',
+    'ENDPOINTS',
+]);
+/**
+ * This is the type of function that is being targetted in the transaction.
+ */
+exports.SAFETransactionActionTypeSchema = zod_1.default.enum([
+    'ADD',
+    'REMOVE',
+    'UPDATE',
+]);
+//#endregion Enums
+//#region Transaction
+/**
+ * This is the schema for the SAFE transaction base.
+ */
+exports.ISAFETransactionBaseSchema = zod_1.default.object({
+    createdAt: zod_1.default.number(), // the javascript timestamp of when the transaction was created
+    authority: zod_1.default.string(), // the public key of the authority that created the transaction
+    authoritySignature: zod_1.default.string(), // the signature of the authority that created the transaction
+    transaction: zod_1.default.object({
+        type: exports.SAFETransactionTypeSchema, // the type of transaction
+        action: exports.SAFETransactionActionTypeSchema, // the action to perform on the transaction
+    }),
+    version: zod_1.default.number(), // the version of the transaction
+});
+//#endregion Transaction

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@degenerate/endpoints",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "devDependencies": {
@@ -39,9 +39,9 @@
   "author": "Degenerate Inc.",
   "license": "ISC",
   "dependencies": {
-    "@degenerate/generic": "^0.1.9",
+    "@degenerate/generic": "^0.1.11",
     "express": "^4.21.1",
     "zod": "^3.23.8"
   },
-  "gitHead": "5e38293cf889de1089ca2cda356191136a493507"
+  "gitHead": "737d8d07f08124b2f4c05bd9e4a41c96bd571791"
 }

package/dist/cors/endpoints/authorities/validate-authorities-transaction.d.ts

@@ -1,30 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-/**
- * This takes the incoming object and validates that it is the correct shape
- * @param req
- * @param res
- * @param next
- * @returns
- */
-export declare function validateAuthoritiesTransaction(req: Request, res: Response, next: NextFunction): Response<any, Record<string, any>> | undefined;
-/**
- * This is the transaction targetting an authority in the SAFE Ecosystem.
- *
-const sampleTransactionAuthority: ISAFETransactionAuthority = {
-    createdAt: Date.now(),
-    authority: '0xAuthorityPublicKey',
-    authoritySignature: '0xAuthoritySignature',
-    transaction: {
-        type: SAFETransactionType.AUTHORITY,
-        action: SAFETransactionActionType.CREATE,
-        data: {
-            authorizationIssuer: 'exampleIssuer-12345678' as IAuthorizationIssuer,
-            authorizationPublicKey: '0xAuthorizationPublicKey',
-            authorityValidationType: AuthorityValidationType.JWT,
-            authorityOver: [SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS],
-        },
-    },
-    version: 1,
-};
- */
-//# sourceMappingURL=validate-authorities-transaction.d.ts.map

package/dist/cors/endpoints/authorities/validate-authorities-transaction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate-authorities-transaction.d.ts","sourceRoot":"","sources":["../../../../src/cors/endpoints/authorities/validate-authorities-transaction.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,kDAY7F;AAED;;;;;;;;;;;;;;;;;;;GAmBG"}

package/dist/cors/endpoints/authorities/validate-authorities-transaction.js

@@ -1,155 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateAuthoritiesTransaction = validateAuthoritiesTransaction;
-/**
- * This takes the incoming object and validates that it is the correct shape
- * @param req
- * @param res
- * @param next
- * @returns
- */
-function validateAuthoritiesTransaction(req, res, next) {
-    const { transaction } = req.body;
-    if (!transaction) {
-        return res.status(400).send({ error: 'No transaction provided' });
-    }
-    if (!transaction.authorities) {
-        return res.status(400).send({ error: 'No authorities provided' });
-    }
-    if (!transaction.authorities.length) {
-        return res.status(400).send({ error: 'No authorities provided' });
-    }
-    next();
-}
-/**
- * This is the transaction targetting an authority in the SAFE Ecosystem.
- *
-const sampleTransactionAuthority: ISAFETransactionAuthority = {
-    createdAt: Date.now(),
-    authority: '0xAuthorityPublicKey',
-    authoritySignature: '0xAuthoritySignature',
-    transaction: {
-        type: SAFETransactionType.AUTHORITY,
-        action: SAFETransactionActionType.CREATE,
-        data: {
-            authorizationIssuer: 'exampleIssuer-12345678' as IAuthorizationIssuer,
-            authorizationPublicKey: '0xAuthorizationPublicKey',
-            authorityValidationType: AuthorityValidationType.JWT,
-            authorityOver: [SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS],
-        },
-    },
-    version: 1,
-};
- */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// /**
-//  * This validates the incoming request for the shape of the add account holder record to a user
-//  *
-//  * @param req the incoming request
-//  * @param res the response
-//  * @param next the next function
-//  * @returns
-//  */
-// export function validateAddAccountHolderRecord(req: Request, res: Response, next: NextFunction): void | Response<any> {
-//     let parsedBody;
-//     if (typeof req.body === 'object') {
-//         parsedBody = req.body;
-//     } else {
-//         parsedBody = JSON.parse(req.body);
-//     }
-//     // if we can't parse the body then it's not a valid object
-//     if (!parsedBody) throw new RequestObjectValidationFailedError(req.body, 'req.body', 'object');
-//     const bodyKeys = Object.keys(parsedBody);
-//     if (bodyKeys.length !== 2) {
-//         throw new RequestObjectShouldOnlyHaveXPropertiesError(parsedBody, 'req.body', bodyKeys.length, 2);
-//     }
-//     if (!validateString(parsedBody.userId, true, false, false)) {
-//         throw new RequestObjectValidationFailedError(parsedBody.userId, 'userId', 'string');
-//     }
-//     if (!validateArray(parsedBody.accountHolderRecords)) {
-//         throw new RequestObjectValidationFailedError(parsedBody.accountHolderRecords, 'accountHolderRecords', 'array');
-//     }
-//     for (const accountHolderRecord of parsedBody.accountHolderRecords) {
-//         validateAccountHolderRecord(accountHolderRecord);
-//     }
-//     req.body = parsedBody as IAccountHolderRecordDoc;
-//     next();
-//     return;
-// }
-// /**
-//  * Make sure the account holder record is valid
-//  *
-//  * @param accountHolderRecord the account holder record
-//  */
-// function validateAccountHolderRecord(accountHolderRecord: any): void {
-//     if (!accountHolderRecord) throw new RequestObjectValidationFailedError(accountHolderRecord, 'accountHolderRecord', 'object');
-//     const bodyKeys = Object.keys(accountHolderRecord);
-//     if (bodyKeys.length !== 3) {
-//         throw new RequestObjectShouldOnlyHaveXPropertiesError(accountHolderRecord, 'accountHolderRecord', bodyKeys.length, 3);
-//     }
-//     if (!validateString(accountHolderRecord.financialEndpointProviderId, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(accountHolderRecord.financialEndpointProviderId,
-//             'financialEndpointProviderId', 'string');
-//     }
-//     if (!validateString(accountHolderRecord.institutionId, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(accountHolderRecord.institutionId, 'institutionId', 'string');
-//     }
-//     if (!accountHolderRecord.accountHolder) throw new RequestObjectValidationFailedError(accountHolderRecord, 'accountHolder', 'object');
-//     validateAccountHolder(accountHolderRecord.accountHolder);
-//     return;
-// }
-// /**
-//  * This validates the account holder object
-//  *
-//  * @param accountHolder
-//  * @returns
-//  */
-// function validateAccountHolder(accountHolder: any): void {
-//     if (!accountHolder) throw new RequestObjectValidationFailedError(accountHolder, 'accountHolder', 'object');
-//     const bodyKeys = Object.keys(accountHolder);
-//     if (bodyKeys.length !== 5) {
-//         throw new RequestObjectShouldOnlyHaveXPropertiesError(accountHolder, 'accountHolder', bodyKeys.length, 5);
-//     }
-//     if (!validateString(accountHolder.accountId, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(accountHolder.accountId, 'accountId', 'string');
-//     }
-//     if (!accountHolder.address) throw new RequestObjectValidationFailedError(accountHolder, 'address', 'object');
-//     validateAccountHolderAddress(accountHolder.address);
-//     if (!validateString(accountHolder.name, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(accountHolder.name, 'name', 'string');
-//     }
-//     if (!validateString(accountHolder.email, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(accountHolder.email, 'email', 'string');
-//     }
-//     if (!validateString(accountHolder.phoneNumber, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(accountHolder.phoneNumber, 'phoneNumber', 'string');
-//     }
-//     return;
-// }
-// /**
-//  * This validates the account holder address record
-//  *
-//  * @param address
-//  */
-// function validateAccountHolderAddress(address: any): void {
-//     if (!address) throw new RequestObjectValidationFailedError(address, 'address', 'object');
-//     if (!validateString(address.civicAddress, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(address.civicAddress, 'civicAddress', 'string');
-//     }
-//     if (!validateString(address.city, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(address.city, 'city', 'string');
-//     }
-//     if (!validateString(address.province, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(address.province, 'province', 'string');
-//     }
-//     if (!validateString(address.postalCode, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(address.postalCode, 'postalCode', 'string');
-//     }
-//     if (!validateString(address.poBox, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(address.poBox, 'poBox', 'string');
-//     }
-//     if (!validateString(address.country, false, true, true)) {
-//         throw new RequestObjectValidationFailedError(address.country, 'country', 'string');
-//     }
-//     return;
-// }

package/dist/schema/authorities.schema.d.ts

@@ -1,343 +0,0 @@
-import z from 'zod';
-import { AuthorityValidationType, SAFETransactionActionType, SAFETransactionType } from '@degenerate/generic';
-/**
- * This is the data for the authority in the SAFE Ecosystem.
- */
-export declare const ISAFETransactionAuthorityDataSchema: z.ZodObject<{
-    authorizationIssuer: z.ZodString;
-    authorizationPublicKey: z.ZodString;
-    authorityValidationType: z.ZodEnum<[AuthorityValidationType]>;
-    authorityOver: z.ZodArray<z.ZodEnum<[SAFETransactionType.AUTHORITY, SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS, SAFETransactionType.RULES, SAFETransactionType.EVENTS, SAFETransactionType.ENDPOINTS]>, "many">;
-}, "strip", z.ZodTypeAny, {
-    authorizationIssuer: string;
-    authorizationPublicKey: string;
-    authorityValidationType: AuthorityValidationType;
-    authorityOver: SAFETransactionType[];
-}, {
-    authorizationIssuer: string;
-    authorizationPublicKey: string;
-    authorityValidationType: AuthorityValidationType;
-    authorityOver: SAFETransactionType[];
-}>;
-/**
- * This is the schema for the SAFE transaction base.
- */
-export declare const ISAFETransactionBaseSchema: z.ZodObject<{
-    createdAt: z.ZodNumber;
-    authority: z.ZodString;
-    authoritySignature: z.ZodString;
-    transaction: z.ZodObject<{
-        type: z.ZodEnum<[SAFETransactionType.AUTHORITY, SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS, SAFETransactionType.RULES, SAFETransactionType.EVENTS, SAFETransactionType.ENDPOINTS]>;
-        action: z.ZodEnum<[SAFETransactionActionType.ADD, SAFETransactionActionType.REMOVE, SAFETransactionActionType.UPDATE]>;
-    }, "strip", z.ZodTypeAny, {
-        type: SAFETransactionType;
-        action: SAFETransactionActionType;
-    }, {
-        type: SAFETransactionType;
-        action: SAFETransactionActionType;
-    }>;
-    version: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    createdAt: number;
-    authority: string;
-    authoritySignature: string;
-    transaction: {
-        type: SAFETransactionType;
-        action: SAFETransactionActionType;
-    };
-    version: number;
-}, {
-    createdAt: number;
-    authority: string;
-    authoritySignature: string;
-    transaction: {
-        type: SAFETransactionType;
-        action: SAFETransactionActionType;
-    };
-    version: number;
-}>;
-/**
- * This is the transaction targetting an authority in the SAFE Ecosystem.
- *
-const sampleTransactionAuthority: ISAFETransactionAuthority = {
-    createdAt: Date.now(),
-    authority: '0xAuthorityPublicKey',
-    authoritySignature: '0xAuthoritySignature',
-    transaction: {
-        type: SAFETransactionType.AUTHORITY,
-        action: SAFETransactionActionType.CREATE,
-        data: {
-            authorizationIssuer: 'exampleIssuer-12345678' as IAuthorizationIssuer,
-            authorizationPublicKey: '0xAuthorizationPublicKey',
-            authorityValidationType: AuthorityValidationType.JWT,
-            authorityOver: [SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS],
-        },
-    },
-    version: 1,
-};
- */
-/**
- * This is the schema for the authority transaction add.
- */
-export declare const ISAFETransactionAuthorityAddSchema: z.ZodObject<z.objectUtil.extendShape<{
-    createdAt: z.ZodNumber;
-    authority: z.ZodString;
-    authoritySignature: z.ZodString;
-    transaction: z.ZodObject<{
-        type: z.ZodEnum<[SAFETransactionType.AUTHORITY, SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS, SAFETransactionType.RULES, SAFETransactionType.EVENTS, SAFETransactionType.ENDPOINTS]>;
-        action: z.ZodEnum<[SAFETransactionActionType.ADD, SAFETransactionActionType.REMOVE, SAFETransactionActionType.UPDATE]>;
-    }, "strip", z.ZodTypeAny, {
-        type: SAFETransactionType;
-        action: SAFETransactionActionType;
-    }, {
-        type: SAFETransactionType;
-        action: SAFETransactionActionType;
-    }>;
-    version: z.ZodNumber;
-}, {
-    transaction: z.ZodObject<{
-        type: z.ZodLiteral<SAFETransactionType.AUTHORITY>;
-        action: z.ZodLiteral<SAFETransactionActionType.ADD>;
-        data: z.ZodObject<{
-            authorizationIssuer: z.ZodString;
-            authorizationPublicKey: z.ZodString;
-            authorityValidationType: z.ZodEnum<[AuthorityValidationType]>;
-            authorityOver: z.ZodArray<z.ZodEnum<[SAFETransactionType.AUTHORITY, SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS, SAFETransactionType.RULES, SAFETransactionType.EVENTS, SAFETransactionType.ENDPOINTS]>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        }, {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.ADD;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    }, {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.ADD;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    }>;
-}>, "strip", z.ZodTypeAny, {
-    createdAt: number;
-    authority: string;
-    authoritySignature: string;
-    transaction: {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.ADD;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    };
-    version: number;
-}, {
-    createdAt: number;
-    authority: string;
-    authoritySignature: string;
-    transaction: {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.ADD;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    };
-    version: number;
-}>;
-/**
- * This is the schema for the authority transaction update.
- */
-export declare const ISAFETransactionAuthorityUpdateSchema: z.ZodObject<z.objectUtil.extendShape<{
-    createdAt: z.ZodNumber;
-    authority: z.ZodString;
-    authoritySignature: z.ZodString;
-    transaction: z.ZodObject<{
-        type: z.ZodEnum<[SAFETransactionType.AUTHORITY, SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS, SAFETransactionType.RULES, SAFETransactionType.EVENTS, SAFETransactionType.ENDPOINTS]>;
-        action: z.ZodEnum<[SAFETransactionActionType.ADD, SAFETransactionActionType.REMOVE, SAFETransactionActionType.UPDATE]>;
-    }, "strip", z.ZodTypeAny, {
-        type: SAFETransactionType;
-        action: SAFETransactionActionType;
-    }, {
-        type: SAFETransactionType;
-        action: SAFETransactionActionType;
-    }>;
-    version: z.ZodNumber;
-}, {
-    transaction: z.ZodObject<{
-        type: z.ZodLiteral<SAFETransactionType.AUTHORITY>;
-        action: z.ZodLiteral<SAFETransactionActionType.UPDATE>;
-        data: z.ZodObject<{
-            authorizationIssuer: z.ZodString;
-            authorizationPublicKey: z.ZodString;
-            authorityValidationType: z.ZodEnum<[AuthorityValidationType]>;
-            authorityOver: z.ZodArray<z.ZodEnum<[SAFETransactionType.AUTHORITY, SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS, SAFETransactionType.RULES, SAFETransactionType.EVENTS, SAFETransactionType.ENDPOINTS]>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        }, {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.UPDATE;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    }, {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.UPDATE;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    }>;
-}>, "strip", z.ZodTypeAny, {
-    createdAt: number;
-    authority: string;
-    authoritySignature: string;
-    transaction: {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.UPDATE;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    };
-    version: number;
-}, {
-    createdAt: number;
-    authority: string;
-    authoritySignature: string;
-    transaction: {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.UPDATE;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    };
-    version: number;
-}>;
-/**
- * This is the schema for the authority transaction remove.
- */
-export declare const ISAFETransactionAuthorityRemoveSchema: z.ZodObject<z.objectUtil.extendShape<{
-    createdAt: z.ZodNumber;
-    authority: z.ZodString;
-    authoritySignature: z.ZodString;
-    transaction: z.ZodObject<{
-        type: z.ZodEnum<[SAFETransactionType.AUTHORITY, SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS, SAFETransactionType.RULES, SAFETransactionType.EVENTS, SAFETransactionType.ENDPOINTS]>;
-        action: z.ZodEnum<[SAFETransactionActionType.ADD, SAFETransactionActionType.REMOVE, SAFETransactionActionType.UPDATE]>;
-    }, "strip", z.ZodTypeAny, {
-        type: SAFETransactionType;
-        action: SAFETransactionActionType;
-    }, {
-        type: SAFETransactionType;
-        action: SAFETransactionActionType;
-    }>;
-    version: z.ZodNumber;
-}, {
-    transaction: z.ZodObject<{
-        type: z.ZodLiteral<SAFETransactionType.AUTHORITY>;
-        action: z.ZodLiteral<SAFETransactionActionType.REMOVE>;
-        data: z.ZodObject<{
-            authorizationIssuer: z.ZodString;
-            authorizationPublicKey: z.ZodString;
-            authorityValidationType: z.ZodEnum<[AuthorityValidationType]>;
-            authorityOver: z.ZodArray<z.ZodEnum<[SAFETransactionType.AUTHORITY, SAFETransactionType.SHAREDATA, SAFETransactionType.FUNCTIONS, SAFETransactionType.RULES, SAFETransactionType.EVENTS, SAFETransactionType.ENDPOINTS]>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        }, {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.REMOVE;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    }, {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.REMOVE;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    }>;
-}>, "strip", z.ZodTypeAny, {
-    createdAt: number;
-    authority: string;
-    authoritySignature: string;
-    transaction: {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.REMOVE;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    };
-    version: number;
-}, {
-    createdAt: number;
-    authority: string;
-    authoritySignature: string;
-    transaction: {
-        type: SAFETransactionType.AUTHORITY;
-        action: SAFETransactionActionType.REMOVE;
-        data: {
-            authorizationIssuer: string;
-            authorizationPublicKey: string;
-            authorityValidationType: AuthorityValidationType;
-            authorityOver: SAFETransactionType[];
-        };
-    };
-    version: number;
-}>;
-//# sourceMappingURL=authorities.schema.d.ts.map

package/dist/schema/authorities.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"authorities.schema.d.ts","sourceRoot":"","sources":["../../src/schema/authorities.schema.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAKpB,OAAO,EACH,uBAAuB,EACvB,yBAAyB,EACzB,mBAAmB,EACtB,MAAM,qBAAqB,CAAC;AAK7B;;GAEG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;EAK9C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASrC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;GAEG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM7C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMhD,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMhD,CAAC"}