///
import { AsyncLocalStorage } from 'async_hooks';
import { Atom } from 'data0';
import cors from 'cors';
import { FastifyLoggerOptions } from 'fastify';
import { MatchExpressionData } from '@interaqt/storage';
import SQLite from 'better-sqlite3';
import { UnwrapReactive } from 'data0';
export declare const Action: Klass<{
name: {
type: "string";
required: true;
};
}>;
export declare const Activity: Klass;
export declare const ACTIVITY_RECORD = "_Activity_";
declare class ActivityCall {
activity: ActivityInstanceType;
controller: Controller;
static cache: Map;
collection: true;
defaultValue: (...args: any[]) => (InertKlassInstance | ReactiveKlassInstance)[];
};
transfers: {
type: Klass;
collection: true;
defaultValue: (...args: any[]) => (InertKlassInstance | ReactiveKlassInstance)[];
};
groups: {
type: Klass;
collection: true;
defaultValue: (...args: any[]) => (InertKlassInstance | ReactiveKlassInstance)[];
};
gateways: {
type: Klass;
collection: true;
defaultValue: (...args: any[]) => (InertKlassInstance | ReactiveKlassInstance)[];
};
events: {
type: Klass< {
name: {
type: "string";
required: true;
};
}>;
collection: true;
defaultValue: (...args: any[]) => (InertKlassInstance< {
name: {
type: "string";
required: true;
};
}> | ReactiveKlassInstance< {
name: {
type: "string";
required: true;
};
}>)[];
};
}>, ActivityCall>;
static from: (activity: ActivityInstanceType, controller: Controller) => ActivityCall;
graph: Seq;
uuidToNode: Map;
uuidToInteractionCall: Map;
interactionCallByName: Map;
rawToNode: Map | InertKlassInstance | InertKlassInstance, GraphNode>;
system: System;
constructor(activity: ActivityInstanceType, controller: Controller);
buildGraph(activity: ActivityInstanceType, parentGroup?: ActivityGroupNode): Seq;
create(): Promise<{
activityId: any;
state: ActivitySeqStateData;
}>;
getNodeByUUID(uuid: string): GraphNode | undefined;
getState(activityId: string): Promise;
getActivity(activityId: string): Promise;
setActivity(activityId: string, value: any): Promise;
setState(activityId: string, state: any): Promise;
isStartNode(uuid: string): boolean;
isEndNode(uuid: string): boolean;
isActivityHead(interaction: InteractionInstanceType, head?: InteractionLikeNodeBase): boolean;
callInteraction(inputActivityId: string | undefined, uuid: string, interactionEventArgs: InteractionEventArgs): Promise;
saveUserRefs(activityId: string, interactionCall: InteractionCall, interactionEventArgs: InteractionEventArgs): Promise;
checkUserRef: (attributive: KlassInstance, eventUser: EventUser, activityId: string) => Promise;
}
export declare const activityEntity: InertKlassInstance< {
name: {
type: "string";
collection: false;
required: true;
constraints: {
nameFormat({ name }: {
name: Atom;
}): Atom;
};
};
computedData: {
type: Klass[];
collection: false;
required: false;
};
properties: {
type: Klass< {
name: {
type: "string";
required: true;
collection: false;
constraints: {
format({ name }: {
name: Atom;
}): Atom;
length({ name }: {
name: Atom;
}): Atom;
};
};
type: {
type: "string";
required: true;
collection: false;
options: PropertyTypes[];
};
collection: {
type: "boolean";
required: true;
collection: false;
defaultValue(): boolean;
};
args: {
computedType: (values: {
type: PropertyTypes;
}) => string;
};
computedData: {
collection: false;
type: Klass[];
required: false;
};
computed: {
required: false;
type: "function";
collection: false;
};
}>;
collection: true;
required: true;
constraints: {
eachNameUnique({ properties }: any): Atom;
};
defaultValue(): never[];
};
isRef: {
required: true;
collection: false;
type: "boolean";
defaultValue: () => boolean;
};
}>;
export declare const ActivityGroup: Klass;
export declare type ActivityGroupInstanceType = KlassInstance, false>;
declare type ActivityGroupNode = {
content: ActivityGroupInstanceType;
parentGroup?: ActivityGroupNode;
childSeqs?: Seq[];
} & InteractionLikeNodeBase;
export declare type ActivityGroupPublicType = {
type: {
type: 'string';
required: true;
collection: false;
};
activities: {
instanceType: UnwrappedActivityInstanceType;
required: false;
collection: true;
defaultValue: (...args: any[]) => UnwrappedActivityInstanceType[];
};
};
export declare type ActivityInstanceType = KlassInstance;
declare type ActivityPublicType = {
name: {
type: 'string';
collection: false;
required: true;
};
interactions: {
type: Klass;
collection: true;
defaultValue: (...args: any[]) => KlassInstance, any>[];
};
transfers: {
type: Klass;
collection: true;
defaultValue: (...args: any[]) => KlassInstance, any>[];
};
groups: {
type: Klass;
collection: true;
defaultValue: (...args: any[]) => KlassInstance, any>[];
};
gateways: {
type: Klass;
collection: true;
defaultValue: (...args: any[]) => KlassInstance, any>[];
};
events: {
type: typeof Event_2;
collection: true;
defaultValue: (...args: any[]) => KlassInstance[];
};
};
declare type ActivitySeqStateData = {
current?: InteractionStateData;
};
export declare const Any: Klass<{
record: {
type: (Klass<{
name: {
type: "string";
collection: false;
required: true;
constraints: {
nameFormat({ name }: {
name: Atom;
}): Atom;
};
};
computedData: {
type: Klass[];
collection: false;
required: false;
};
properties: {
type: Klass<{
name: {
type: "string";
required: true;
collection: false;
constraints: {
format({ name }: {
name: Atom;
}): Atom;
length({ name }: {
name: Atom;
}): Atom;
};
};
type: {
type: "string";
required: true;
collection: false;
options: PropertyTypes[];
};
collection: {
type: "boolean";
required: true;
collection: false;
defaultValue(): boolean;
};
args: {
computedType: (values: {
type: PropertyTypes;
}) => string;
};
computedData: {
collection: false;
type: Klass[];
required: false;
};
computed: {
required: false;
type: "function";
collection: false;
};
}>;
collection: true;
required: true;
constraints: {
eachNameUnique({ properties }: any): Atom;
};
defaultValue(): never[];
};
isRef: {
required: true;
collection: false;
type: "boolean";
defaultValue: () => boolean;
};
}> | Klass)[];
collection: false;
required: true;
};
match: {
type: "function";
collection: false;
required: true;
};
}>;
export declare type APIBody = {
activity?: string;
interaction?: string;
activityId?: string;
payload?: EventPayload;
query?: EventQuery;
};
export declare const asyncInteractionContext: AsyncLocalStorage;
declare type AtomData = {
type: 'atom';
data: T;
};
declare type AtomError = {
name: string;
type: string;
stack?: ConceptCheckStack[];
content?: string;
error?: any;
};
export declare type AtomHandle = (arg: T) => boolean | Promise;
export declare const Attributive: Klass< {
stringContent: {
type: "string";
};
content: {
type: "function";
required: true;
collection: false;
};
name: {
type: "string";
};
isRef: {
type: "boolean";
};
}>;
export declare const Attributives: Klass< {
content: {
type: (Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
operator: {
type: "string";
required: true;
collection: false;
options: string[];
defaultValue: () => string;
};
left: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: true;
collection: false;
};
right: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: false;
collection: false;
};
}>)[];
collection: false;
required: false;
};
}>;
export declare const BoolAtomData: Klass<{
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance | InertKlassInstance;
required: true;
collection: false;
};
}>;
export declare class BoolExp {
raw: ExpressionData;
static atom(data: U): BoolExp;
constructor(raw: ExpressionData);
isAtom(): boolean;
get left(): BoolExp;
get right(): BoolExp | undefined;
get data(): T;
toValue(): AtomData;
static fromValue(value: ExpressionData): BoolExp;
isExpression(): boolean;
and(atomValueOrExp: any): BoolExp;
isAnd(): boolean;
isOr(): boolean;
isNot(): boolean;
or(atomValueOrExp: any): BoolExp;
not(): BoolExp;
map(fn: MapFn, context?: string[]): BoolExp;
evaluate(atomHandle: AtomHandle, stack?: any[], inverse?: boolean): true | EvaluateError;
evaluateAsync(atomHandle: AtomHandle, stack?: any[], inverse?: boolean): Promise;
}
export declare const BoolExpressionData: Klass<{
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
operator: {
type: "string";
required: true;
collection: false;
options: string[];
defaultValue: () => string;
};
left: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance | InertKlassInstance;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: true;
collection: false;
};
right: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance | InertKlassInstance;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: false;
collection: false;
};
}>;
export declare type BoolExpressionRawData = {
type: 'expression';
operator: 'and' | 'not' | 'or';
left: ExpressionData;
right?: ExpressionData;
};
export declare function boolExpToAttributives(obj: BoolExp>): InertKlassInstance< {
content: {
type: (Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
operator: {
type: "string";
required: true;
collection: false;
options: string[];
defaultValue: () => string;
};
left: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: true;
collection: false;
};
right: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: false;
collection: false;
};
}>)[];
collection: false;
required: false;
};
}>;
export declare function boolExpToConditions(obj: BoolExp>): InertKlassInstance< {
content: {
type: (Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
operator: {
type: "string";
required: true;
collection: false;
options: string[];
defaultValue: () => string;
};
left: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: true;
collection: false;
};
right: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: false;
collection: false;
};
}>)[];
collection: false;
required: false;
};
}>;
export declare function boolExpToDataAttributives(obj: BoolExp>): InertKlassInstance< {
content: {
type: (Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
operator: {
type: "string";
required: true;
collection: false;
options: string[];
defaultValue: () => string;
};
left: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: true;
collection: false;
};
right: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: false;
collection: false;
};
}>)[];
collection: false;
required: false;
};
}>;
declare type CheckUserRef = (attributive: KlassInstance, eventUser: EventUser, activityId: string) => Promise;
declare type ClassMetaPublicItem = OptionalComputedValueType>>>;
declare type ClassPropType = {
type?: Klass | Klass[] | PrimitivePropType;
instanceType?: Object;
reactiveInstanceType?: KlassInstance;
computedType?: (...arg: any[]) => string | Function;
options?: any[] | ((thisProp: any, thisEntity: object) => any[]);
constraints?: {
[ruleName: string]: ((thisProp: any, thisEntity: object) => Atom | boolean | any[]) | Function | string;
};
};
declare type CommonAtomPublic = {
content: {
type: 'function';
required: true;
collection: false;
};
};
export declare const Computation: Klass< {
content: {
type: "function";
required: true;
collection: false;
};
name: {
type: "string";
};
}>;
export declare const ComputedData: Klass<{
computeEffect: {
type: "string";
collection: false;
required: true;
};
computation: {
type: "string";
collection: false;
required: true;
};
}>;
declare class ComputedDataHandle {
controller: Controller;
computedData: KlassInstance;
dataContext: DataContext;
static Handles: Map, typeof ComputedDataHandle>;
computedDataType: 'global' | 'entity' | 'relation' | 'property';
userComputeEffect: (mutationEvent: any, mutationEvents: any) => Promise | ComputeEffectResult;
userFullCompute: (...args: any[]) => Promise;
recordName?: string;
propertyName?: string;
stateName?: string;
constructor(controller: Controller, computedData: KlassInstance, dataContext: DataContext);
setupSchema(): void;
setupStates(): Promise;
setupInitialValue(): Promise;
addEventListener(): void;
parseComputeEffectFunction(content: string): Function;
parseFullComputeFunction(content: string): Function;
parseComputedData(): void;
getDefaultValue(newRecordId?: any): any;
insertDefaultPropertyValue(newRecord: any): Promise;
computeEffect(mutationEvent: RecordMutationEvent, mutationEvents: RecordMutationEvent[]): any;
recompute(effectResult: ComputeEffectResult, mutationEvent: RecordMutationEvent, mutationEvents: RecordMutationEvent[]): Promise;
updateState(affectedId: true | string, newValue: any): Promise;
}
declare type ComputedEffect = any;
declare type ComputedValueType = (obj: KlassInstance) => any;
declare type ComputeEffectResult = ComputedEffect | ComputedEffect[] | undefined;
export declare interface Concept {
name: string;
}
export declare interface ConceptAlias extends Concept {
for: Concept[];
}
declare type ConceptCheckResponse = AtomError | true;
declare type ConceptCheckStack = {
type: string;
values: {
[k: string]: any;
};
};
export declare type ConceptInstance = any;
export declare type ConceptType = {};
export declare const Condition: Klass< {
content: {
type: "function";
required: true;
collection: false;
};
name: {
type: "string";
};
}>;
export declare const Conditions: Klass< {
content: {
type: (Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
operator: {
type: "string";
required: true;
collection: false;
options: string[];
defaultValue: () => string;
};
left: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: true;
collection: false;
};
right: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: false;
collection: false;
};
}>)[];
collection: false;
required: false;
};
}>;
export declare const constraints: {
entityNameUnique({ entities }: {
entities: (typeof Entity)[];
}): Atom;
};
export declare class Controller {
system: System;
entities: KlassInstance[];
relations: KlassInstance[];
activities: KlassInstance[];
interactions: KlassInstance[];
states: KlassInstance[];
computedDataHandles: Set;
activityCalls: Map;
activityCallsByName: Map;
interactionCallsByName: Map;
interactionCalls: Map;
globals: {
BoolExp: typeof BoolExp;
};
constructor(system: System, entities: KlassInstance[], relations: KlassInstance[], activities: KlassInstance[], interactions: KlassInstance[], states?: KlassInstance[]);
addComputedDataHandle(computedData: KlassInstance, host: DataContext["host"], id: DataContext["id"]): void;
setup(install?: boolean): Promise;
callbacks: Map>;
listen(event: any, callback: SystemCallback): () => void;
dispatch(event: any, ...args: any[]): Promise;
callInteraction(interactionId: string, interactionEventArgs: InteractionEventArgs): Promise;
callActivityInteraction(activityCallId: string, interactionCallId: string, activityId: string | undefined, interactionEventArgs: InteractionEventArgs): Promise;
}
export declare const Count: Klass<{
record: {
type: (Klass<{
name: {
type: "string";
collection: false;
required: true;
constraints: {
nameFormat({ name }: {
name: Atom;
}): Atom;
};
};
computedData: {
type: Klass[];
collection: false;
required: false;
};
properties: {
type: Klass<{
name: {
type: "string";
required: true;
collection: false;
constraints: {
format({ name }: {
name: Atom;
}): Atom;
length({ name }: {
name: Atom;
}): Atom;
};
};
type: {
type: "string";
required: true;
collection: false;
options: PropertyTypes[];
};
collection: {
type: "boolean";
required: true;
collection: false;
defaultValue(): boolean;
};
args: {
computedType: (values: {
type: PropertyTypes;
}) => string;
};
computedData: {
collection: false;
type: Klass[];
required: false;
};
computed: {
required: false;
type: "function";
collection: false;
};
}>;
collection: true;
required: true;
constraints: {
eachNameUnique({ properties }: any): Atom;
};
defaultValue(): never[];
};
isRef: {
required: true;
collection: false;
type: "boolean";
defaultValue: () => boolean;
};
}> | Klass)[];
collection: false;
required: true;
};
match: {
type: "function";
collection: false;
required: true;
};
}>;
export declare function createClass(metadata: T): Klass;
export declare function createDataAPI(handle: DataAPIHandle, config?: DataAPIConfig): DataAPI;
export declare function createInstances(objects: KlassRawInstanceDataType[], reactiveForce?: boolean): Map | ReactiveKlassInstance>;
export declare function createInstancesFromString(objStr: string): Map | ReactiveKlassInstance>;
export declare function createUserRoleAttributive({ name, isRef }: {
name?: string;
isRef?: boolean;
}, options?: KlassOptions | ReactiveKlassOptions): InertKlassInstance< {
stringContent: {
type: "string";
};
content: {
type: "function";
required: true;
collection: false;
};
name: {
type: "string";
};
isRef: {
type: "boolean";
};
}> | ReactiveKlassInstance< {
stringContent: {
type: "string";
};
content: {
type: "function";
required: true;
collection: false;
};
name: {
type: "string";
};
isRef: {
type: "boolean";
};
}>;
export declare type DataAPI = DataAPIHandle & DataAPIConfig;
export declare type DataAPIConfig = {
params?: any[];
allowAnonymous?: boolean;
};
export declare type DataAPIContext = {
user: EventUser;
};
export declare type DataAPIHandle = (this: Controller, context: DataAPIContext, ...rest: any[]) => any;
export declare type DataAPIs = {
[k: string]: DataAPI;
};
export declare const DataAttributive: Klass< {
content: {
type: "function";
required: true;
collection: false;
};
name: {
type: "string";
};
}>;
export declare const DataAttributives: Klass< {
content: {
type: (Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | Klass< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
operator: {
type: "string";
required: true;
collection: false;
options: string[];
defaultValue: () => string;
};
left: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: true;
collection: false;
};
right: {
instanceType: InertKlassInstance< {
type: {
type: "string";
required: true;
collection: false;
defaultValue: () => string;
};
data: {
instanceType: ReactiveKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}> | InertKlassInstance< {
content: {
type: "function";
required: true;
collection: false;
};
}>;
required: true;
collection: false;
};
}> | UnwrappedBoolExpressionInstanceType;
required: false;
collection: false;
};
}>)[];
collection: false;
required: false;
};
}>;
export declare type Database = {
open: () => Promise;
logger: DatabaseLogger;
scheme: (sql: string, name?: string) => Promise;
query: (sql: string, values: any[], name?: string) => Promise;
delete: (sql: string, where: any[], name?: string) => Promise;
insert: (sql: string, values: any[], name?: string) => Promise;
update: (sql: string, values: any[], idField?: string, name?: string) => Promise;
getAutoId: (recordName: string) => Promise;
parseMatchExpression?: (key: string, value: [string, any], fieldName: string, fieldType: string, isReferenceValue: boolean, getReferenceFieldValue: (v: string) => string) => any;
};
export declare type DatabaseLogger = {
info: (arg: {
type: string;
name: string;
sql: string;
params?: any[];
}) => any;
child: (fixed: object) => DatabaseLogger;
};
declare type DataContext = {
host?: KlassInstance | KlassInstance;
id: KlassInstance | KlassInstance | KlassInstance | string;
};
export declare function deepClone(obj: T, deepCloneKlass?: boolean): T;
declare type DefaultValueType = (...args: any[]) => any;
export declare interface DerivedConcept extends Concept {
base?: Concept;
attributive?: any;
}
export declare const Entity: Klass<{
name: {
type: "string";
collection: false;
required: true;
constraints: {
nameFormat({ name }: {
name: Atom;
}): Atom;
};
};
computedData: {
type: Klass[];
collection: false;
required: false;
};
properties: {
type: Klass<{
name: {
type: "string";
required: true;
collection: false;
constraints: {
format({ name }: {
name: Atom;
}): Atom;
length({ name }: {
name: Atom;
}): Atom;
};
};
type: {
type: "string";
required: true;
collection: false;
options: PropertyTypes[];
};
collection: {
type: "boolean";
required: true;
collection: false;
defaultValue(): boolean;
};
args: {
computedType: (values: {
type: PropertyTypes;
}) => string;
};
computedData: {
collection: false;
type: Klass[];
required: false;
};
computed: {
required: false;
type: "function";
collection: false;
};
}>;
collection: true;
required: true;
constraints: {
eachNameUnique({ properties }: any): Atom;
};
defaultValue(): never[];
};
isRef: {
required: true;
collection: false;
type: "boolean";
defaultValue: () => boolean;
};
}>;
export declare type EntityIdRef = {
id: string;
[ROW_ID_ATTR]?: string;
[k: string]: any;
};
export declare type EvaluateError = {
data: any;
stack: any[];
error: any;
inverse: boolean;
};
declare const Event_2: Klass<{
name: {
type: "string";
required: true;
};
}>;
export { Event_2 as Event }
export declare const EVENT_RECORD = "_Event_";
export declare const eventEntity: InertKlassInstance< {
name: {
type: "string";
collection: false;
required: true;
constraints: {
nameFormat({ name }: {
name: Atom;
}): Atom;
};
};
computedData: {
type: Klass[];
collection: false;
required: false;
};
properties: {
type: Klass< {
name: {
type: "string";
required: true;
collection: false;
constraints: {
format({ name }: {
name: Atom;
}): Atom;
length({ name }: {
name: Atom;
}): Atom;
};
};
type: {
type: "string";
required: true;
collection: false;
options: PropertyTypes[];
};
collection: {
type: "boolean";
required: true;
collection: false;
defaultValue(): boolean;
};
args: {
computedType: (values: {
type: PropertyTypes;
}) => string;
};
computedData: {
collection: false;
type: Klass[];
required: false;
};
computed: {
required: false;
type: "function";
collection: false;
};
}>;
collection: true;
required: true;
constraints: {
eachNameUnique({ properties }: any): Atom;
};
defaultValue(): never[];
};
isRef: {
required: true;
collection: false;
type: "boolean";
defaultValue: () => boolean;
};
}>;
export declare type EventPayload = {
[k: string]: any;
};
/**
* 与 interaction 无关,但与当前 query 有关的信息。例如数据获取的 viewPort,innerInteraction 的 activity id
*/
export declare type EventQuery = {
[k: string]: any;
};
export declare type EventUser = {
[k: string]: any;
id: string;
roles: string[];
};
export declare const Every: Klass<{
record: {
type: (Klass<{
name: {
type: "string";
collection: false;
required: true;
constraints: {
nameFormat({ name }: {
name: Atom;
}): Atom;
};
};
computedData: {
type: Klass[];
collection: false;
required: false;
};
properties: {
type: Klass<{
name: {
type: "string";
required: true;
collection: false;
constraints: {
format({ name }: {
name: Atom;
}): Atom;
length({ name }: {
name: Atom;
}): Atom;
};
};
type: {
type: "string";
required: true;
collection: false;
options: PropertyTypes[];
};
collection: {
type: "boolean";
required: true;
collection: false;
defaultValue(): boolean;
};
args: {
computedType: (values: {
type: PropertyTypes;
}) => string;
};
computedData: {
collection: false;
type: Klass[];
required: false;
};
computed: {
required: false;
type: "function";
collection: false;
};
}>;
collection: true;
required: true;
constraints: {
eachNameUnique({ properties }: any): Atom;
};
defaultValue(): never[];
};
isRef: {
required: true;
collection: false;
type: "boolean";
defaultValue: () => boolean;
};
}> | Klass)[];
collection: false;
required: true;
};
match: {
type: "function";
collection: false;
required: true;
};
notEmpty: {
type: "boolean";
collection: false;
required: false;
};
}>;
export declare type ExpressionData = BoolExpressionRawData | AtomData;
declare type ExtractKlassTypes[]> = T extends Array ? SUB_KLASS extends Klass ? KlassProp> : never : never;
export declare function findRootActivity(interaction: InteractionInstanceType): ActivityInstanceType | null;
export declare function forEachInteraction(activity: ActivityInstanceType, handle: (i: InteractionInstanceType, g?: ActivityGroupInstanceType) => any, parenGroup?: ActivityGroupInstanceType): void;
export declare const Gateway: Klass;
export declare type GatewayInstanceType = KlassInstance;
declare type GatewayNode = {
uuid: string;
content: GatewayInstanceType;
prev: GraphNode[];
next: GraphNode[];
};
export declare type GatewayPublicType = {
name: {
type: 'string';
required: true;
};
};
export declare const GetAction: InertKlassInstance< {
name: {
type: "string";
required: true;
};
}> | ReactiveKlassInstance< {
name: {
type: "string";
required: true;
};
}>;
export declare function getDisplayValue(obj: InertKlassInstance): string | undefined;
export declare function getInstance>(Type: T): KlassInstance[];
export declare function getInteractions(activity: ActivityInstanceType): InertKlassInstance[];
export declare function getUUID(obj: InertKlassInstance): string;
declare type GraphNode = InteractionNode | ActivityGroupNode | GatewayNode;
declare type HandleAttributive = (attributive: KlassInstance) => Promise;
export declare const ID_ATTR = "id";
declare class IDSystem {
db: Database;
constructor(db: Database);
setup(): Promise;
getAutoId(recordName: string): Promise;
}
declare type IfReactiveCollectionProp = REACTIVE extends true ? (COLLECTION extends true ? UnwrapReactive : Atom) : (COLLECTION extends true ? T[] : T);
export declare type InertKlassInstance> = InertKlassInstanceProps & KlassInstancePrimitiveProps;
export declare type InertKlassInstanceProps> = OptionalProps & RequiredProps;
export declare const Interaction: Klass;
declare class InteractionCall {
interaction: InteractionInstanceType;
controller: Controller;
activitySeqCall?: ActivityCall | undefined;
system: System;
constructor(interaction: InteractionInstanceType, controller: Controller, activitySeqCall?: ActivityCall | undefined);
checkAttributive(inputAttributive: any, interactionEvent: InteractionEventArgs | undefined, attributiveTarget: any): Promise;
checkMixedAttributive(attributiveData: KlassInstance, instance: ConceptInstance): Promise;
createHandleAttributive(AttributiveClass: typeof Attributive | typeof Attributive, interactionEvent: InteractionEventArgs, target: any): (attributive: KlassInstance) => Promise;
checkUser(interactionEvent: InteractionEventArgs, activityId?: string, checkUserRef?: CheckUserRef): Promise;
checkConcept(instance: ConceptInstance, concept: Concept, attributives?: BoolExpressionRawData>, stack?: ConceptCheckStack[]): Promise;
isConcept(instance: ConceptInstance, concept: Concept, stack?: ConceptCheckStack[]): Promise;
isDerivedConcept(concept: Concept): boolean;
isConceptAlias(concept: Concept): boolean;
checkAttributives(attributives: BoolExp>, handleAttributive: HandleAttributive, stack?: ConceptCheckStack[]): Promise;
checkPayload(interactionEvent: InteractionEventArgs): Promise;
checkCondition(interactionEvent: InteractionEventArgs): Promise;
runEffects(eventArgs: InteractionEventArgs, activityId: string | undefined, response: InteractionCallResponse): Promise;
isGetInteraction(): boolean;
saveEvent(interactionEvent: InteractionEvent): Promise;
savePayload(payload: InteractionEventArgs["payload"]): Promise;
retrieveData(interactionEvent: InteractionEventArgs): Promise;
check(interactionEventArgs: InteractionEventArgs, activityId?: string, checkUserRef?: CheckUserRef, context?: InteractionContext): Promise;
call(interactionEventArgs: InteractionEventArgs, activityId?: string, checkUserRef?: CheckUserRef, context?: InteractionContext): Promise;
}
declare type InteractionCallResponse = {
error?: any;
data?: any;
event?: InteractionEvent;
effects?: any[];
sideEffects?: {
[k: string]: SideEffectResult;
};
context?: {
[k: string]: any;
};
};
export declare type InteractionContext = {
logContext?: any;
[k: string]: any;
};
export declare type InteractionEvent = {
interactionId: string;
interactionName: string;
activityId?: string;
args: InteractionEventArgs;
};
export declare type InteractionEventArgs = {
user: EventUser;
payload?: EventPayload;
query?: EventQuery;
};
export declare type InteractionInstanceType = KlassInstance;
declare type InteractionLikeNodeBase = {
uuid: string;
next: GraphNode | null;
prev?: GraphNode;
parentSeq: Seq;
};
declare type InteractionNode = {
content: InteractionInstanceType;
parentGroup?: ActivityGroupNode;
} & InteractionLikeNodeBase;
export declare type InteractionPublicType = {
name: {
type: 'string';
collection: false;
required: true;
};
conditions: {
required: false;
collection: false;
type: (typeof Conditions | typeof Condition)[];
};
userAttributives: {
required: false;
collection: false;
type: (typeof Attributives | typeof Attributive)[];
};
userRef: {
type: typeof Attributive;
collection: false;
};
action: {
type: typeof Action;
collection: false;
required: true;
};
payload: {
type: typeof Payload;
collection: false;
};
sideEffects: {
type: typeof SideEffect;
collection: true;
defaultValue: (...args: any[]) => KlassInstance