@openedc/sdk 3.8.1

package/openedc-sdk.d.ts

@@ -0,0 +1,1136 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type DataStateMessageEvent = {
+	store: string;
+	method: CRUDTypes;
+	state: Record<string, unknown>;
+};
+declare const CRUDMethods: {
+	readonly INSERT: "INSERT";
+	readonly UPDATE: "UPDATE";
+	readonly DELETE: "DELETE";
+};
+export type CRUDTypes = typeof CRUDMethods[keyof typeof CRUDMethods];
+export type QueryCallback<T extends DataBlock> = ((data: any, updatedBlock?: T, crud?: CRUDTypes) => void);
+declare class LiveQuery<T extends DataBlock> {
+	queryResult: QueryResult;
+	callbacks: QueryCallback<T>[];
+	dataCache: T[];
+	constructor(queryResult: QueryResult, callback: QueryCallback<T>);
+	start(): Promise<this>;
+	executeQuery(): Promise<void>;
+	executeCallbacks(updatedBlock?: T, crud?: CRUDTypes): void;
+	debounceCallbacks: (updatedBlock?: T | undefined, crud?: CRUDTypes | undefined) => void;
+	evaluateDataChange({ store, method, state }: DataStateMessageEvent, debounce?: boolean): Promise<void>;
+	find(block: typeof DataBlock, key: string, value: unknown): DataBlock | undefined;
+	recursivelyInsertData(block: DataBlock, data: Record<string, unknown>, visited?: Record<string, DataBlock>): Promise<DataBlock>;
+	selectivelyAdoptChanges(block: DataBlock, data: Record<string, unknown>): Promise<DataBlock>;
+	parseReferences(store: string, data: Record<string, unknown>): Record<string, unknown>;
+	addCallback(callback: QueryCallback<T>): this;
+	removeCallback(callback: QueryCallback<T>): void;
+}
+export type Policy = {
+	name: string;
+	command: "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "ALL";
+	expression: string;
+	check?: string;
+	restricted?: {
+		permission: string;
+		fields: string[];
+	};
+};
+export type RawData<T extends DataBlock> = {
+	[K in keyof T as T[K] extends Function ? never : K]: T[K] extends DataBlock | BlockReference<DataBlock> ? string : T[K] extends DataBlock | BlockReference<DataBlock> | undefined ? string | undefined : T[K] extends DataBlock[] | BlockReference<DataBlock>[] ? string[] : T[K] extends DataBlock[] | BlockReference<DataBlock>[] | undefined ? string[] | undefined : T[K];
+};
+export type AuditData<T extends DataBlock> = RawData<T> & {
+	[K in keyof AuditRecord as AuditRecord[K] extends Function ? never : K]: AuditRecord[K];
+};
+export type DataDifference = AuditData<any> & {
+	store: string;
+	previous: Record<string, unknown>;
+	current: Record<string, unknown>;
+};
+declare class AuditRecord {
+	static readonly collectionName = "audit";
+	static fields: Record<string, FieldDefinition>;
+	method: CRUDTypes;
+	timestamp: number;
+	userUUID: string;
+	reason?: string;
+	constructor(method: CRUDTypes, userUUID: string, reason?: string);
+	static fromBlock(constructor: typeof DataBlock): typeof DataBlock;
+	static getDifferences: (constructor: typeof DataBlock, records: AuditData<any>[], keys: string[]) => DataDifference[];
+	static derivePolicies(policies: Policy[]): Policy[];
+	with(data: Record<string, unknown>): {
+		method: CRUDTypes;
+		timestamp: number;
+		userUUID: string;
+		reason: string | undefined;
+	} & Record<string, unknown>;
+}
+declare const ProjectStatus: {
+	readonly draft: "draft";
+	readonly production: "production";
+	readonly finished: "finished";
+	readonly archived: "archived";
+};
+export declare class Project extends DataBlock {
+	name: string;
+	description: string | undefined;
+	status: typeof ProjectStatus[keyof typeof ProjectStatus];
+	owner: BlockReference<User>;
+	timeZone?: string;
+	startDate?: string;
+	endDate?: string;
+	publicProjectKey?: string;
+	fileMegabyteLimit?: number;
+	smsSendLimit?: number;
+	mfaRequired?: boolean;
+	constructor(name: string, owner: BlockReference<User>);
+	static getUrl(uuid: string, site?: string): string;
+	getUrl(site?: string): string;
+}
+export type ValidKey = Exclude<IDBValidKey, Date | BufferSource>;
+export type ExtendedKey = ValidKey | DataBlock | BlockReference<DataBlock> | Record<string, ValidKey | undefined> | undefined;
+declare class QueryResult {
+	uuid: string;
+	projectUUID: string | undefined;
+	block: typeof DataBlock;
+	where: WhereResult[];
+	sort: SortResult[];
+	update?: Record<string, unknown>;
+	delete?: boolean;
+	first: boolean;
+	constructor(block: typeof DataBlock);
+	toString(): string;
+	dataDoesMatch(store: string, data: DataBlock | Record<string, unknown>): boolean;
+}
+declare class WhereResult {
+	field: string;
+	operator: "=" | "!=" | ">=" | "<=" | "in" | "any" | "between";
+	value: ValidKey | Record<string, ValidKey | undefined> | undefined;
+	union: "and" | "or" | undefined;
+	constructor(field: string, operator: WhereResult["operator"], value: WhereResult["value"], union: WhereResult["union"]);
+	dataDoesMatch(data: DataBlock | Record<string, unknown>): boolean | undefined;
+}
+declare class SortResult {
+	field: string;
+	type: "asc" | "desc";
+	constructor(field: string, type: SortResult["type"]);
+}
+declare class Where<T extends typeof DataBlock> {
+	protected fieldName: string;
+	protected result: QueryResult;
+	protected union: WhereResult["union"];
+	constructor(fieldName: string, result: QueryResult, union?: WhereResult["union"]);
+	protected finalizeWhere(value: ExtendedKey, operator: WhereResult["operator"], union?: WhereResult["union"]): void;
+	equals(value: ExtendedKey): Collection<T>;
+	notEquals(value: ExtendedKey): Collection<T>;
+	greaterThanOrEqual(value: ExtendedKey): Collection<T>;
+	lowerThanOrEqual(value: ExtendedKey): Collection<T>;
+	includes(value: ExtendedKey): Collection<T>;
+	equalsAny(values: ValidKey[]): Collection<T>;
+	between(from: ValidKey, to: ValidKey): Collection<T>;
+}
+declare class Sort<T extends typeof DataBlock> {
+	protected fieldName: string;
+	protected result: QueryResult;
+	constructor(fieldName: string, result: QueryResult);
+	protected finalizeSort(type: SortResult["type"]): void;
+	asc(): Collection<T>;
+	desc(): Collection<T>;
+}
+declare class Collection<T extends typeof DataBlock> {
+	protected result: QueryResult;
+	constructor(result: QueryResult);
+	sort(fieldName: string): Sort<T>;
+	or(fieldName: string): void;
+	and(fieldName: string): Where<T>;
+	project(project?: Project | string): this;
+	all(): Promise<InstanceType<T>[]>;
+	all(options: {
+		raw: boolean;
+	}): Promise<RawData<InstanceType<T>>[]>;
+	all(callback: (data: InstanceType<T>[], updatedBlock?: InstanceType<T>, crud?: CRUDTypes) => void): Promise<LiveQuery<InstanceType<T>>>;
+	first(): Promise<InstanceType<T> | undefined>;
+	first(options: {
+		raw: boolean;
+	}): Promise<RawData<InstanceType<T>>>;
+	first(callback: (data?: InstanceType<T>, updatedBlock?: InstanceType<T>, crud?: CRUDTypes) => void): Promise<LiveQuery<InstanceType<T>>>;
+	private executeQuery;
+	audit(): Promise<AuditData<InstanceType<T>>[]>;
+	update(data: Partial<RawData<InstanceType<T>>>): Promise<Record<string, unknown>[]>;
+	delete(): Promise<Record<string, unknown>[]>;
+}
+export interface PersistenceAdapter {
+	offline?: boolean;
+	getObject: (definition: BlockDefinition, key: Record<string, string>) => Promise<Record<string, unknown> | undefined>;
+	setObject: (definition: BlockDefinition, value: Record<string, unknown>, reason?: string, refresh?: boolean) => Promise<void>;
+	setObjects: (definition: BlockDefinition, values: Record<string, unknown>[], reasons?: Record<string, string | undefined>, refresh?: boolean) => Promise<void>;
+	deleteObject: (definition: BlockDefinition, key: Record<string, string>, reason?: string) => Promise<void>;
+	executeQuery: (queryResult: QueryResult) => Promise<Record<string, unknown> | Record<string, unknown>[]>;
+	registerLiveQuery?: (queryResult: QueryResult) => void;
+	unregisterLiveQuery?: (queryResult: QueryResult) => void;
+	uploadFile?: (file: File, published: boolean, callback?: (progress: number) => void) => Promise<string>;
+	getFileURL?: (externalId: string, published: boolean, expiration: number) => Promise<string>;
+}
+export type BlockDefinition = {
+	collection: string;
+	store: string;
+	auto?: boolean;
+	audit?: boolean;
+	global?: boolean;
+	compound?: boolean;
+	snapshot?: boolean;
+	restricted?: boolean;
+	version?: number;
+};
+export type FieldType = typeof String | typeof Number | typeof Boolean | typeof Date | typeof Object | string;
+export type FieldDefinition = {
+	key?: boolean;
+	index?: boolean;
+	unique?: boolean;
+	lazy?: boolean;
+	group?: string;
+	type?: FieldType | FieldType[];
+	relation?: typeof DataBlock | typeof DataBlock[];
+	delete?: "unset" | "cascade";
+};
+declare class DataBlock {
+	static adapter: PersistenceAdapter;
+	static fields: Record<string, FieldDefinition>;
+	static definition: BlockDefinition;
+	static keyPath?: string[];
+	protected internal: {
+		lastState?: Record<string, unknown>;
+	};
+	readonly uuid: string;
+	readonly project?: string;
+	readonly createdDate: number;
+	constructor(..._: unknown[]);
+	static deriveKey(data: Record<string, unknown>): {
+		[k: string]: string;
+	};
+	static referenceWith<T extends typeof DataBlock>(this: T, uuid: string): BlockReference<InstanceType<T>>;
+	get static(): typeof DataBlock;
+	protected get children(): DataBlock[];
+	static where<T extends typeof DataBlock>(this: T): Collection<T>;
+	static where<T extends typeof DataBlock>(this: T, value: string): Where<T>;
+	static where<T extends typeof DataBlock>(this: T, value: Record<string, ExtendedKey>): Collection<T>;
+	commit(options?: {
+		cascade?: boolean;
+		project?: Project | string;
+		reason?: string;
+		refresh?: boolean;
+	}, transaction?: string): Promise<this>;
+	static commit(data: DataBlock[], project?: string, reasons?: Record<string, string>, refresh?: boolean): Promise<void>;
+	protected beforeTrigger(): Promise<void> | void;
+	protected afterTrigger(): Promise<void> | void;
+	prepareSerialization(): Promise<void> | void;
+	discard(): Promise<void>;
+	private updateLocalQueryCache;
+	delete(options?: {
+		cascade?: boolean;
+		reason?: string;
+	}): Promise<undefined>;
+	get changedFields(): Record<string, unknown>;
+	toObject(): Record<string, unknown>;
+	toString(): string;
+	clone(options?: {
+		cascade?: boolean;
+		custom?: (original: DataBlock) => DataBlock | void;
+		adjust?: (clone: DataBlock) => void;
+	}, visited?: Record<string, DataBlock>): this;
+	find<T extends typeof DataBlock>(block: T, key?: string, value?: unknown, all?: boolean, visited?: Set<string>): InstanceType<T> | undefined;
+	find<T extends typeof DataBlock>(block: T, key: string | undefined, value: unknown | undefined, all: true, visited?: Set<string>): InstanceType<T>[] | undefined;
+	set(values: Partial<this>): this & Partial<this>;
+	get uncommitted(): boolean;
+	get reference(): BlockReference<this>;
+	private static withCache;
+	static getByUUID<T extends typeof DataBlock>(this: T, uuid: string): Promise<InstanceType<T>>;
+	static fromObject<T extends typeof DataBlock>(this: T, state: Record<string, unknown>): Promise<InstanceType<T>>;
+	static rebuildBlock<T extends typeof DataBlock>(this: T, state: Record<string, unknown>): Promise<InstanceType<T>>;
+}
+declare class BlockReference<T extends DataBlock> {
+	collection: string;
+	store: string;
+	uuid: string;
+	constructor(collection: string, store: string, uuid: string);
+	static fromString<T extends DataBlock>(value: unknown): BlockReference<T> | undefined;
+	get data(): Promise<T>;
+	toString(): string;
+}
+declare const AdminRights: {
+	readonly MANAGE_ALL_DATA: "manage-all-data";
+	readonly CREATE_OWN_PROJECTS: "create-own-projects";
+	readonly VIEW_EXISTING_USERS: "view-existing-users";
+};
+export declare class User extends DataBlock {
+	oid: string;
+	givenName?: string;
+	familyName?: string;
+	email?: string;
+	language?: string;
+	adminRights: typeof AdminRights[keyof typeof AdminRights][];
+	constructor(oid: string);
+	beforeTrigger(): void;
+	hasAdminRight(...rights: User["adminRights"]): boolean;
+	get fullName(): string | undefined;
+}
+declare const OID_SUFFIX = "OID";
+declare const INSTANCE_SUFFIX = "Instance";
+declare const ENTRIES: {
+	studyEventGroup: undefined;
+	studyEvent: boolean;
+	form: boolean;
+	section: boolean;
+	item: undefined;
+	dataset: undefined;
+};
+export type FlatPathOIDs = {
+	[K in keyof typeof ENTRIES as `${K}${typeof OID_SUFFIX}`]?: string;
+};
+export type FlatPathInstances = {
+	[K in keyof typeof ENTRIES as typeof ENTRIES[K] extends boolean ? `${K}${typeof INSTANCE_SUFFIX}` : never]?: number;
+};
+export type FlatPath = FlatPathOIDs & FlatPathInstances;
+export declare class ODMPath {
+	private values;
+	constructor(values: Record<string, string | number>, until?: keyof typeof ENTRIES);
+	static unequal(a?: ODMPath, b?: ODMPath): boolean;
+	static from(value: string): ODMPath;
+	static uniques<T extends keyof FlatPath>(paths: ODMPath[], value: T): (ODMPath[T] & {})[];
+	static with(path?: ODMPath | FlatPath, until?: keyof typeof ENTRIES): ODMPath;
+	with(path?: ODMPath | FlatPath, until?: keyof typeof ENTRIES): ODMPath;
+	relative(reference?: ODMPath | FlatPath): ODMPath;
+	toString(): string;
+	toObject(): FlatPath;
+	filter: (element: Partial<FlatPath>) => boolean;
+	get formless(): ODMPath;
+	get studyEventGroupOID(): string | undefined;
+	get studyEventOID(): string | undefined;
+	get studyEventInstance(): number | undefined;
+	get formOID(): string | undefined;
+	get formInstance(): number | undefined;
+	get sectionOID(): string | undefined;
+	get sectionInstance(): number | undefined;
+	get itemOID(): string | undefined;
+	get datasetOID(): string | undefined;
+	get fieldOID(): string | undefined;
+}
+declare class Location$1 extends DataBlock {
+	oid: string;
+	name: string;
+	address?: string;
+	timeZone?: string;
+	constructor(oid: string, name: string, address?: string);
+}
+export declare class Alias extends DataBlock {
+	context: string;
+	name: string;
+	static prefix: string;
+	constructor(context: string, name: string);
+	static addPrefixed(aliases: Alias[], context: string, name?: string | number): Alias | undefined;
+	static findPrefixed(aliases: Alias[], context: string): string | undefined;
+	hasPrefixed(context: string): boolean;
+}
+export declare class TranslatedText extends DataBlock {
+	lang: string;
+	text: string;
+	type: "text/plain" | "text/html" | "text/markdown";
+	constructor(lang: string, text: string, type?: TranslatedText["type"]);
+	private getType;
+	get template(): string;
+	setText(value: string, type?: TranslatedText["type"]): void;
+}
+export type TranslatedModel = DataBlock & {
+	readonly id: string;
+	readonly texts: Description;
+};
+export declare class Description extends DataBlock {
+	translatedTexts: TranslatedText[];
+	getText(lang?: string): string | undefined;
+	getTemplate(lang?: string): string | undefined;
+	setText(lang: string, value?: string | null, type?: TranslatedText["type"]): TranslatedText | this | undefined;
+	static setText(element: DataBlock & {
+		description?: Description;
+	}, lang: string, value?: string | null): (DataBlock & {
+		description?: Description;
+	}) | undefined;
+}
+export declare class ConditionDef extends DataBlock {
+	oid: string;
+	formalExpression: string;
+	constructor(oid: string, formalExpression: string);
+}
+export declare class Decode extends Description {
+}
+export declare class CodeListItem extends DataBlock implements TranslatedModel {
+	codedValue: string;
+	decode: Decode;
+	description: Description | undefined;
+	constructor(codedValue: string);
+	get id(): string;
+	get texts(): Decode;
+}
+export declare class CodeList extends DataBlock {
+	oid: string;
+	name: string;
+	dataType: "integer" | "decimal" | "text" | "string";
+	codeListItems: CodeListItem[];
+	constructor(oid: string);
+	addCodeListItem(lang: string, translatedText?: string | null, codedValue?: string, index?: number): void;
+	get codedValueIncrement(): string;
+	get fingerprint(): string;
+}
+export declare class CodeListRef extends DataBlock {
+	codeList: CodeList;
+	constructor(codeList: CodeList);
+}
+export declare class Question extends Description {
+}
+export declare class FormalExpression extends DataBlock {
+	context: string;
+	code: string;
+	constructor(context?: string, code?: string);
+}
+export declare class ErrorMessage extends Description {
+}
+export type NestedData = {
+	[studyEventOID: string]: {
+		[studyEventInstance: number]: {
+			[formOID: string]: {
+				[formInstance: number]: {
+					[sectionOID: string]: {
+						[sectionInstance: number]: {
+							[itemOID: string]: PrimitiveValue;
+						};
+					};
+				};
+			};
+		};
+	};
+};
+export type FieldData = {
+	sectionOID: string;
+	sectionInstance: number;
+	itemOID: string;
+	datasetOID: string;
+	value?: PrimitiveValue;
+	missing?: string;
+	verified?: number;
+};
+declare const MissingTypes: {
+	readonly "not-available": "NAVU";
+	readonly "not-applicable": "NA";
+	readonly invalid: "INV";
+	readonly "not-asked": "NASK";
+	readonly "asked-but-unknown": "ASKU";
+};
+declare const VerifiedTypes: {
+	readonly sdv: 1;
+};
+/**
+ * While the metadata models very closely reflect the ODM metadata elements, this ItemData
+ * flattens the majority of the ODM clinicaldata elements. The reason are fast query executions
+ * without the need for expensive joins. On IndexedDB, compound indices allow a precise data
+ * query and the naming is in alignment with the ODMPath model. It remains to be evaluated how
+ * six relatively long UUIDs affect the indexing process and query performance and whether to
+ * switch to an auto-increment approach for those ODM metadata models.
+ */
+export declare class ItemData extends DataBlock implements FieldData {
+	subject: BlockReference<SubjectData>;
+	studyEventOID: string;
+	studyEventInstance: number;
+	formOID: string;
+	formInstance: number;
+	sectionOID: string;
+	sectionInstance: number;
+	itemOID: string;
+	datasetOID: string;
+	value?: FieldData["value"];
+	missing?: typeof MissingTypes[keyof typeof MissingTypes];
+	verified?: typeof VerifiedTypes[keyof typeof VerifiedTypes];
+	constructor(subject: ItemData["subject"], path?: ODMPath, value?: ItemData["value"]);
+	static getHash(data: ItemData[]): Promise<string>;
+	static get<T extends PrimitiveValue>(subject: BlockReference<SubjectData>, itemOID: string, projectUUID?: string | undefined): Promise<T | undefined>;
+}
+export declare class StudyEventGroupRef extends DataBlock {
+	studyEventGroupDef: StudyEventGroupDef;
+	mandatory: "Yes" | "No";
+	constructor(studyEventGroupDef: StudyEventGroupDef);
+	get def(): StudyEventGroupDef;
+	get oid(): string;
+}
+export declare class StudyTiming extends DataBlock {
+	oid: string;
+	studyEvent: BlockReference<StudyEventDef>;
+	predecessor?: BlockReference<StudyEventDef>;
+	absoluteTarget?: string;
+	relativeTarget?: number;
+	preWindow: number;
+	postWindow: number;
+	constructor(oid: string, studyEvent: BlockReference<StudyEventDef>);
+	get timepoints(): string[] | undefined;
+	set timepoints(values: string[] | undefined);
+	getTimepointsTexts(event?: StudyEventDef): {
+		delay: string;
+		days: string;
+		timepoints: string;
+	} | undefined;
+}
+export declare class Protocol extends DataBlock {
+	studyEventGroupRefs: StudyEventGroupRef[];
+	studyTimings: StudyTiming[];
+}
+export declare class MetaDataVersion extends DataBlock {
+	oid: string;
+	name: string;
+	protocol: Protocol | undefined;
+	constructor(oid: string, name?: string);
+	getArms(subject?: SubjectData): StudyEventGroupRef[] | undefined;
+	get studyEvents(): StudyEventRef[];
+}
+declare const StatusType: {
+	readonly INCOMPLETE: 1;
+	readonly COMPLETE: 2;
+	readonly VERIFIED: 3;
+};
+export declare class FormStatus extends DataBlock {
+	subject: BlockReference<SubjectData>;
+	studyEventOID: string;
+	studyEventInstance: number;
+	formOID: string;
+	formInstance: number;
+	value: typeof StatusType[keyof typeof StatusType];
+	locked?: boolean;
+	version?: BlockReference<ItemGroupDef>;
+	lastUpdateDatetime: number;
+	constructor(subject: FormStatus["subject"], version?: FormStatus["version"], path?: ODMPath, value?: FormStatus["value"], locked?: boolean);
+	beforeTrigger(): void;
+	getImplicitValue(skip?: boolean): 2 | 1 | 5 | 3 | 4;
+	static getIcon(value?: FormStatus["value"] | unknown): "circle-half-stroke-solid" | "circle-check-solid" | "badge-check-solid" | "shield-keyhole-solid" | "forward-solid" | "circle-duotone";
+	static getType(value?: FormStatus["value"] | unknown): "danger" | "primary" | "success" | undefined;
+	static getKey(value?: FormStatus["value"] | unknown): string;
+	static getAggregation(states: FormStatus[], originalLength: number): number;
+	setValue(form: ItemGroupRef, data: ItemData[], hiddenPaths: string[]): void;
+	getStatusByField(form: ItemGroupRef, data: ItemData[], hiddenPaths: string[], skipEmpty?: boolean): Map<ODMPath, number>;
+}
+declare const DefaultFields: {
+	readonly environment: "environment";
+	readonly location: "location";
+	readonly event: "event";
+	readonly "event-instance": "event-instance";
+	readonly form: "form";
+	readonly "form-instance": "form-instance";
+};
+export type ExpressionData = NestedData & {
+	[defaultFields in typeof DefaultFields[keyof typeof DefaultFields]]?: string;
+};
+declare const Comparators: {
+	readonly GT: ">";
+	readonly GE: ">=";
+	readonly LT: "<";
+	readonly LE: "<=";
+	readonly EQ: "==";
+	readonly NE: "!=";
+};
+export declare class RangeCheck extends DataBlock {
+	comparator?: keyof typeof Comparators;
+	checkValue?: string | number;
+	formalExpression?: FormalExpression;
+	softHard: "Soft" | "Hard";
+	errorMessage?: ErrorMessage;
+	constructor(comparator?: keyof typeof Comparators, checkValue?: string | number);
+	evaluate(value?: PrimitiveValue, siblings?: RangeCheck[], data?: ExpressionData, path?: ODMPath): boolean;
+	get logic(): string;
+	set logic(value: string);
+	get value(): string;
+	set value(value: string);
+}
+export type Right = boolean | (string | number)[];
+export declare class Role extends DataBlock {
+	name: string;
+	description?: string;
+	rights: {
+		[name: string]: Right;
+	};
+	constructor(name: string, rights?: Role["rights"]);
+}
+declare class EncryptionKey extends DataBlock {
+	owner?: BlockReference<User>;
+	credentialId: string;
+	encryptedKey: string;
+	private static cryptoKeys;
+	constructor(owner: BlockReference<User>, credentialId: string, encryptedKey: string, cryptoKey?: CryptoKey);
+	get cryptoKey(): Promise<CryptoKey>;
+	private unsetCryptoKeys;
+}
+export type TranslationOptions = {
+	key: string;
+	locale?: string;
+	pluralRule?: number;
+	interpolation?: Record<string, string | number | undefined>;
+	transform?: "upper" | "lower" | "capital" | "decapital" | "date" | "time" | "datetime" | "l10n" | "ref";
+};
+export type Notifications = "announcements" | "message-unread" | "query-assigned" | "subject-created" | "schedule-reached" | "schedule-upcoming" | "schedule-ending";
+export type NotificationVariants = `${Notifications}-${"participant" | "member"}-${"action" | "info"}`;
+declare const NotificationTypes: {
+	[type in Notifications]: {
+		limitedMethods?: Array<keyof typeof NotificationMethods>;
+	};
+};
+declare const NotificationMethods: {
+	email: string;
+	push: string;
+	app: string;
+};
+declare class Notification$1 extends DataBlock {
+	recipient?: BlockReference<User>;
+	subject?: BlockReference<SubjectData>;
+	language?: string;
+	type: keyof typeof NotificationTypes;
+	toSendBy?: {
+		[method in keyof typeof NotificationMethods]?: true;
+	} & {
+		sms?: true;
+	};
+	retries: number;
+	action?: string;
+	values?: TranslationOptions["interpolation"];
+	readAt?: number;
+	dedupe?: string;
+	constructor(recipient: Notification$1["recipient"], language: Notification$1["language"], type: Notification$1["type"], toSendBy: Notification$1["toSendBy"], action: Notification$1["action"], values: Notification$1["values"], dedupe?: Notification$1["dedupe"], subject?: Notification$1["subject"]);
+	get variant(): NotificationVariants;
+	commitDedupe(project: string): Promise<void>;
+}
+export declare class ProjectUser extends DataBlock {
+	user: User | undefined;
+	role: Role | undefined;
+	locations: BlockReference<Location$1>[];
+	participant?: BlockReference<SubjectData>;
+	preferredGivenName?: string;
+	preferredFamilyName?: string;
+	preferredEmail?: string;
+	preferredLanguage?: string;
+	notifications?: {
+		[type in keyof typeof NotificationTypes]?: {
+			[method in keyof typeof NotificationMethods]?: true;
+		};
+	};
+	encryptedPrivateProjectKey?: string;
+	private encryptionKey?;
+	constructor(user?: User, participant?: BlockReference<SubjectData>);
+	beforeTrigger(): Promise<void>;
+	hasRight(...rights: string[]): boolean;
+	inRight(value: string | number, ...rights: string[]): boolean;
+	getEncryptionKey(): Promise<EncryptionKey>;
+	getDecryptedPrivateProjectKey(): Promise<string>;
+	get defaultEmail(): string | undefined;
+	get defaultNotifications(): ProjectUser["notifications"];
+	get isOwner(): boolean;
+	get givenName(): string | undefined;
+	get familyName(): string | undefined;
+	get email(): string | undefined;
+	get language(): string | undefined;
+	get fullName(): string | undefined;
+	get type(): "team-member" | "study-participant";
+	getMemberNameOrSubjectId(subjects?: SubjectData[], options?: SubjectKeyOptions): string | undefined;
+	getComboboxEntry(subjects?: SubjectData[], options?: SubjectKeyOptions): {
+		value: string;
+		content: string;
+	};
+}
+export type AtomicConfig = {
+	path: string;
+	[key: string]: any;
+};
+export declare class ItemDef extends DataBlock implements TranslatedModel {
+	oid: string;
+	name: string;
+	dataType: "string" | "text" | "integer" | "decimal" | "float" | "double" | "boolean" | "date" | "time" | "datetime" | "partialDate" | "email" | "base64Binary" | "URI";
+	question: Question;
+	description: Description | undefined;
+	rangeChecks: RangeCheck[];
+	codeListRef: CodeListRef | undefined;
+	aliases: Alias[];
+	constructor(oid: string, name?: string);
+	translatedText(lang?: string, preferName?: boolean): string;
+	get fieldName(): any;
+	get suitableFields(): AtomicConfig[] | undefined;
+	get encryption(): string | undefined;
+	set encryption(value: string | undefined);
+	get id(): string;
+	get texts(): Question;
+}
+export declare class MethodDef extends ConditionDef {
+	type?: "Computation" | "Imputation" | "Transpose" | "Preload";
+}
+export declare class ItemRef extends DataBlock {
+	itemDef: ItemDef;
+	mandatory: "Yes" | "No";
+	repeat: "Yes" | undefined;
+	unitsItemDef: ItemDef | undefined;
+	collectionCondition: ConditionDef | undefined;
+	calculationMethod: MethodDef | undefined;
+	constructor(itemDef: ItemDef);
+	get def(): ItemDef;
+	get oid(): string;
+	get itemRefs(): this[];
+	get itemRef(): this;
+	get significantRef(): this;
+}
+declare const FormPurpose: {
+	eCRF: string;
+	ePRO: string;
+	eConsent: string;
+	Information: string;
+};
+export declare class ItemGroupDef extends DataBlock {
+	oid: string;
+	name: string;
+	type: "Form" | "Section" | "Dataset" | "Concept";
+	repeating: "No" | "Simple" | "Dynamic" | "Static";
+	repeatingLimit?: number;
+	hasNoData: "Yes" | undefined;
+	description: Description;
+	itemOrGroupRefs: (ItemGroupRef | ItemRef)[];
+	aliases: Alias[];
+	purpose?: keyof typeof FormPurpose;
+	constructor(oid: string, type: ItemGroupDef["type"], name?: string);
+	get formFields(): (ItemGroupRef | ItemRef)[];
+	get datasetType(): "choices" | "questions" | undefined;
+	get assignedElements(): (ItemGroupRef | ItemRef)[];
+	get itemGroupRefs(): ItemGroupRef[];
+	get itemRefs(): ItemRef[];
+	get fieldName(): any;
+	get suitableFields(): AtomicConfig[] | undefined;
+	get languages(): string[];
+	get firstMatchingLanguage(): string;
+	get version(): number | undefined;
+	set version(value: number | undefined);
+	get headerHeight(): number | undefined;
+	set headerHeight(value: number | undefined);
+	get headerImage(): string | undefined;
+	set headerImage(value: string | undefined);
+	private headerUrlPromise?;
+	get headerUrl(): Promise<string | undefined>;
+}
+export declare class ItemGroupRef extends DataBlock {
+	itemGroupDef: ItemGroupDef;
+	mandatory: "Yes" | "No";
+	collectionCondition: ConditionDef | undefined;
+	constructor(itemGroupDef: ItemGroupDef);
+	get def(): ItemGroupDef;
+	get oid(): string;
+	get itemRefs(): ItemRef[];
+	get itemRef(): ItemRef | undefined;
+	get significantRef(): ItemGroupRef | ItemRef | undefined;
+	get itemDef(): ItemDef | undefined;
+}
+export declare class StudyEventDef extends DataBlock {
+	oid: string;
+	name: string;
+	repeating: "Yes" | "No";
+	repeatingLimit?: number;
+	type: "Scheduled" | "Unscheduled" | "Common";
+	description: Description;
+	itemGroupRefs: ItemGroupRef[];
+	aliases: Alias[];
+	constructor(oid: string);
+	get assignedElements(): ItemGroupRef[];
+	get referenceDateItemOID(): string | undefined;
+}
+export declare class StudyEventRef extends DataBlock {
+	studyEventDef: StudyEventDef;
+	mandatory: "Yes" | "No";
+	collectionCondition: ConditionDef | undefined;
+	constructor(studyEventDef: StudyEventDef);
+	get def(): StudyEventDef;
+	get oid(): string;
+}
+export declare class StudyEventGroupDef extends DataBlock {
+	oid: string;
+	name: string;
+	description?: Description;
+	studyEventRefs: StudyEventRef[];
+	aliases: Alias[];
+	armOID?: string;
+	constructor(oid: string);
+	get assignedElements(): StudyEventRef[];
+}
+export declare class SettingData<T extends FieldData["value"]> extends DataBlock implements FieldData {
+	moduleName: string;
+	sectionOID: string;
+	sectionInstance: number;
+	itemOID: string;
+	datasetOID: string;
+	value?: T;
+	constructor(moduleName: string, path?: ODMPath, value?: T);
+	static get<T extends PrimitiveValue>(itemOID: string, projectUUID?: string | undefined): Promise<T | undefined>;
+}
+export type SubjectKeyOptions = {
+	minLengthPadding?: number;
+	manualEntryPrefix?: string;
+	autoIncrementPrefix?: string;
+	locationIdPrefix?: Record<string, string>;
+};
+export declare class SubjectData extends DataBlock {
+	subjectKey: string;
+	locationCount: number | undefined;
+	location: BlockReference<Location$1> | undefined;
+	arms: BlockReference<StudyEventGroupDef>[] | undefined;
+	constructor(subjectKey?: string, location?: BlockReference<Location$1>);
+	beforeTrigger(): Promise<void>;
+	getPlainKey(): string;
+	getKeyPrefix(options: SubjectKeyOptions): string;
+	getId(options: SubjectKeyOptions): string;
+	getIdAsync(): Promise<string>;
+	static getKeyPrefix(subjectKey: string | undefined, locationUUID: string | undefined, options: SubjectKeyOptions): string;
+	static getPlainKey(subjectKey: string | undefined, locationCount: number | undefined): string;
+	static getId(subjectKey: string | undefined, locationCount: number | undefined, locationUUID: string | undefined, options: SubjectKeyOptions): string;
+	static getSubjectKeyOptions(settings?: SettingData<any>[], locations?: Location$1[]): SubjectKeyOptions;
+	static fetchSubjectKeyOptions(projectUUID?: string | undefined): Promise<SubjectKeyOptions>;
+	editableBy(user?: ProjectUser, action?: string): boolean | BlockReference<Location$1> | undefined;
+	viewableBy(user?: ProjectUser): boolean | BlockReference<Location$1> | undefined;
+}
+export declare class CalendarEvent extends DataBlock {
+	owner: BlockReference<User>;
+	subject?: BlockReference<SubjectData>;
+	studyEventOID?: string;
+	studyEventInstance?: number;
+	name?: string;
+	description?: string;
+	private startDateUTC;
+	private startTimeUTC?;
+	private endDateUTC;
+	private endTimeUTC?;
+	shared?: boolean;
+	constructor(owner: BlockReference<User>, startDate: string);
+	get startDate(): string;
+	set startDate(value: string);
+	get startTime(): string | undefined;
+	set startTime(value: string | undefined);
+	get endDate(): string;
+	set endDate(value: string);
+	get endTime(): string | undefined;
+	set endTime(value: string | undefined);
+	transformISO(direction: "utc-to-locale" | "locale-to-utc", date: string, time?: string): {
+		date: string;
+		time: string;
+	};
+	isAllday(referenceDate?: string): boolean | "" | undefined;
+	isBetween(referenceDate?: string): boolean | "" | undefined;
+	getTime(referenceDate?: string): string | undefined;
+	get url(): string | undefined;
+}
+export declare class FileMetadata extends DataBlock {
+	fileName: string;
+	mimeType: string;
+	fileSize: number;
+	version: string;
+	policyReference?: BlockReference<DataBlock>;
+	constructor(file?: File, policyReference?: BlockReference<DataBlock>);
+	get megabytes(): string;
+}
+export declare class FileContent extends DataBlock {
+	metadata: BlockReference<FileMetadata>;
+	base64Binary?: string;
+	file?: File | string;
+	published: boolean;
+	constructor(metadata: BlockReference<FileMetadata>, file: File, published?: boolean);
+	beforeTrigger(): Promise<void>;
+	upload(callback?: (progress: number) => void): Promise<void>;
+	getUrl(expiration?: number): Promise<string>;
+	private getTemporaryObjectURL;
+	prepareSerialization(): Promise<void>;
+}
+export type SignaturePoints = {
+	time: number;
+	x: number;
+	y: number;
+	pressure: number;
+}[][];
+declare const SignatureStatus: {
+	readonly SIGNED: 1;
+	readonly WITHDRAWN: 2;
+};
+export declare class Signature extends DataBlock {
+	signee?: BlockReference<User>;
+	form?: BlockReference<FormStatus>;
+	signaturePoints?: SignaturePoints | string;
+	signatureURL?: string;
+	dataHash?: string;
+	status: typeof SignatureStatus[keyof typeof SignatureStatus];
+	lastUpdateDatetime: number;
+	constructor(signee?: BlockReference<User>, form?: BlockReference<FormStatus>, dataHash?: string);
+	beforeTrigger(): void;
+}
+export declare class SurveyInstance extends DataBlock {
+	id: string;
+	active: boolean;
+	studyEventInstance: number;
+	form: BlockReference<ItemGroupRef>;
+	formInstance: number;
+	subject?: BlockReference<SubjectData>;
+	expirationDate?: number;
+	showExistingData?: boolean;
+	location?: BlockReference<Location$1>;
+	constructor(studyEventInstance: number, form: SurveyInstance["form"], formInstance: number, subject?: SurveyInstance["subject"], location?: SurveyInstance["location"]);
+	getUrl(host?: string): string;
+}
+export declare class SurveySession extends DataBlock {
+	instance: BlockReference<SurveyInstance>;
+	subject?: BlockReference<SubjectData>;
+	finished?: boolean;
+	constructor(instance: SurveySession["instance"], subject: SurveySession["subject"]);
+}
+export declare class SurveySettings extends DataBlock {
+	form: BlockReference<ItemGroupRef>;
+	autoContinueForm: boolean;
+	multipleAnswers: boolean;
+	defaultExpirationTime?: number;
+	defaultShowExistingData?: boolean;
+	customColor?: string;
+	constructor(form: SurveySettings["form"]);
+}
+export declare class DocumentMetadata extends DataBlock {
+	type: "folder" | "document";
+	name?: string;
+	parent?: BlockReference<DocumentMetadata>;
+	constructor(type: DocumentMetadata["type"], parent?: DocumentMetadata["parent"]);
+}
+export declare class DocumentVersion extends DataBlock {
+	metadata: BlockReference<DocumentMetadata>;
+	major: number;
+	minor: number;
+	status: "draft" | "version";
+	name?: string;
+	lang?: string;
+	constructor(metadata: BlockReference<DocumentMetadata>, major: number, minor: number, name?: string);
+	get full(): string;
+	get text(): string;
+	static createVersion(metadata: BlockReference<DocumentMetadata>, major: number, minor: number, file?: File, content?: string, name?: string): Promise<DocumentVersion>;
+}
+export declare class DocumentContent extends DataBlock {
+	version: BlockReference<DocumentVersion>;
+	html?: string;
+	file?: BlockReference<FileContent>;
+	constructor(version: BlockReference<DocumentVersion>, html?: string, file?: BlockReference<FileContent>);
+	getFileData(): Promise<{
+		mimeType: string;
+		objectURL: string;
+	} | undefined>;
+}
+export declare class Study extends DataBlock {
+	oid: string;
+	studyName: string;
+	protocolName: string;
+	description: Description;
+	metaDataVersions: MetaDataVersion[];
+	constructor(oid: string, studyName: string, protocolName: string);
+}
+export declare class ODM extends DataBlock {
+	fileOID: string;
+	fileType: "Snapshot" | "Transactional" | "Query";
+	creationDateTime: Date;
+	odmVersion: string;
+	description?: Description;
+	studies: Study[];
+	adminData: undefined;
+	clinicalData: undefined;
+	sourceSystem: string;
+	sourceSystemVersion: any;
+	constructor(fileOID: string);
+	get metaDataVersion(): MetaDataVersion | undefined;
+}
+declare const QueryStates: {
+	readonly OPEN: "Open";
+	readonly ANSWERED: "Answered";
+	readonly RESOLVED: "Resolved";
+	readonly CANCELLED: "Cancelled";
+};
+declare const QueryTypes: {
+	readonly MANUAL: "Manual";
+	readonly SYSTEM: "System";
+};
+declare const QueryPriorities: {
+	readonly LOW: 1;
+	readonly MEDIUM: 2;
+	readonly HIGH: 3;
+};
+export declare class DataQuery extends DataBlock {
+	oid: string;
+	name: string;
+	value: string;
+	owner?: BlockReference<User>;
+	subject?: BlockReference<SubjectData>;
+	studyEventOID: string;
+	studyEventInstance: number;
+	formOID: string;
+	formInstance: number;
+	sectionOID: string;
+	sectionInstance: number;
+	itemOID: string;
+	datasetOID: string;
+	state: typeof QueryStates[keyof typeof QueryStates];
+	responsible?: BlockReference<User>;
+	type: typeof QueryTypes[keyof typeof QueryTypes];
+	lastUpdateDatetime: number;
+	involved: BlockReference<User>[];
+	priority: typeof QueryPriorities[keyof typeof QueryPriorities];
+	dueDate?: string;
+	constructor(oid: string, owner?: BlockReference<User>, subject?: BlockReference<SubjectData>, path?: ODMPath);
+	get isNew(): boolean;
+	nextStates(user: ProjectUser): ("Open" | "Answered" | "Resolved" | "Cancelled")[];
+	beforeTrigger(): void;
+	mayBeEditedBy(user: ProjectUser): boolean;
+	static isPending(value: DataQuery["state"] | unknown): boolean;
+}
+declare const RandomizationStatus: {
+	readonly draft: "draft";
+	readonly review: "review";
+	readonly confirmed: "confirmed";
+};
+export declare class RandomizationInfo extends DataBlock {
+	status: keyof typeof RandomizationStatus;
+	stratification: {
+		location?: boolean;
+		itemOIDs?: string[];
+	};
+}
+export declare class RandomizationSchedule extends DataBlock {
+	plan: BlockReference<RandomizationPlan>;
+	order: number;
+	block: number;
+	subjectKey: number;
+	studyArm: BlockReference<StudyEventGroupDef>;
+	stratification?: {
+		locationUUID?: string;
+		[itemOID: string]: string | undefined;
+	};
+	assignedSubject?: BlockReference<SubjectData>;
+	constructor(plan: RandomizationSchedule["plan"], order: number, block: number, subjectKey: number, studyArm: RandomizationSchedule["studyArm"]);
+	static randomizeSubject(info: RandomizationPlan["info"], subject: SubjectData): Promise<void>;
+}
+declare const RandomizationMethods: {
+	"simple-randomization": {
+		blocks: false;
+		strata: false;
+	};
+	"permuted-block-randomization": {
+		blocks: true;
+		strata: false;
+	};
+	"stratified-block-randomization": {
+		blocks: true;
+		strata: true;
+	};
+};
+export declare class RandomizationPlan extends DataBlock {
+	version: number;
+	info: RandomizationInfo;
+	arms: {
+		[studyEventGroupOID: string]: {
+			decode: string;
+			ratio: number;
+		};
+	};
+	methods: {
+		type: keyof typeof RandomizationMethods;
+		blockSizes?: number[];
+	};
+	subjects: {
+		number: number;
+		start: number;
+	};
+	beforeTrigger(): void;
+	get ratioSum(): number;
+	get blockSum(): number;
+	generateRandomizationSchedule(metadata: MetaDataVersion, locations: Location$1[]): Promise<RandomizationSchedule[]>;
+	private getStratificationGroups;
+	private getShuffledSubjectKeys;
+	private getShuffledArmOIDsByRatio;
+}
+export type FieldItemReference = {
+	defaultFields?: string[];
+	formFields?: string[];
+	formPaths?: string[];
+	odmPaths?: string[];
+};
+declare const ProcessingMethods: Record<string, {
+	evaluate: (type: ItemDef["dataType"], scale: "categorical" | "quantitative" | "discrete") => boolean;
+	aggregation?: (values: (string | number)[]) => number;
+	binning?: {
+		transform: (value: string, translate?: boolean) => string;
+		bins?: (translate?: boolean) => string[];
+	};
+}>;
+export declare class ChartSettings extends DataBlock {
+	description?: string;
+	chartName: string;
+	dimensions: {
+		[name: string]: FieldItemReference;
+	};
+	processing: {
+		[field: string]: keyof typeof ProcessingMethods;
+	};
+	size: "small" | "medium" | "large";
+	constructor(chartName: string);
+	get config(): AtomicConfig | undefined;
+}
+export declare class ReportSettings extends DataBlock {
+	name?: string;
+	owner: BlockReference<User>;
+	sharedUsers: BlockReference<User>[];
+	location?: BlockReference<Location$1>;
+	filters: ChartSettings[];
+	charts: ChartSettings[];
+	translateTexts: boolean;
+	shared: boolean;
+	constructor(owner: BlockReference<User>, translateTexts: boolean);
+}
+declare class ShareableBlock extends DataBlock {
+	owner: BlockReference<User>;
+	sharedWithMembers?: boolean;
+	sharedWithParticipants?: boolean;
+	locationsFilter?: BlockReference<Location$1>[];
+	usersFilter?: BlockReference<User>[];
+	collaborators?: BlockReference<User>[];
+	constructor(owner: BlockReference<User>);
+	get explicitUsers(): BlockReference<User>[];
+	userHasAccess(user?: ProjectUser, subjects?: SubjectData[]): boolean | undefined;
+	userMayEdit(user?: ProjectUser): boolean | undefined;
+	usersLocationFilter(user?: ProjectUser, subjects?: SubjectData[]): boolean | undefined;
+}
+export declare class MessengerChannel extends ShareableBlock {
+	title?: string;
+	getLocalizedTitle(users?: ProjectUser[], locations?: Location$1[], subjects?: SubjectData[], options?: SubjectKeyOptions, locale?: string): string;
+}
+export declare class ChannelMessage extends DataBlock {
+	channel: BlockReference<MessengerChannel>;
+	author: BlockReference<User>;
+	text: string;
+	constructor(channel: BlockReference<MessengerChannel>, author: BlockReference<User>, text: string);
+}
+export declare class ChannelStatus extends DataBlock {
+	channel: BlockReference<MessengerChannel>;
+	owner: BlockReference<User>;
+	lastReadMessageUUID?: string;
+	notificationForMessageUUID?: string;
+	constructor(channel: BlockReference<MessengerChannel>, owner: BlockReference<User>);
+}
+export type LoginParameters = {
+	serverUrl: string;
+	apiKey: string;
+};
+export declare const login: ({ serverUrl, apiKey }: LoginParameters) => Promise<User>;
+export declare const logout: () => Promise<void>;
+export declare const scope: (project: Project) => void;
+
+export {
+	Location$1 as Location,
+	Notification$1 as Notification,
+};
+
+export {};