arvo-core 2.0.10 → 2.1.0

package/dist/ArvoContract/helpers.js

@@ -3,29 +3,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSimpleArvoContract = exports.createArvoContract = void 0;
+exports.createArvoContract = void 0;
 var _1 = __importDefault(require("."));
 var typegen_1 = require("../ArvoOrchestratorContract/typegen");
 var utils_1 = require("../utils");
-var validators_1 = require("./validators");
-var schema_1 = require("../schema");
-var ArvoOrchestrationSubject_1 = __importDefault(require("../ArvoOrchestrationSubject"));
 /**
- * Creates and validates an ArvoContract instance from a contract specification.
+ * Creates a validated ArvoContract instance with full control over event types and schemas.
  *
- * @template TContract - The contract specification type, must extend IArvoContract
- * @param contract - The contract specification object containing URI, type, and versioned schemas
- * @throws {Error} If any event type uses the reserved orchestrator prefix
- * @throws {Error} If URI or event types fail validation
- * @returns A properly typed ArvoContract instance
+ * @param contract - Contract specification object
+ *
+ * @throws {Error} If the event types contain reserved prefix ({@link ArvoOrchestratorEventTypeGen})
+ * @throws {Error} If any of the ArvoContract's internal validations fail. See {@link ArvoContract}
+ *
+ * @returns A fully typed and validated ArvoContract instance
  *
  * @example
  * ```typescript
  * const contract = createArvoContract({
  *   uri: 'com.example.contract',
  *   type: 'input.event',
+ *   description: "Some example contract",
+ *   metadata: {
+ *     owner: 'team-a',
+ *     priority: 'high'
+ *   },
  *   versions: {
- *     '0.0.1': {
+ *     '1.0.0': {
  *       accepts: z.object({ data: z.string() }),
  *       emits: {
  *         'output.event': z.object({ result: z.number() })
@@ -35,138 +38,30 @@ var ArvoOrchestrationSubject_1 = __importDefault(require("../ArvoOrchestrationSu
  * });
  * ```
  */
-var createArvoContract = function (contract, isOrchestrationContract) {
-    if (isOrchestrationContract === void 0) { isOrchestrationContract = false; }
+var createArvoContract = function (contract) {
+    var _a, _b;
     var createErrorMessage = function (source, type, version) {
         var versionString = version ? ", version=".concat(version) : '';
         return (0, utils_1.cleanString)("\n      In contract (uri=".concat(contract.uri).concat(versionString, "), the '").concat(source, "' event (type=").concat(type, ") must not start\n      with '").concat(typegen_1.ArvoOrchestratorEventTypeGen.prefix, "' because this is a reserved pattern\n      for Arvo orchestrators.\n    "));
     };
-    var isReservedPrefix = function (value) {
-        return !isOrchestrationContract &&
-            value.startsWith(typegen_1.ArvoOrchestratorEventTypeGen.prefix);
-    };
-    if (isReservedPrefix(contract.type)) {
+    if (typegen_1.ArvoOrchestratorEventTypeGen.isOrchestratorEventType(contract.type)) {
         throw new Error(createErrorMessage('accepts', contract.type, null));
     }
-    validators_1.ArvoContractValidators.contract.uri.parse(contract.uri);
-    for (var _i = 0, _a = Object.entries(contract.versions); _i < _a.length; _i++) {
-        var _b = _a[_i], version = _b[0], versionContract = _b[1];
-        schema_1.ArvoSemanticVersionSchema.parse(version);
-        if (version === ArvoOrchestrationSubject_1.default.WildCardMachineVersion) {
-            throw new Error("The version cannot be ".concat(ArvoOrchestrationSubject_1.default.WildCardMachineVersion));
-        }
-        for (var _c = 0, _d = Object.keys(versionContract.emits); _c < _d.length; _c++) {
-            var emitType = _d[_c];
-            validators_1.ArvoContractValidators.record.type.parse(emitType);
-            if (isReservedPrefix(emitType)) {
+    for (var _i = 0, _c = Object.entries(contract.versions); _i < _c.length; _i++) {
+        var _d = _c[_i], version = _d[0], versionContract = _d[1];
+        for (var _e = 0, _f = Object.keys(versionContract['emits']); _e < _f.length; _e++) {
+            var emitType = _f[_e];
+            if (typegen_1.ArvoOrchestratorEventTypeGen.isOrchestratorEventType(emitType)) {
                 throw new Error(createErrorMessage('emits', emitType, version));
             }
         }
     }
-    return new _1.default(contract);
-};
-exports.createArvoContract = createArvoContract;
-/**
- * Creates a simplified ArvoContract with standardized type prefixes and emit patterns.
- * This is a convenience function that automatically formats event types according to conventions:
- * - Accept types are prefixed with "com."
- * - Emit types are prefixed with "evt." and suffixed with ".success"
- *
- * @template TUri - The URI type for the contract
- * @template TType - The base type name (without prefixes) for the contract
- * @template TVersions - Record of versions containing accept and emit schemas
- *
- * @param param - The configuration object for creating the contract
- * @param param.uri - The URI identifying the contract
- * @param param.type - The base type name (will be prefixed with "com.")
- * @param param.versions - Version-specific schema definitions
- * @param param.versions[version].accepts - Zod schema for validating incoming events
- * @param param.versions[version].emits - Zod schema for validating outgoing events
- *
- * @returns An ArvoContract instance with standardized type formatting:
- *          - Accept type will be "com.[type]"
- *          - Emit type will be "evt.[type].success"
- *
- * @example
- * ```typescript
- * const contract = createSimpleArvoContract({
- *   uri: 'example.com/contracts/processor',
- *   type: 'document.process',
- *   versions: {
- *     '1.0.0': {
- *       accepts: z.object({
- *         documentId: z.string(),
- *         options: z.object({ format: z.string() })
- *       }),
- *       emits: z.object({
- *         processedDocument: z.string(),
- *         metadata: z.object({ size: z.number() })
- *       })
- *     }
- *   }
- * });
- *
- * // Results in a contract where:
- * // - Accept type is "com.document.process"
- * // - Emit type is "evt.document.process.success"
- * ```
- *
- * @example
- * ```typescript
- * // Multiple versions example
- * const contract = createSimpleArvoContract({
- *   uri: 'api.example/contracts/user',
- *   type: 'user.create',
- *   versions: {
- *     '1.0.0': {
- *       accepts: z.object({ name: z.string() }),
- *       emits: z.object({ id: z.string() })
- *     },
- *     '2.0.0': {
- *       accepts: z.object({
- *         name: z.string(),
- *         email: z.string().email()
- *       }),
- *       emits: z.object({
- *         id: z.string(),
- *         created: z.date()
- *       })
- *     }
- *   }
- * });
- * ```
- *
- * @remarks
- * This function simplifies contract creation by:
- * 1. Automatically prefixing accept types with "com."
- * 2. Creating a single emit type prefixed with "evt." and suffixed with ".success"
- * 3. Maintaining type safety and schema validation
- *
- * Use this when you have a simple contract pattern with:
- * - A single accept type
- * - A single success emit type
- * - Standard type naming conventions
- *
- * For more complex contracts with multiple emit types or custom type naming,
- * use {@link createArvoContract} instead.
- */
-var createSimpleArvoContract = function (param) {
-    return (0, exports.createArvoContract)({
-        uri: param.uri,
-        type: "com.".concat(param.type),
-        versions: Object.fromEntries(Object.entries(param.versions).map(function (_a) {
-            var _b;
-            var version = _a[0], contract = _a[1];
-            return [
-                version,
-                {
-                    accepts: contract.accepts,
-                    emits: (_b = {},
-                        _b["evt.".concat(param.type, ".success")] = contract.emits,
-                        _b),
-                },
-            ];
-        })),
+    return new _1.default({
+        uri: contract.uri,
+        type: contract.type,
+        description: (_a = contract.description) !== null && _a !== void 0 ? _a : null,
+        metadata: (_b = contract.metadata) !== null && _b !== void 0 ? _b : {},
+        versions: contract.versions,
     });
 };
-exports.createSimpleArvoContract = createSimpleArvoContract;
+exports.createArvoContract = createArvoContract;

package/dist/ArvoContract/index.d.ts

@@ -8,21 +8,27 @@ import { VersionedArvoContract } from './VersionedArvoContract';
  * The ArvoContract class provides type-safe validation and versioning capabilities for event handling,
  * ensuring consistency in message passing between different parts of the system.
  *
- * @template TUri - The URI identifier for the contract, must be a string type
- * @template TType - The accept type for the contract, must be a string type
- * @template TVersions - Record of versioned schemas defining contract structure per version
- *
  * @example
  * ```typescript
  * const contract = createArvoContract({
  *   uri: '#/my/service/data',
  *   type: 'com.process.data',
+ *   description: 'An example contract',
+ *   metadata: {
+ *     visibility: "public"
+ *   }
  *   versions: {
  *     '1.0.0': {
  *       accepts: z.object({ data: z.string() }),
  *       emits: {
  *         'data.processed': z.object({ result: z.string() })
  *       }
+ *     },
+ *     '2.0.0': {
+ *       accepts: z.object({ data: z.number() }),
+ *       emits: {
+ *         'data.processed': z.object({ result: z.number() })
+ *       }
  *     }
  *   }
  * });
@@ -34,25 +40,30 @@ export default class ArvoContract<TUri extends string = string, TType extends st
 }> = Record<ArvoSemanticVersion, {
     accepts: z.ZodTypeAny;
     emits: Record<string, z.ZodTypeAny>;
-}>> {
+}>, TMetaData extends Record<string, any> = Record<string, any>> {
     private readonly _uri;
     private readonly _type;
     private readonly _versions;
-    readonly description: string | null;
-    constructor(params: IArvoContract<TUri, TType, TVersions>);
-    /**
-     * Gets the URI of the contract.
-     */
+    private readonly _description;
+    private readonly _metadata;
     get uri(): TUri;
-    /**
-     * Get the type of the event the handler
-     * bound to the contract accepts
-     */
     get type(): TType;
+    get versions(): TVersions;
+    get description(): string | null;
+    get metadata(): TMetaData;
     /**
-     * Gets the version of the contract
+     * Creates a new ArvoContract instance with validated parameters.
+     *
+     * @param params - Contract configuration parameters
+     *
+     * @throws {Error} When URI format is invalid
+     * @throws {Error} When event type format is invalid
+     * @throws {Error} When version string is not valid semantic version
+     * @throws {Error} When version is a reserved wildcard version
+     * @throws {Error} When emit type format is invalid
+     * @throws {Error} When no versions are provided
      */
-    get versions(): TVersions;
+    constructor(params: IArvoContract<TUri, TType, TVersions, TMetaData>);
     /**
      * Gets the system error event specification for this contract.
      * System errors follow a standardized format to handle exceptional conditions
@@ -73,9 +84,6 @@ export default class ArvoContract<TUri extends string = string, TType extends st
     /**
      * Retrieves a specific version of the contract or resolves special version identifiers.
      *
-     * @template V - Type parameter constrained to valid semantic versions in TVersions
-     * @template S - Type parameter for special version identifiers
-     *
      * @param option - Version identifier or special version string
      * - Specific version (e.g., "1.0.0")
      * - "latest" or "any" for the most recent version
@@ -85,30 +93,21 @@ export default class ArvoContract<TUri extends string = string, TType extends st
      *
      * @throws {Error} When an invalid or non-existent version is requested
      */
-    version<V extends ArvoSemanticVersion & keyof TVersions, S extends 'any' | 'latest' | 'oldest'>(option: V | S): V extends ArvoSemanticVersion ? VersionedArvoContract<typeof this, V> : VersionedArvoContract<typeof this, ArvoSemanticVersion & keyof TVersions>;
+    version<V extends (ArvoSemanticVersion & keyof TVersions) | 'any' | 'latest' | 'oldest'>(option: V): V extends ArvoSemanticVersion & keyof TVersions ? VersionedArvoContract<typeof this, V, TMetaData> : VersionedArvoContract<any, any, any>;
     /**
      * Retrieves version numbers in sorted order based on semantic versioning rules.
-     *
-     * @param ordering - Sort direction for versions
-     * - 'ASC' - Ascending order (oldest to newest)
-     * - 'DESC' - Descending order (newest to oldest)
-     *
      * @returns Array of semantic versions sorted according to specified ordering
      */
     getSortedVersionNumbers(ordering: 'ASC' | 'DESC'): `${number}.${number}.${number}`[];
     /**
      * Exports the ArvoContract instance as a plain object conforming to the IArvoContract interface.
      * This method can be used to serialize the contract or to create a new instance with the same parameters.
-     *
-     * @returns An object representing the contract, including its URI, accepts, and emits properties.
      */
     export(): IArvoContract<TUri, TType, TVersions>;
     /**
      * Converts the ArvoContract instance to a JSON Schema representation.
      * This method provides a way to represent the contract's structure and validation rules
      * in a format that conforms to the JSON Schema specification.
-     *
-     * @returns An object representing the contract in JSON Schema format:
      */
     toJsonSchema(): ArvoContractJSONSchema;
 }

package/dist/ArvoContract/index.js

@@ -1,48 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var zod_to_json_schema_1 = require("zod-to-json-schema");
 var schema_1 = require("../schema");
 var utils_1 = require("../utils");
+var VersionedArvoContract_1 = require("./VersionedArvoContract");
+var validators_1 = require("./validators");
+var WildCardArvoSemanticVersion_1 = require("./WildCardArvoSemanticVersion");
+var OpenTelemetry_1 = require("../OpenTelemetry");
 /**
  * Represents a contract with defined input and output schemas for event-driven architectures.
  * The ArvoContract class provides type-safe validation and versioning capabilities for event handling,
  * ensuring consistency in message passing between different parts of the system.
  *
- * @template TUri - The URI identifier for the contract, must be a string type
- * @template TType - The accept type for the contract, must be a string type
- * @template TVersions - Record of versioned schemas defining contract structure per version
- *
  * @example
  * ```typescript
  * const contract = createArvoContract({
  *   uri: '#/my/service/data',
  *   type: 'com.process.data',
+ *   description: 'An example contract',
+ *   metadata: {
+ *     visibility: "public"
+ *   }
  *   versions: {
  *     '1.0.0': {
  *       accepts: z.object({ data: z.string() }),
  *       emits: {
  *         'data.processed': z.object({ result: z.string() })
  *       }
+ *     },
+ *     '2.0.0': {
+ *       accepts: z.object({ data: z.number() }),
+ *       emits: {
+ *         'data.processed': z.object({ result: z.number() })
+ *       }
  *     }
  *   }
  * });
  * ```
  */
 var ArvoContract = /** @class */ (function () {
+    /**
+     * Creates a new ArvoContract instance with validated parameters.
+     *
+     * @param params - Contract configuration parameters
+     *
+     * @throws {Error} When URI format is invalid
+     * @throws {Error} When event type format is invalid
+     * @throws {Error} When version string is not valid semantic version
+     * @throws {Error} When version is a reserved wildcard version
+     * @throws {Error} When emit type format is invalid
+     * @throws {Error} When no versions are provided
+     */
     function ArvoContract(params) {
         var _a;
         this._uri = params.uri;
         this._type = params.type;
         this._versions = params.versions;
-        this.description = (_a = params.description) !== null && _a !== void 0 ? _a : null;
+        this._description = (_a = params.description) !== null && _a !== void 0 ? _a : null;
+        this._metadata = params.metadata;
+        validators_1.ArvoContractValidators.contract.uri.parse(params.uri);
+        validators_1.ArvoContractValidators.record.type.parse(params.type);
+        for (var _i = 0, _b = Object.entries(params.versions); _i < _b.length; _i++) {
+            var _c = _b[_i], version = _c[0], versionContract = _c[1];
+            schema_1.ArvoSemanticVersionSchema.parse(version);
+            if ((0, WildCardArvoSemanticVersion_1.isWildCardArvoSematicVersion)(version)) {
+                throw new Error("For contract (uri=".concat(params.uri, "), the version cannot be '").concat(WildCardArvoSemanticVersion_1.WildCardArvoSemanticVersion, "'. It is a reserved version type."));
+            }
+            for (var _d = 0, _e = Object.keys(versionContract.emits); _d < _e.length; _d++) {
+                var emitType = _e[_d];
+                validators_1.ArvoContractValidators.record.type.parse(emitType);
+            }
+        }
         if (!Object.keys(this._versions).length) {
             throw new Error("An ArvoContract (uri=".concat(this._uri, ") must have at least one version"));
         }
     }
     Object.defineProperty(ArvoContract.prototype, "uri", {
-        /**
-         * Gets the URI of the contract.
-         */
         get: function () {
             return this._uri;
         },
@@ -50,10 +82,6 @@ var ArvoContract = /** @class */ (function () {
         configurable: true
     });
     Object.defineProperty(ArvoContract.prototype, "type", {
-        /**
-         * Get the type of the event the handler
-         * bound to the contract accepts
-         */
         get: function () {
             return this._type;
         },
@@ -61,15 +89,26 @@ var ArvoContract = /** @class */ (function () {
         configurable: true
     });
     Object.defineProperty(ArvoContract.prototype, "versions", {
-        /**
-         * Gets the version of the contract
-         */
         get: function () {
             return this._versions;
         },
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(ArvoContract.prototype, "description", {
+        get: function () {
+            return this._description;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ArvoContract.prototype, "metadata", {
+        get: function () {
+            return this._metadata;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(ArvoContract.prototype, "systemError", {
         /**
          * Gets the system error event specification for this contract.
@@ -99,9 +138,6 @@ var ArvoContract = /** @class */ (function () {
     /**
      * Retrieves a specific version of the contract or resolves special version identifiers.
      *
-     * @template V - Type parameter constrained to valid semantic versions in TVersions
-     * @template S - Type parameter for special version identifiers
-     *
      * @param option - Version identifier or special version string
      * - Specific version (e.g., "1.0.0")
      * - "latest" or "any" for the most recent version
@@ -125,9 +161,9 @@ var ArvoContract = /** @class */ (function () {
         else {
             resolvedVersion = option;
         }
-        return {
+        return new VersionedArvoContract_1.VersionedArvoContract({
             uri: this._uri,
-            description: this.description,
+            description: this._description,
             version: resolvedVersion,
             accepts: {
                 type: this._type,
@@ -135,15 +171,11 @@ var ArvoContract = /** @class */ (function () {
             },
             systemError: this.systemError,
             emits: this._versions[resolvedVersion].emits,
-        }; // needed due to TypeScript limitations with conditional types
+            metadata: this._metadata,
+        }); // needed due to TypeScript limitations with conditional types
     };
     /**
      * Retrieves version numbers in sorted order based on semantic versioning rules.
-     *
-     * @param ordering - Sort direction for versions
-     * - 'ASC' - Ascending order (oldest to newest)
-     * - 'DESC' - Descending order (newest to oldest)
-     *
      * @returns Array of semantic versions sorted according to specified ordering
      */
     ArvoContract.prototype.getSortedVersionNumbers = function (ordering) {
@@ -153,51 +185,48 @@ var ArvoContract = /** @class */ (function () {
     /**
      * Exports the ArvoContract instance as a plain object conforming to the IArvoContract interface.
      * This method can be used to serialize the contract or to create a new instance with the same parameters.
-     *
-     * @returns An object representing the contract, including its URI, accepts, and emits properties.
      */
     ArvoContract.prototype.export = function () {
         return {
             uri: this._uri,
             type: this._type,
-            description: this.description,
+            description: this._description,
             versions: this._versions,
+            metadata: this._metadata,
         };
     };
     /**
      * Converts the ArvoContract instance to a JSON Schema representation.
      * This method provides a way to represent the contract's structure and validation rules
      * in a format that conforms to the JSON Schema specification.
-     *
-     * @returns An object representing the contract in JSON Schema format:
      */
     ArvoContract.prototype.toJsonSchema = function () {
         var _this = this;
-        return {
-            uri: this._uri,
-            description: this.description,
-            versions: Object.entries(this._versions).map(function (_a) {
-                var version = _a[0], contract = _a[1];
-                return ({
-                    version: version,
-                    accepts: {
-                        type: _this._type,
-                        schema: (0, zod_to_json_schema_1.zodToJsonSchema)(contract.accepts),
-                    },
-                    systemError: {
-                        type: _this.systemError.type,
-                        schema: (0, zod_to_json_schema_1.zodToJsonSchema)(_this.systemError.schema),
-                    },
-                    emits: Object.entries(contract.emits).map(function (_a) {
-                        var key = _a[0], value = _a[1];
-                        return ({
-                            type: key,
-                            schema: (0, zod_to_json_schema_1.zodToJsonSchema)(value),
-                        });
-                    }),
-                });
-            }),
-        };
+        try {
+            return {
+                uri: this._uri,
+                description: this._description,
+                metadata: this._metadata,
+                versions: Object.keys(this._versions).map(function (version) {
+                    var jsonSchema = _this.version(version).toJsonSchema();
+                    return {
+                        version: jsonSchema.version,
+                        accepts: jsonSchema.accepts,
+                        systemError: jsonSchema.systemError,
+                        emits: jsonSchema.emits,
+                        metadata: jsonSchema.metadata,
+                    };
+                }),
+            };
+        }
+        catch (e) {
+            var errorMessage = "ArvoContract.toJsonSchema failed: ".concat(e.message);
+            (0, OpenTelemetry_1.logToSpan)({
+                level: 'ERROR',
+                message: errorMessage,
+            });
+            throw new Error(errorMessage);
+        }
     };
     return ArvoContract;
 }());

package/dist/ArvoContract/types.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import zodToJsonSchema from 'zod-to-json-schema';
 import { ArvoSemanticVersion } from '../types';
+import { VersionedArvoContractJSONSchema } from './VersionedArvoContract/types';
 /**
  * Represents a record in an Arvo contract, containing a type identifier and its validation schema.
  *
@@ -13,12 +13,19 @@ export type ArvoContractRecord<TType extends string = string, TSchema extends z.
     /** The Zod schema used for validating data associated with this record */
     schema: TSchema;
 };
+/**
+ * Utility type that resolves the inferred TypeScript type from an ArvoContractRecord's schema.
+ *
+ * @template T - The ArvoContractRecord whose schema type should be inferred
+ */
+export type ResolveArvoContractRecord<T extends ArvoContractRecord> = z.infer<T['schema']>;
 /**
  * Defines the structure of an Arvo contract, including its identifier, type, and versioned schemas.
  *
  * @template TUri - The unique URI identifier for the contract
  * @template TType - The event type that the contract's handler accepts
  * @template TVersions - A record of versioned schemas, mapping semantic versions to their accept/emit schemas
+ * @template TMetaData - Optional metadata type
  */
 export interface IArvoContract<TUri extends string = string, TType extends string = string, TVersions extends Record<ArvoSemanticVersion, {
     accepts: z.ZodTypeAny;
@@ -26,55 +33,25 @@ export interface IArvoContract<TUri extends string = string, TType extends strin
 }> = Record<ArvoSemanticVersion, {
     accepts: z.ZodTypeAny;
     emits: Record<string, z.ZodTypeAny>;
-}>> {
+}>, TMetaData extends Record<string, any> = Record<string, any>> {
     /** The unique URI identifier for this contract */
     uri: TUri;
     /** The event type that this contract's handler accepts */
     type: TType;
     /** Optional description providing context about the contract or its handler */
-    description?: string | null;
+    description: string | null;
+    /** The contract metadata */
+    metadata: TMetaData;
     /** A record mapping semantic versions to their corresponding schemas */
     versions: TVersions;
 }
-/**
- * Utility type that resolves the inferred TypeScript type from an ArvoContractRecord's schema.
- *
- * @template T - The ArvoContractRecord whose schema type should be inferred
- */
-export type ResolveArvoContractRecord<T extends ArvoContractRecord> = z.infer<T['schema']>;
 /**
  * Represents the JSON Schema representation of an ArvoContract, used for serialization
  * and documentation purposes. This structure follows the JSON Schema specification.
  */
 export type ArvoContractJSONSchema = {
-    /** The unique URI identifier for the contract */
     uri: string;
-    /** The human-readable description of the contract */
     description: string | null;
-    /** Array of versioned schemas for this contract */
-    versions: {
-        /** The semantic version identifier for this schema version */
-        version: ArvoSemanticVersion;
-        /** The schema for accepted inputs in this version */
-        accepts: {
-            /** The type identifier for accepted inputs */
-            type: string;
-            /** JSON Schema representation of the input validation schema */
-            schema: ReturnType<typeof zodToJsonSchema>;
-        };
-        /** The system error event */
-        systemError: {
-            /** The type of the event */
-            type: string;
-            /** The schema of the error */
-            schema: ReturnType<typeof zodToJsonSchema>;
-        };
-        /** Array of schemas for events that can be emitted in this version */
-        emits: {
-            /** The type identifier for the emitted event */
-            type: string;
-            /** JSON Schema representation of the event validation schema */
-            schema: ReturnType<typeof zodToJsonSchema>;
-        }[];
-    }[];
+    metadata: Record<string, any> | null;
+    versions: Omit<VersionedArvoContractJSONSchema, 'uri' | 'description'>[];
 };