@cratis/event-models 0.0.0-stage → 0.105.6

package/dist/Messages/EventModelMessagesProvider.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { EventModelMessages } from './EventModelMessages';
+export interface EventModelMessagesProviderProps {
+    messages: EventModelMessages;
+    children?: React.ReactNode;
+}
+export declare const EventModelMessagesProvider: ({ messages, children }: EventModelMessagesProviderProps) => React.JSX.Element;

package/dist/Messages/defaultEventModelMessages.d.ts

@@ -0,0 +1,2 @@
+import type { EventModelMessages } from './EventModelMessages';
+export declare const defaultEventModelMessages: EventModelMessages;

package/dist/Messages/index.d.ts

@@ -0,0 +1,4 @@
+export * from './EventModelMessages';
+export * from './defaultEventModelMessages';
+export * from './EventModelMessagesContext';
+export * from './EventModelMessagesProvider';

package/dist/Model/Actor.d.ts

@@ -0,0 +1,9 @@
+import type { ActorType } from './ActorType';
+import type { PersonaReference } from './PersonaReference';
+export interface Actor {
+    id: string;
+    name: string;
+    actorType: ActorType;
+    description: string;
+    persona?: PersonaReference;
+}

package/dist/Model/ActorType.d.ts

@@ -0,0 +1,5 @@
+export declare enum ActorType {
+    UIRole = 0,
+    systemRole = 1,
+    chatRole = 2
+}

package/dist/Model/Assignee.d.ts

@@ -0,0 +1,8 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { AssigneeKind } from './AssigneeKind';
+export interface Assignee {
+    id: Guid;
+    name: string;
+    kind: AssigneeKind;
+    avatar?: string;
+}

package/dist/Model/AssigneeKind.d.ts

@@ -0,0 +1,5 @@
+export declare enum AssigneeKind {
+    system = "system",
+    agent = "agent",
+    user = "user"
+}

package/dist/Model/AutomationTrigger.d.ts

@@ -0,0 +1,9 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { AutomationTriggerSchedule } from './AutomationTriggerSchedule';
+import type { AutomationTriggerType } from './AutomationTriggerType';
+export interface AutomationTrigger {
+    type: AutomationTriggerType;
+    description: string;
+    schedule?: AutomationTriggerSchedule;
+    eventId?: Guid;
+}

package/dist/Model/AutomationTriggerSchedule.d.ts

@@ -0,0 +1,8 @@
+export interface AutomationTriggerSchedule {
+    intervalMinutes: number;
+    intervalHours: number;
+    timeOfDay: string;
+    dayOfWeek: number;
+    dayOfMonth: number;
+    description: string;
+}

package/dist/Model/AutomationTriggerType.d.ts

@@ -0,0 +1,6 @@
+export declare enum AutomationTriggerType {
+    timer = 0,
+    event = 1,
+    custom = 2,
+    none = 3
+}

package/dist/Model/CommandConcurrency.d.ts

@@ -0,0 +1,9 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { ConcurrencyBinding } from './ConcurrencyBinding';
+export interface CommandConcurrency {
+    scopeId?: Guid;
+    includeEventSource: boolean;
+    eventSourceType?: ConcurrencyBinding;
+    eventStreamType?: ConcurrencyBinding;
+    eventStreamId?: ConcurrencyBinding;
+}

package/dist/Model/CommandItem.d.ts

@@ -0,0 +1,13 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { JsonSchema } from '@cratis/components/types';
+import type { CommandConcurrency } from './CommandConcurrency';
+import type { CommandPropertyRules } from './CommandPropertyRules';
+export interface CommandItem {
+    id: Guid;
+    name: string;
+    schema: JsonSchema;
+    stateSchema: JsonSchema;
+    logicDescription: string;
+    rules?: CommandPropertyRules[];
+    concurrency?: CommandConcurrency;
+}

package/dist/Model/CommandPropertyRules.d.ts

@@ -0,0 +1,5 @@
+import type { CommandRule } from './CommandRule';
+export interface CommandPropertyRules {
+    propertyName: string;
+    rules: CommandRule[];
+}

package/dist/Model/CommandRule.d.ts

@@ -0,0 +1,4 @@
+export interface CommandRule {
+    errorMessage: string;
+    ruleType: string;
+}

package/dist/Model/ConcurrencyBinding.d.ts

@@ -0,0 +1,5 @@
+import type { ConcurrencyValueSource } from './ConcurrencyValueSource';
+export interface ConcurrencyBinding {
+    source: ConcurrencyValueSource;
+    value: string;
+}

package/dist/Model/ConcurrencyValueSource.d.ts

@@ -0,0 +1,5 @@
+export declare enum ConcurrencyValueSource {
+    notSet = 0,
+    value = 1,
+    commandProperty = 2
+}

package/dist/Model/EventConstraint.d.ts

@@ -0,0 +1,4 @@
+export interface EventConstraint {
+    name: string;
+    message: string;
+}

package/dist/Model/EventConstraints.d.ts

@@ -0,0 +1,5 @@
+import type { EventConstraint } from './EventConstraint';
+export interface EventConstraints {
+    unique?: EventConstraint;
+    uniqueEventType?: EventConstraint;
+}

package/dist/Model/EventItem.d.ts

@@ -0,0 +1,11 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { JsonSchema } from '@cratis/components/types';
+import type { EventConstraints } from './EventConstraints';
+export interface EventItem {
+    id: Guid;
+    name: string;
+    schema: JsonSchema;
+    sourceEventId?: string;
+    tags?: string[];
+    constraints?: EventConstraints;
+}

package/dist/Model/EventModel.d.ts

@@ -0,0 +1,11 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { ModuleCollection } from './ModuleCollection';
+import type { ModuleCollectionLink } from './ModuleCollectionLink';
+import type { StickyNote } from './StickyNote';
+export interface EventModel {
+    id: Guid;
+    name: string;
+    collections: ModuleCollection[];
+    stickyNotes: StickyNote[];
+    links: ModuleCollectionLink[];
+}

package/dist/Model/ExternalEventItem.d.ts

@@ -0,0 +1,6 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface ExternalEventItem {
+    id: Guid;
+    name: string;
+    sourceEventId: string;
+}

package/dist/Model/Feature.d.ts

@@ -0,0 +1,14 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { ScreenTemplate } from './ScreenTemplate';
+import type { Slice } from './Slice';
+export interface Feature {
+    id: Guid;
+    name: string;
+    subFeatures: Feature[];
+    slices: Slice[];
+    collapsed: boolean;
+    rowCollapsed: boolean;
+    enabled: boolean;
+    screenTemplate?: ScreenTemplate;
+    commentCount: number;
+}

package/dist/Model/Module.d.ts

@@ -0,0 +1,12 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { Feature } from './Feature';
+import type { ScreenTemplate } from './ScreenTemplate';
+export interface Module {
+    id: Guid;
+    name: string;
+    features: Feature[];
+    collapsed: boolean;
+    sortOrder: number;
+    screenTemplate?: ScreenTemplate;
+    commentCount: number;
+}

package/dist/Model/ModuleCollection.d.ts

@@ -0,0 +1,10 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { Actor } from './Actor';
+import type { Module } from './Module';
+import type { Position } from './Position';
+export interface ModuleCollection {
+    id: Guid;
+    position: Position;
+    modules: Module[];
+    actors: Actor[];
+}

package/dist/Model/ModuleCollectionLink.d.ts

@@ -0,0 +1,6 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface ModuleCollectionLink {
+    id: Guid;
+    sourceCollectionId: Guid;
+    targetCollectionId: Guid;
+}

package/dist/Model/PersonaReference.d.ts

@@ -0,0 +1,5 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface PersonaReference {
+    id: Guid;
+    name: string;
+}

package/dist/Model/Position.d.ts

@@ -0,0 +1,4 @@
+export interface Position {
+    x: number;
+    y: number;
+}

package/dist/Model/QueryItem.d.ts

@@ -0,0 +1,7 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { QueryParameter } from './QueryParameter';
+export interface QueryItem {
+    id: Guid;
+    name: string;
+    parameters: QueryParameter[];
+}

package/dist/Model/QueryParameter.d.ts

@@ -0,0 +1,5 @@
+import type { QueryParameterType } from './QueryParameterType';
+export interface QueryParameter {
+    name: string;
+    type: QueryParameterType;
+}

package/dist/Model/QueryParameterType.d.ts

@@ -0,0 +1,8 @@
+export declare enum QueryParameterType {
+    text = 0,
+    number = 1,
+    boolean = 2,
+    date = 3,
+    time = 4,
+    uniqueId = 5
+}

package/dist/Model/ReadModelItem.d.ts

@@ -0,0 +1,8 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { JsonSchema } from '@cratis/components/types';
+export interface ReadModelItem {
+    id: Guid;
+    name: string;
+    schema: JsonSchema;
+    materializes: boolean;
+}

package/dist/Model/ScreenTemplate.d.ts

@@ -0,0 +1,4 @@
+export interface ScreenTemplate {
+    id: string;
+    name: string;
+}

package/dist/Model/Slice.d.ts

@@ -0,0 +1,31 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { Assignee } from './Assignee';
+import type { AutomationTrigger } from './AutomationTrigger';
+import type { CommandItem } from './CommandItem';
+import type { EventItem } from './EventItem';
+import type { ExternalEventItem } from './ExternalEventItem';
+import type { QueryItem } from './QueryItem';
+import type { ReadModelItem } from './ReadModelItem';
+import type { SliceSpecification } from './SliceSpecification';
+import type { SliceStatus } from './SliceStatus';
+import type { SliceType } from './SliceType';
+import type { UserExperienceActor } from './UserExperienceActor';
+export interface Slice {
+    id: Guid;
+    name: string;
+    sliceType: SliceType;
+    description: string;
+    status: SliceStatus;
+    collapsed: boolean;
+    sortOrder: number;
+    command?: CommandItem;
+    readModel?: ReadModelItem;
+    externalEvents: ExternalEventItem[];
+    events: EventItem[];
+    queries: QueryItem[];
+    actors: UserExperienceActor[];
+    automationTrigger?: AutomationTrigger;
+    specifications: SliceSpecification[];
+    commentCount: number;
+    assignee?: Assignee;
+}

package/dist/Model/SliceSpecification.d.ts

@@ -0,0 +1,19 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { SpecificationCommand } from './SpecificationCommand';
+import type { SpecificationError } from './SpecificationError';
+import type { SpecificationGivenEvent } from './SpecificationGivenEvent';
+import type { SpecificationReadModel } from './SpecificationReadModel';
+import type { SpecificationRunOutcome } from './SpecificationRunOutcome';
+import type { SpecificationThenEvent } from './SpecificationThenEvent';
+export interface SliceSpecification {
+    id: Guid;
+    name: string;
+    given: SpecificationGivenEvent[];
+    when?: SpecificationCommand;
+    givenReadModel?: SpecificationReadModel;
+    thenEvents: SpecificationThenEvent[];
+    thenErrors: SpecificationError[];
+    collapsed: boolean;
+    lastRunOutcome?: SpecificationRunOutcome;
+    lastRunMessage?: string;
+}

package/dist/Model/SliceStatus.d.ts

@@ -0,0 +1,9 @@
+export declare enum SliceStatus {
+    notStarted = 0,
+    draft = 1,
+    readyForImplementation = 2,
+    inProgress = 3,
+    readyForReview = 4,
+    done = 5,
+    analysis = 6
+}

package/dist/Model/SliceType.d.ts

@@ -0,0 +1,6 @@
+export declare enum SliceType {
+    stateChange = 0,
+    stateView = 1,
+    automation = 2,
+    translator = 3
+}

package/dist/Model/SpecificationCommand.d.ts

@@ -0,0 +1,7 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface SpecificationCommand {
+    id: Guid;
+    commandId?: Guid;
+    name: string;
+    values: Record<string, unknown>;
+}

package/dist/Model/SpecificationError.d.ts

@@ -0,0 +1,7 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { SpecificationErrorRuleReference } from './SpecificationErrorRuleReference';
+export interface SpecificationError {
+    id: Guid;
+    name: string;
+    reference?: SpecificationErrorRuleReference;
+}

package/dist/Model/SpecificationErrorRuleKind.d.ts

@@ -0,0 +1,5 @@
+export declare enum SpecificationErrorRuleKind {
+    commandValidationRule = 0,
+    eventUniqueConstraint = 1,
+    eventUniqueEventTypeConstraint = 2
+}

package/dist/Model/SpecificationErrorRuleReference.d.ts

@@ -0,0 +1,8 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { SpecificationErrorRuleKind } from './SpecificationErrorRuleKind';
+export interface SpecificationErrorRuleReference {
+    kind: SpecificationErrorRuleKind;
+    itemId: Guid;
+    propertyName: string;
+    ruleType: string;
+}

package/dist/Model/SpecificationGivenEvent.d.ts

@@ -0,0 +1,7 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface SpecificationGivenEvent {
+    id: Guid;
+    name: string;
+    eventId: Guid;
+    values: Record<string, unknown>;
+}

package/dist/Model/SpecificationReadModel.d.ts

@@ -0,0 +1,6 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface SpecificationReadModel {
+    id: Guid;
+    readModelItemId: Guid;
+    name: string;
+}

package/dist/Model/SpecificationRunOutcome.d.ts

@@ -0,0 +1,5 @@
+export declare enum SpecificationRunOutcome {
+    passed = 0,
+    failed = 1,
+    inconclusive = 2
+}

package/dist/Model/SpecificationThenEvent.d.ts

@@ -0,0 +1,7 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface SpecificationThenEvent {
+    id: Guid;
+    name: string;
+    eventId: Guid;
+    values: Record<string, unknown>;
+}

package/dist/Model/StickyNote.d.ts

@@ -0,0 +1,8 @@
+import type { Position } from './Position';
+export interface StickyNote {
+    id: string;
+    position: Position;
+    width: number;
+    height: number;
+    text: string;
+}

package/dist/Model/UserExperienceActor.d.ts

@@ -0,0 +1,10 @@
+import type { PrototypeLayout, UIElement } from '@cratis/scene';
+import type { ActorType } from './ActorType';
+export interface UserExperienceActor {
+    id: string;
+    type: ActorType;
+    elements: UIElement[];
+    layout: PrototypeLayout;
+    windowWidth: number;
+    windowHeight: number;
+}

package/dist/Model/index.d.ts

@@ -0,0 +1,43 @@
+export * from './Actor';
+export * from './ActorType';
+export * from './Assignee';
+export * from './AssigneeKind';
+export * from './AutomationTrigger';
+export * from './AutomationTriggerSchedule';
+export * from './AutomationTriggerType';
+export * from './CommandConcurrency';
+export * from './CommandItem';
+export * from './CommandPropertyRules';
+export * from './CommandRule';
+export * from './ConcurrencyBinding';
+export * from './ConcurrencyValueSource';
+export * from './EventConstraint';
+export * from './EventConstraints';
+export * from './EventItem';
+export * from './EventModel';
+export * from './ExternalEventItem';
+export * from './Feature';
+export * from './Module';
+export * from './ModuleCollection';
+export * from './ModuleCollectionLink';
+export * from './PersonaReference';
+export * from './Position';
+export * from './QueryItem';
+export * from './QueryParameter';
+export * from './QueryParameterType';
+export * from './ReadModelItem';
+export * from './ScreenTemplate';
+export * from './Slice';
+export * from './SliceSpecification';
+export * from './SliceStatus';
+export * from './SliceType';
+export * from './SpecificationCommand';
+export * from './SpecificationError';
+export * from './SpecificationErrorRuleKind';
+export * from './SpecificationErrorRuleReference';
+export * from './SpecificationGivenEvent';
+export * from './SpecificationReadModel';
+export * from './SpecificationRunOutcome';
+export * from './SpecificationThenEvent';
+export * from './StickyNote';
+export * from './UserExperienceActor';

package/dist/Modules/ModuleColumnFrame.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode, Ref } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+export interface ModuleColumnFrameProps {
+    moduleId: Guid;
+    collectionId?: Guid;
+    marginLeft: number;
+    dragging?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    children?: ReactNode;
+}
+export declare const ModuleColumnFrame: ({ moduleId, collectionId, marginLeft, dragging, ref, children }: ModuleColumnFrameProps) => import("react").JSX.Element;

package/dist/Modules/ModuleDropIndicator.d.ts

@@ -0,0 +1 @@
+export declare const ModuleDropIndicator: () => import("react").JSX.Element;

package/dist/Modules/ModuleHeader.d.ts

@@ -0,0 +1,20 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceStatus } from '../Model';
+import { type HeaderDragStart } from '../HeaderDragging';
+export interface ModuleHeaderProps {
+    moduleId: Guid;
+    name: string;
+    height: number;
+    collapsed: boolean;
+    onToggleCollapse?: () => void;
+    onAddModule?: () => void;
+    onAddFeature?: () => void;
+    onRenamed?: (moduleId: Guid, name: string) => void;
+    validateName?: (name: string) => string | undefined;
+    status?: SliceStatus;
+    detailsVisible?: boolean;
+    onToggleDetails?: () => void;
+    onDragStart?: (start: HeaderDragStart) => void;
+    error?: string;
+}
+export declare const ModuleHeader: ({ moduleId, name, height, collapsed, onToggleCollapse, onAddModule, onAddFeature, onRenamed, validateName, status, detailsVisible, onToggleDetails, onDragStart, error, }: ModuleHeaderProps) => import("react").JSX.Element;

package/dist/Modules/ModuleHeaderAction.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+export interface ModuleHeaderAction {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    description?: string;
+    disabled?: boolean;
+    tooltip?: string;
+    indicator?: boolean;
+    isSeparator?: boolean;
+    items?: readonly ModuleHeaderAction[];
+    onActivate: (moduleId: Guid, host: DOMRect) => void;
+}

package/dist/Modules/ModuleHeaderCell.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export interface ModuleHeaderCellProps {
+    width: number;
+    collapsed: boolean;
+    children?: ReactNode;
+}
+export declare const ModuleHeaderCell: ({ width, collapsed, children }: ModuleHeaderCellProps) => import("react").JSX.Element;

package/dist/Modules/ModuleHeaderMenu.d.ts

@@ -0,0 +1,10 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { ModuleHeaderAction } from './ModuleHeaderAction';
+export interface ModuleHeaderMenuProps {
+    moduleId: Guid;
+    actions: readonly ModuleHeaderAction[];
+    onAddModule?: () => void;
+    onAddFeature?: () => void;
+    kind: 'options' | 'add';
+}
+export declare const ModuleHeaderMenu: ({ moduleId, actions, onAddModule, onAddFeature, kind }: ModuleHeaderMenuProps) => import("react").JSX.Element | null;

package/dist/Modules/ModulePlaceholder.d.ts

@@ -0,0 +1,6 @@
+export interface ModulePlaceholderProps {
+    width: number;
+    height: number;
+    featureWidths: readonly number[];
+}
+export declare const ModulePlaceholder: ({ width, height, featureWidths }: ModulePlaceholderProps) => import("react").JSX.Element;

package/dist/Modules/ModuleSurface.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode, Ref } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+export interface ModuleSurfaceProps {
+    moduleId: Guid;
+    collectionId: Guid;
+    index: number;
+    width: number;
+    collapsed: boolean;
+    dragging?: boolean;
+    frameRef?: Ref<HTMLDivElement>;
+    header: ReactNode;
+    template?: ReactNode;
+    content: ReactNode;
+}
+export declare const ModuleSurface: ({ moduleId, collectionId, index, width, collapsed, dragging, frameRef, header, template, content }: ModuleSurfaceProps) => import("react").JSX.Element;

package/dist/Modules/ModulesArea.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import { type HeaderDragStart } from '../HeaderDragging';
+import { type ModuleAreaItem } from './moduleAreaState';
+export interface ModulesAreaProps<T extends ModuleAreaItem> {
+    collectionId: Guid;
+    initialModules: T[];
+    onAddModule?: () => Promise<T | undefined>;
+    onModulesReordered?: (orderedIds: Guid[]) => Promise<boolean>;
+    onCollapseChanged?: (moduleId: Guid, collapsed: boolean) => Promise<boolean>;
+    onRenameModule?: (moduleId: Guid, name: string) => Promise<boolean>;
+    onPersistenceError?: (error: unknown) => void;
+    renderModule: (module: T, options: {
+        index: number;
+        dragging: boolean;
+        onDragStart?: (start: HeaderDragStart) => void;
+        onAddModule?: () => void;
+        onToggleCollapse?: () => void;
+        onRenamed?: (name: string) => void;
+    }) => ReactNode;
+    onModulesChanged?: (modules: T[]) => void;
+}
+export declare function ModulesArea<T extends ModuleAreaItem>({ collectionId, initialModules, onAddModule, onModulesReordered, onCollapseChanged, onRenameModule, onPersistenceError, renderModule, onModulesChanged, }: ModulesAreaProps<T>): import("react").JSX.Element;

package/dist/Modules/ModulesReordered.d.ts

@@ -0,0 +1,2 @@
+import type { Guid } from '@cratis/fundamentals';
+export type ModulesReordered = (collectionId: Guid, orderedIds: Guid[]) => void;

package/dist/Modules/index.d.ts

@@ -0,0 +1,12 @@
+export * from './ModuleColumnFrame';
+export * from './ModuleDropIndicator';
+export * from './ModuleHeader';
+export * from './ModuleHeaderAction';
+export * from './ModulesArea';
+export * from './moduleAreaState';
+export * from './moduleWidth';
+export * from './ModuleHeaderCell';
+export * from './ModulePlaceholder';
+export * from './ModuleSurface';
+export * from './ModulesReordered';
+export * from './useModuleDrag';