arvo-core 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [1.0.0] - 2024-08-31
+
+- Finalised the first release version of the core. This contains core class such as ArvoEvent, ArvoContract, and ArvoContractLibrary. Moreover, this release contains utility functions for string manipulation, validation and OpenTelemetry

package/LICENSE.md

@@ -0,0 +1,7 @@
+The MIT License (MIT)
+Copyright (c) 2024 Saad Ahmad
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+---
+title: ArvoEvent
+group: Guides
+---
+
+# Arvo
+
+## What is Arvo
+
+Arvo is an opinionated approach to building event-driven systems. It's designed as a pattern and methodology rather than a rigid framework.
+
+## Principal
+
+The core principle of Arvo is to provide a solid foundation with enough flexibility for customization, allowing you to impose your own technical posture, including security measures, event brokerage, and telemetry. While Arvo offers a structured approach, it encourages developers to implement their own solutions if they believe they can improve upon or diverge from Arvo's principles.
+
+If you're looking to focus on results without getting bogged down in the nitty-gritty of event creation, handling, system state management, and telemetry, while also avoiding vendor lock-in, Arvo provides an excellent starting point. I believe, it strikes a balance between opinionated design and customization, making it an ideal choice for developers who want a head start in building event-driven systems without sacrificing flexibility.
+
+Key features of Arvo include:
+
+- Lightweight and unopinionated core
+- Extensible architecture
+- Cloud-agnostic design
+- Built-in primitives for event-driven patterns
+- Easy integration with existing systems and tools
+
+Whether you're building a small microservice or a large-scale distributed system, my hope with Arvo is to offers you some of the tools and patterns to help you succeed in the world of event-driven architecture.
+
+# Arvo - Core
+
+This core package defines primitive types and utility functions to help you quickly start building interesting and robust event-driven applications.
+
+At its core, Arvo has only two main data structures:
+
+## Components
+
+- [ArvoEvent](src/ArvoEvent/README.md) aims to provide a extendible variant of the open-source CloudEvent spec-ed object to define all the event in the system.
+- [ArvoContract](src/ArvoContract/README.md) is a basic class to define and impose contracts between services, ensuring trust in decoupled systems during build and development.
+- [ArvoContractLibrary](src/ArvoContractLibrary/README.md) is a utility class designed to manage and access multiple ArvoContract instances efficiently.
+
+## Utilities
+
+The package also includes utility functions for:
+
+- Creating ArvoEvents
+- Integrating with OpenTelemetry
+- TypeScript types for core components

package/dist/ArvoContract/helpers.d.ts

@@ -0,0 +1,15 @@
+import { IArvoContract } from './types';
+import ArvoContract from '.';
+import { TelemetryContext } from '../OpenTelemetry/types';
+/**
+ * Infers the ArvoContract type from a given IArvoContract.
+ */
+export type InferArvoContract<T> = T extends IArvoContract<infer U, infer V, infer W> ? ArvoContract<U, V, W> : never;
+/**
+ * Creates an ArvoContract instance from the given contract specification.
+ * @template TContract - The type of the contract specification.
+ * @param {TContract} contractSpec - The contract specification.
+ * @param {TelemetryContext} [telemetry] - Optional telemetry context for tracing.
+ * @returns {InferArvoContract<TContract>} The created ArvoContract instance.
+ */
+export declare const createArvoContract: <const TContract extends IArvoContract>(contract: TContract, telemetry?: TelemetryContext) => InferArvoContract<TContract>;

package/dist/ArvoContract/helpers.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArvoContract = void 0;
+var _1 = __importDefault(require("."));
+var OpenTelemetry_1 = require("../OpenTelemetry");
+/**
+ * Creates an ArvoContract instance from the given contract specification.
+ * @template TContract - The type of the contract specification.
+ * @param {TContract} contractSpec - The contract specification.
+ * @param {TelemetryContext} [telemetry] - Optional telemetry context for tracing.
+ * @returns {InferArvoContract<TContract>} The created ArvoContract instance.
+ */
+var createArvoContract = function (contract, telemetry) {
+    return (0, OpenTelemetry_1.createOtelSpan)(telemetry || 'Arvo Contract Creator', 'Create ArvoContract', {}, function () { return new _1.default(contract); });
+};
+exports.createArvoContract = createArvoContract;

package/dist/ArvoContract/index.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { ArvoContractRecord, IArvoContract } from './types';
+/**
+ * Extracts the event type from a given type T.
+ * @template T - The type to extract the event type from.
+ */
+type ExtractEventType<T> = T extends {
+    type: infer U;
+} ? U : never;
+/**
+ * ArvoContract class represents a contract with defined input and output schemas.
+ * It provides methods for validating inputs and outputs based on the contract's specifications.
+ *
+ * @template T - The URI type.
+ * @template TAccepts - The accepted record type.
+ * @template TEmits - The emitted record type.
+ */
+export default class ArvoContract<T extends string = string, TAccepts extends ArvoContractRecord = ArvoContractRecord, TEmits extends ArvoContractRecord = ArvoContractRecord> {
+    private readonly _uri;
+    private readonly _accepts;
+    private readonly _emits;
+    /**
+     * Creates an instance of ArvoContract.
+     * @param {IArvoContract<T, TAccepts, TEmits>} params - The contract parameters.
+     */
+    constructor(params: IArvoContract<T, TAccepts, TEmits>);
+    get uri(): T;
+    get accepts(): Readonly<TAccepts>;
+    /**
+     * Gets all emitted event types and schemas as a readonly record.
+     * Use this when you need to access all emitted events at once.
+     */
+    get emits(): Readonly<Record<ExtractEventType<TEmits>, TEmits>>;
+    /**
+     * Gets a specific emitted event type and schema.
+     * Use this when you need to access a single emitted event by its type.
+     * @template U - The type of the emit record to retrieve.
+     * @param {U} type - The type of the emit record.
+     * @returns {Readonly<Extract<TEmits, { type: U }>>} The emit record.
+     * @throws {Error} If the emit type is not found in the contract.
+     */
+    getEmit<U extends ExtractEventType<TEmits>>(type: U): Readonly<Extract<TEmits, {
+        type: U;
+    }>>;
+    /**
+     * Validates the input against the contract's accept schema.
+     * @template U - The type of the input to validate.
+     * @param {TAccepts['type']} type - The type of the input.
+     * @param {U} input - The input to validate.
+     * @returns {z.SafeParseReturnType<U, z.infer<TAccepts['schema']>>} The validation result.
+     * @throws {Error} If the accept type is not found in the contract.
+     */
+    validateInput<U>(type: TAccepts['type'], input: U): z.SafeParseReturnType<U, z.infer<TAccepts['schema']>>;
+    /**
+     * Validates the output against the contract's emit schema.
+     * @template U - The type of the output to validate.
+     * @param {U} type - The type of the output.
+     * @param {unknown} output - The output to validate.
+     * @returns {z.SafeParseReturnType<unknown, z.infer<Extract<TEmits, { type: U }>['schema']>>} The validation result.
+     * @throws {Error} If the emit type is not found in the contract.
+     */
+    validateOutput<U extends ExtractEventType<TEmits>>(type: U, output: unknown): z.SafeParseReturnType<unknown, z.infer<Extract<TEmits, {
+        type: U;
+    }>['schema']>>;
+    /**
+     * Validates the accepts record.
+     * @param {TAccepts} accepts - The accepts record to validate.
+     * @returns {TAccepts} The validated accepts record.
+     * @private
+     */
+    private validateAccepts;
+    /**
+     * Validates the emits records.
+     * @param {TEmits[]} emits - The emits records to validate.
+     * @returns {ReadonlyArray<TEmits>} The validated emits records.
+     * @private
+     */
+    private validateEmits;
+}
+export {};

package/dist/ArvoContract/index.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var validators_1 = require("./validators");
+/**
+ * ArvoContract class represents a contract with defined input and output schemas.
+ * It provides methods for validating inputs and outputs based on the contract's specifications.
+ *
+ * @template T - The URI type.
+ * @template TAccepts - The accepted record type.
+ * @template TEmits - The emitted record type.
+ */
+var ArvoContract = /** @class */ (function () {
+    /**
+     * Creates an instance of ArvoContract.
+     * @param {IArvoContract<T, TAccepts, TEmits>} params - The contract parameters.
+     */
+    function ArvoContract(params) {
+        this._uri = validators_1.ArvoContractValidators.contract.uri.parse(params.uri);
+        this._accepts = this.validateAccepts(params.accepts);
+        this._emits = this.validateEmits(params.emits);
+        Object.freeze(this);
+    }
+    Object.defineProperty(ArvoContract.prototype, "uri", {
+        get: function () {
+            return this._uri;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ArvoContract.prototype, "accepts", {
+        get: function () {
+            return this._accepts;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ArvoContract.prototype, "emits", {
+        /**
+         * Gets all emitted event types and schemas as a readonly record.
+         * Use this when you need to access all emitted events at once.
+         */
+        get: function () {
+            return Object.freeze(this._emits.reduce(function (acc, emit) {
+                // @ts-ignore
+                acc[emit.type] = emit;
+                return acc;
+            }, {}));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Gets a specific emitted event type and schema.
+     * Use this when you need to access a single emitted event by its type.
+     * @template U - The type of the emit record to retrieve.
+     * @param {U} type - The type of the emit record.
+     * @returns {Readonly<Extract<TEmits, { type: U }>>} The emit record.
+     * @throws {Error} If the emit type is not found in the contract.
+     */
+    ArvoContract.prototype.getEmit = function (type) {
+        var emit = this._emits.find(function (item) { return item.type === type; });
+        if (!emit) {
+            throw new Error("Emit type \"".concat(type, "\" not found in contract"));
+        }
+        return emit;
+    };
+    /**
+     * Validates the input against the contract's accept schema.
+     * @template U - The type of the input to validate.
+     * @param {TAccepts['type']} type - The type of the input.
+     * @param {U} input - The input to validate.
+     * @returns {z.SafeParseReturnType<U, z.infer<TAccepts['schema']>>} The validation result.
+     * @throws {Error} If the accept type is not found in the contract.
+     */
+    ArvoContract.prototype.validateInput = function (type, input) {
+        if (type !== this._accepts.type) {
+            throw new Error("Accept type \"".concat(type, "\" not found in contract"));
+        }
+        return this._accepts.schema.safeParse(input);
+    };
+    /**
+     * Validates the output against the contract's emit schema.
+     * @template U - The type of the output to validate.
+     * @param {U} type - The type of the output.
+     * @param {unknown} output - The output to validate.
+     * @returns {z.SafeParseReturnType<unknown, z.infer<Extract<TEmits, { type: U }>['schema']>>} The validation result.
+     * @throws {Error} If the emit type is not found in the contract.
+     */
+    ArvoContract.prototype.validateOutput = function (type, output) {
+        var emit = this.emits[type];
+        if (!emit) {
+            throw new Error("Emit type \"".concat(type, "\" not found in contract"));
+        }
+        return emit.schema.safeParse(output);
+    };
+    /**
+     * Validates the accepts record.
+     * @param {TAccepts} accepts - The accepts record to validate.
+     * @returns {TAccepts} The validated accepts record.
+     * @private
+     */
+    ArvoContract.prototype.validateAccepts = function (accepts) {
+        return {
+            type: validators_1.ArvoContractValidators.record.type.parse(accepts.type),
+            schema: accepts.schema,
+        };
+    };
+    /**
+     * Validates the emits records.
+     * @param {TEmits[]} emits - The emits records to validate.
+     * @returns {ReadonlyArray<TEmits>} The validated emits records.
+     * @private
+     */
+    ArvoContract.prototype.validateEmits = function (emits) {
+        return Object.freeze(emits.map(function (item) { return ({
+            type: validators_1.ArvoContractValidators.record.type.parse(item.type),
+            schema: item.schema,
+        }); }));
+    };
+    return ArvoContract;
+}());
+exports.default = ArvoContract;

package/dist/ArvoContract/types.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+/**
+ * Represents a record in an Arvo contract.
+ * @template TType - The type of the record, defaults to string.
+ * @template TSchema - The Zod schema for the record, defaults to any Zod type.
+ */
+export type ArvoContractRecord<TType extends string = string, TSchema extends z.ZodTypeAny = z.ZodTypeAny> = {
+    /** The type identifier for the record */
+    type: TType;
+    /** The Zod schema used for validating the record */
+    schema: TSchema;
+};
+/**
+ * Interface for an Arvo contract.
+ * @template TUri - The URI type, defaults to string.
+ * @template TAccepts - The type of record the contract accepts, defaults to ArvoContractRecord.
+ * @template TEmits - The type of record the contract emits, defaults to ArvoContractRecord.
+ */
+export interface IArvoContract<TUri extends string = string, TAccepts extends ArvoContractRecord = ArvoContractRecord, TEmits extends ArvoContractRecord = ArvoContractRecord> {
+    /** The unique identifier for the contract */
+    uri: TUri;
+    /** The record type that the contract accepts */
+    accepts: TAccepts;
+    /** An array of record types that the contract can emit */
+    emits: TEmits[];
+}
+/**
+ * Resolves the inferred type of an ArvoContractRecord's schema.
+ * @template T - The ArvoContractRecord to resolve.
+ */
+export type ResolveArvoContractRecord<T extends ArvoContractRecord> = z.infer<T['schema']>;

package/dist/ArvoContract/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ArvoContract/validators.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const ArvoContractValidators: {
+    contract: {
+        uri: z.ZodEffects<z.ZodString, string, string>;
+    };
+    record: {
+        type: z.ZodString;
+    };
+};

package/dist/ArvoContract/validators.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArvoContractValidators = void 0;
+var zod_1 = require("zod");
+var utils_1 = require("../utils");
+exports.ArvoContractValidators = {
+    contract: {
+        uri: zod_1.z
+            .string()
+            .min(1, 'URI must be a non-empty string')
+            .refine(utils_1.validateURI, 'The URI must a valid URI string')
+            .describe((0, utils_1.cleanString)("\n      The addressable unique URI of the contract so that\n      it can be located and address for reference during\n      operations\n    ")),
+    },
+    record: {
+        type: zod_1.z
+            .string()
+            .min(1, 'Type must be a non-empty string')
+            .regex(/^[a-z0-9]+(\.[a-z0-9]+)+\.[a-z0-9]+$/, 'Type should be prefixed with a reverse-DNS name')
+            .describe((0, utils_1.cleanString)("\n        The type of event related to the originating occurrence.\n        Should be prefixed with a reverse-DNS name.\n      ")),
+    },
+};

package/dist/ArvoEvent/helpers.d.ts

@@ -0,0 +1,40 @@
+import ArvoEvent from '.';
+import { TelemetryContext } from '../OpenTelemetry/types';
+import { ArvoEventData, CloudEventExtension, CreateArvoEvent } from './types';
+/**
+ * Creates an ArvoEvent with the provided data and extensions.
+ *
+ * This function creates a new ArvoEvent instance using the provided event data and optional extensions.
+ * It also supports OpenTelemetry tracing if a telemetry context is provided.
+ *
+ * @template TData - The type of the event data, extending ArvoEventData.
+ * @template TExtension - The type of the cloud event extension, extending CloudEventExtension.
+ *
+ * @param {CreateArvoEvent<TData>} event - The event data and metadata to create the ArvoEvent.
+ * @param {TExtension} [extensions] - Optional cloud event extensions.
+ * @param {TelemetryContext} [telemetry] - Optional telemetry context for tracing.
+ *
+ * @returns {ArvoEvent<TData, TExtension>} The created ArvoEvent instance.
+ *
+ * @throws {Error} If there's an error during the creation process.
+ *
+ * @remarks
+ * - If no `id` is provided in the event object, a UUID v4 will be generated.
+ * - If no `time` is provided, the current timestamp will be used.
+ * - If no `datacontenttype` is provided, it defaults to `application/cloudevents+json;charset=UTF-8;profile=arvo`.
+ * - If a non-compatible `datacontenttype` is provided, a warning will be logged to the span.
+ * - The `source`, `subject`, `to`, `redirectto`, and `dataschema` fields are URI-encoded.
+ *
+ * @example
+ * const event = createArvoEvent(
+ *   {
+ *     type: 'com.example.event',
+ *     source: '/example/source',
+ *     subject: 'example-subject',
+ *     data: { key: 'value' }
+ *   },
+ *   { customExtension: 'value' },
+ *   telemetryContext
+ * );
+ */
+export declare const createArvoEvent: <TData extends ArvoEventData, TExtension extends CloudEventExtension>(event: CreateArvoEvent<TData>, extensions?: TExtension, telemetry?: TelemetryContext) => ArvoEvent<TData, TExtension>;

package/dist/ArvoEvent/helpers.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArvoEvent = void 0;
+var _1 = __importDefault(require("."));
+var OpenTelemetry_1 = require("../OpenTelemetry");
+var utils_1 = require("../utils");
+var schema_1 = require("./schema");
+var uuid_1 = require("uuid");
+/**
+ * Creates an ArvoEvent with the provided data and extensions.
+ *
+ * This function creates a new ArvoEvent instance using the provided event data and optional extensions.
+ * It also supports OpenTelemetry tracing if a telemetry context is provided.
+ *
+ * @template TData - The type of the event data, extending ArvoEventData.
+ * @template TExtension - The type of the cloud event extension, extending CloudEventExtension.
+ *
+ * @param {CreateArvoEvent<TData>} event - The event data and metadata to create the ArvoEvent.
+ * @param {TExtension} [extensions] - Optional cloud event extensions.
+ * @param {TelemetryContext} [telemetry] - Optional telemetry context for tracing.
+ *
+ * @returns {ArvoEvent<TData, TExtension>} The created ArvoEvent instance.
+ *
+ * @throws {Error} If there's an error during the creation process.
+ *
+ * @remarks
+ * - If no `id` is provided in the event object, a UUID v4 will be generated.
+ * - If no `time` is provided, the current timestamp will be used.
+ * - If no `datacontenttype` is provided, it defaults to `application/cloudevents+json;charset=UTF-8;profile=arvo`.
+ * - If a non-compatible `datacontenttype` is provided, a warning will be logged to the span.
+ * - The `source`, `subject`, `to`, `redirectto`, and `dataschema` fields are URI-encoded.
+ *
+ * @example
+ * const event = createArvoEvent(
+ *   {
+ *     type: 'com.example.event',
+ *     source: '/example/source',
+ *     subject: 'example-subject',
+ *     data: { key: 'value' }
+ *   },
+ *   { customExtension: 'value' },
+ *   telemetryContext
+ * );
+ */
+var createArvoEvent = function (event, extensions, telemetry) {
+    return (0, OpenTelemetry_1.createOtelSpan)(telemetry || 'ArvoEvent Creation Tracer', 'Create ArvoEvent', {}, function (span) {
+        if (event.datacontenttype &&
+            event.datacontenttype !== schema_1.ArvoDataContentType) {
+            var warning = (0, utils_1.cleanString)("\n        Warning! The provided datacontenttype(=".concat(event.datacontenttype, ")\n        is not ArvoEvent compatible (=").concat(schema_1.ArvoDataContentType, "). There may \n        be some limited functionality.\n      "));
+            (0, OpenTelemetry_1.logToSpan)(span, {
+                level: 'WARNING',
+                message: warning,
+            });
+        }
+        return new _1.default({
+            id: event.id || (0, uuid_1.v4)(),
+            type: event.type,
+            accesscontrol: event.accesscontrol || null,
+            executionunits: event.executionunits || null,
+            traceparent: event.traceparent || null,
+            tracestate: event.tracestate || null,
+            datacontenttype: event.datacontenttype || schema_1.ArvoDataContentType,
+            specversion: event.specversion || '1.0',
+            time: event.time || (0, utils_1.createTimestamp)(),
+            source: encodeURI(event.source),
+            subject: encodeURI(event.subject),
+            to: event.to ? encodeURI(event.to) : null,
+            redirectto: event.redirectto ? encodeURI(event.redirectto) : null,
+            dataschema: event.dataschema ? encodeURI(event.dataschema) : null,
+        }, event.data, extensions);
+    });
+};
+exports.createArvoEvent = createArvoEvent;

package/dist/ArvoEvent/index.d.ts

@@ -0,0 +1,88 @@
+import { ArvoEventData, ArvoExtension, CloudEventContext, CloudEventExtension, OpenTelemetryExtension } from './types';
+/**
+ * Represents an ArvoEvent, which extends the CloudEvent specification.
+ * @template TData - The type of the event data, extending ArvoEventData.
+ * @template TExtension - The type of additional extensions, extending CloudEventExtension.
+ */
+export default class ArvoEvent<TData extends ArvoEventData = ArvoEventData, TExtension extends CloudEventExtension = CloudEventExtension> {
+    readonly id: string;
+    readonly source: string;
+    readonly specversion: string;
+    readonly type: string;
+    readonly subject: string;
+    readonly datacontenttype: string;
+    readonly dataschema: string | null;
+    readonly data: TData;
+    readonly time: string;
+    extensions: TExtension & ArvoExtension & OpenTelemetryExtension;
+    /**
+     * Creates an instance of ArvoEvent.
+     * @param context - The CloudEvent context along with Arvo and OpenTelemetry extensions.
+     * @param data - The event data.
+     * @param extensions - Optional additional extensions.
+     */
+    constructor(context: CloudEventContext & ArvoExtension & OpenTelemetryExtension, data: TData, extensions?: TExtension);
+    /**
+     * Gets the CloudEvent-specified default fields and extensions.
+     * @returns An object containing the base CloudEvent default fields and extensions.
+     * `default` fields are the standard CloudEvents attributes, which include:
+     * `extension` fields are additional attributes that provide extra context or functionality:
+     * - ArvoExtension: Arvo-specific extensions (to, accesscontrol, redirectto, executionunits)
+     * - OpenTelemetryExtension: OpenTelemetry-specific extensions (traceparent, tracestate)
+     * - TExtension: Any additional custom extensions
+     */
+    get cloudevent(): {
+        default: {
+            id: string;
+            source: string;
+            specversion: string;
+            type: string;
+            subject: string;
+            datacontenttype: string;
+            dataschema: string | null;
+            data: TData;
+            time: string;
+        };
+        extensions: TExtension & {
+            to: string | null;
+            accesscontrol: string | null;
+            redirectto: string | null;
+            executionunits: number | null;
+        } & {
+            traceparent: string | null;
+            tracestate: string | null;
+        };
+    };
+    /**
+     * Converts the ArvoEvent to a JSON-serializable object.
+     * @returns A plain object representation of the ArvoEvent.
+     */
+    toJSON(): Record<string, any>;
+    /**
+     * Converts the ArvoEvent to a JSON string.
+     * @param [spacing=0] - The number of spaces to use for indentation in the resulting JSON string.
+     * @returns A JSON string representation of the ArvoEvent.
+     */
+    toString(spacing?: number): string;
+    /**
+     * Gets OpenTelemetry attributes derived from the ArvoEvent.
+     * @returns An object containing OpenTelemetry attributes.
+     * The OpenTelemetry attributes for CloudEvents is as per
+     * the spec provided [here](https://opentelemetry.io/docs/specs/semconv/attributes-registry/cloudevents/)
+     * Additionally, the Arvo extension attributed are also returned
+     * as `cloudevents.arvo.event_*` fields
+     */
+    get otelAttributes(): {
+        'cloudevents.event_id': string;
+        'cloudevents.event_source': string;
+        'cloudevents.event_spec_version': string;
+        'cloudevents.event_subject': string;
+        'cloudevents.event_type': string;
+        'cloudevents.event_time': string;
+        'cloudevents.event_datacontenttype': string;
+        'cloudevents.event_dataschema': string;
+        'cloudevents.arvo.event_redirectto': string;
+        'cloudevents.arvo.event_to': string;
+        'cloudevents.arvo.event_executionunits': string | number;
+    };
+}