agentlang
Version:
The easiest way to build the most reliable AI agents - enterprise-grade teams of AI agents that collaborate with each other and humans
102 lines • 4.85 kB
TypeScript
import { JoinSpec } from '../../language/generated/ast.js';
import { Environment } from '../interpreter.js';
import { Instance, InstanceAttributes, Relationship } from '../module.js';
import { ResolverAuthInfo } from './authinfo.js';
export type JoinInfo = {
relationship: Relationship;
queryInstance: Instance;
subJoins: JoinInfo[] | undefined;
};
export declare function setSubscriptionEvent(fqEventName: string, resolverName: string): void;
export declare function getSubscriptionEvent(resolverName: string): string | undefined;
export declare class Resolver {
protected authInfo: ResolverAuthInfo;
protected env: Environment | undefined;
protected name: string;
static Default: Resolver;
constructor(name?: string);
setAuthInfo(authInfo: ResolverAuthInfo): Resolver;
setEnvironment(env: Environment): Resolver;
getEnvironment(): Environment | undefined;
suspend(): Resolver;
getName(): string;
protected notImpl(method: string): void;
onSetPath(moduleName: string, entryName: string): any;
createInstance(inst: Instance): Promise<any>;
upsertInstance(inst: Instance): Promise<any>;
/**
* @param {Instance} inst - an Instance with query and update attributes
* @param {InstanceAttributes} newAttrs - updated attributes to set in instance
*/
updateInstance(inst: Instance, newAttrs: InstanceAttributes): Promise<any>;
/**
* @param {Instance} inst - an Instance with query attributes
* @param {boolean} queryAll - if this flag is set, fetch all instances
*/
queryInstances(inst: Instance, queryAll: boolean, distinct?: boolean): Promise<any>;
/**
* Return all instances under the given parent-path.
* @param {string} parentPath - path of the parent with the relevant relationship name as the last component
* @param {Instance} inst - child Instance with query attributes
*/
queryChildInstances(parentPath: string, inst: Instance): Promise<any>;
/**
* Return all instances connected to connectedInstance via the given between-relationship
* @param relationship Between relationship
* @param connectedInstance The instance to traveres the relationship from
* @param inst Target instance with query attributes
*/
queryConnectedInstances(relationship: Relationship, connectedInstance: Instance, inst: Instance): Promise<any>;
queryByJoin(inst: Instance, joinInfo: JoinInfo[], intoSpec: Map<string, string>, distinct?: boolean, rawJoinSpec?: JoinSpec): Promise<any>;
/**
* @param {Instance} inst - an Instance with query attributes
*/
deleteInstance(inst: Instance | Instance[], purge: boolean): Promise<any>;
/**
* Connect instances via a between relationship
* @param node1 The main node to connect
* @param otherNodeOrNodes Nodes to be connected to node1
* @param relEntry Details of the repationship
*/
connectInstances(node1: Instance, otherNodeOrNodes: Instance | Instance[], relEntry: Relationship, orUpdate: boolean): Promise<any>;
fullTextSearch(entryName: string, moduleName: string, query: string, options?: Map<string, any>): Promise<any>;
startTransaction(): Promise<any>;
commitTransaction(txnId: string): Promise<any>;
rollbackTransaction(txnId: string): Promise<any>;
subscribe(): Promise<any>;
private onOutOfBandCrud;
onCreate(inst: Instance, env: Environment): Promise<any>;
onUpdate(inst: Instance, env: Environment): Promise<any>;
onDelete(inst: Instance, env: Environment): Promise<any>;
onSubscription(result: any, callPostCrudEvent?: boolean): Promise<any>;
}
type MaybeFunction = Function | undefined;
export type GenericResolverMethods = {
create: MaybeFunction;
upsert: MaybeFunction;
update: MaybeFunction;
query: MaybeFunction;
delete: MaybeFunction;
startTransaction: MaybeFunction;
commitTransaction: MaybeFunction;
rollbackTransaction: MaybeFunction;
};
export type GenericResolverSubscription = {
subscribe: MaybeFunction;
};
export declare class GenericResolver extends Resolver {
implementation: GenericResolverMethods | undefined;
subs: GenericResolverSubscription | undefined;
constructor(name: string, implementation?: GenericResolverMethods);
createInstance(inst: Instance): Promise<any>;
upsertInstance(inst: Instance): Promise<any>;
updateInstance(inst: Instance, newAttrs: InstanceAttributes): Promise<any>;
queryInstances(inst: Instance, queryAll: boolean): Promise<any>;
deleteInstance(inst: Instance | Instance[], purge: boolean): Promise<any>;
startTransaction(): Promise<any>;
commitTransaction(txnId: string): Promise<any>;
rollbackTransaction(txnId: string): Promise<any>;
subscribe(): Promise<void>;
}
export {};
//# sourceMappingURL=interface.d.ts.map