import { WithNote, WithId } from "../shared/utils.js";
import { Concept, Person, Software, WithActor } from "./Agent.js";
/**
 * The certainties a belief may be held with, from the most certain to
 * the least.
 * @category Vocabulary
 */
export declare const certainties: readonly ['true', 'likely', 'possible', 'unlikely', 'false'];
/**
 * Certainty levels for beliefs, ranging from 'true' to 'false'
 * and some values in between.
 * @category Format types
 */
export type Certainty = typeof certainties[number];
/**
 * Whether a statement held with this certainty is stated as a fact when
 * the edition is read as RDF. One held possible, unlikely or false is
 * only quoted, so that a reader who leaves the beliefs aside does not
 * take a doubted statement for the edition's own.
 * @category Assumptions and beliefs
 */
export declare const isAsserted: (certainty: Certainty) => boolean;
/**
 * The certainty a statement is held with. One that carries no belief is
 * stated plainly, and so held true.
 * @category Assumptions and beliefs
 */
export declare const certaintyOf: (assumption: Readonly<Assumption>) => Certainty;
/**
 * An argumentation provides reasons for a belief and
 * may be associated with a person carrying out that argumentation.
 * @see crminf:I1 Argumentation
 * @category Format types
 */
export interface Argumentation<T extends string = 'simpleArgumentation'> extends WithActor, WithNote {
    type: T;
}
/**
 * A meaning comprehension interprets or disambiguates the meaning of
 * symbols or features. For example, interpreting a pencil mark
 * as an instruction to add or remove a perforation or as the dating
 * of the roll.
 * @see crminf:I16 Meaning Comprehension
 * @category Format types
 */
export interface MeaningComprehension extends Argumentation<'meaningComprehension'> {
    /**
     * References (by `@id`) to the symbols or features
     * whose meaning is being interpreted.
     * @see crminf:J22 interpreted meaning of
     */
    comprehends: string[];
}
/**
 * An inference draws a conclusion from given premises.
 * @see crminf:I5 Inference Making
 * @category Format types
 */
export interface Inference extends Argumentation<'inference'> {
    /**
     * References (by `@id`) to the beliefs
     * from which the conclusion is drawn.
     *
     * A belief the editor holds and publishes elsewhere under an IRI of
     * its own, such as a bound from a catalogue of premises the editor
     * keeps, is named by that IRI. Someone else's belief is not: it is
     * adopted first, and the belief of the edition's own that the
     * adoption concludes is named instead.
     * @see crminf:J1 used as premise
     */
    premises: string[];
    /**
     * References (by `@id`) to what the inference worked on besides
     * beliefs, such as the versions it compared, the analysis output it
     * cites, or the document holding a premise named by IRI, in the
     * state it was read in, since a belief published elsewhere may move
     * after the edition has used it.
     * @see crm:P16 used specific object
     */
    used?: string[];
    /**
     * The rules the inference draws its conclusion by, by IRI: a
     * regularity of how the rolls were edited, such as that the same
     * addition at the same place is not made twice independently, a
     * default, such as that copies were not made from two exemplars, or
     * a method, such as how the tolerance of a collation is found. The
     * rules are stated once where they are published, and each
     * inference names those it follows, so that a reader can see what
     * a conclusion rests on besides its premises, and which conclusions
     * rest on a rule.
     * @see crminf:J3 applied
     */
    applies?: string[];
}
/**
 * A belief adoption takes over someone else's belief without checking it:
 * knowledge through private communication, from the secondary
 * literature, or from another edition. Like every reason, it concludes
 * the belief it is a reason of, which is the edition's own and holds of
 * the edition's statement what the adopted belief held. An inference that
 * relies on it names that belief among its premises.
 *
 * The editor's own beliefs need no adoption, wherever they are
 * published: an inference names them directly (see `Inference`).
 * @see crminf:I7 Belief Adoption
 * @category Format types
 */
export interface BeliefAdoption extends Argumentation<'beliefAdoption'> {
    /**
     * A note describing the source of the adopted belief,
     * e.g. a bibliographic reference or personal communication.
     * Where the belief is adopted by its IRI, the note says in which
     * state it was taken over, since a belief published elsewhere may
     * move after the edition has taken it.
     * @see crm:P3 has note
     */
    note: string;
    /**
     * The beliefs this adoption takes over, by IRI, where they are
     * published with one. They are someone else's, and stay theirs: what
     * the edition holds is the belief the adoption concludes.
     * @see crminf:J6 adopted
     */
    adopted?: string[];
}
/**
 * A measurement takes a value off an object by a stated procedure: the
 * period the slot lengths of a copy keep, the median pitch of its held
 * notes. It concludes the belief in that value by itself, with no
 * premises. CRMinf counts observations, and a measurement is one, among
 * the ways a belief comes about, so the value does not have to be
 * passed off as an inference.
 *
 * A measurement a program took names the program and its version, so
 * that the value can be taken again and a value taken by a program
 * later found wanting can be told from the rest. Naming software makes
 * it a digital measurement event in the sense of CRMdig.
 * @see crmsci:S21 Measurement
 * @category Format types
 */
export interface Measurement extends Argumentation<'measurement'> {
    /**
     * References (by `@id` or URL) to what the measurement was taken on
     * or with, such as the scan, the analysis output or the script.
     * @see crm:P16 used specific object
     */
    used?: string[];
    /**
     * The method followed, where it has a name apart from the program
     * that carries it out, such as a line of Theil and Sen through the
     * matched notes of two copies.
     * @see crm:P33 used specific technique
     */
    procedure?: Concept;
    /**
     * The programs that took the measurement, each with its version.
     * @see crmdig:L23 used software or firmware
     */
    software?: Software[];
    /**
     * When the measurement was taken. It is part of the reason and
     * carries no belief of its own.
     * @see crm:P4 has time-span
     */
    date?: TimeSpan;
}
/**
 * An argumentation can be either a plain argumentation, a
 * meaning comprehension, an inference, a belief adoption or a
 * measurement.
 * @category Format types
 */
export type AnyArgumentation = MeaningComprehension | Inference | BeliefAdoption | Measurement | Argumentation;
/**
 * A belief is a temporal object and associates a proposition (i.e.
 * a statement) with a certainty. It comes into existence through
 * argumentations (reasons).
 * @see crminf:I2 Belief
 * @category Format types
 */
export interface Belief extends WithId {
    type: 'belief';
    /**
     * The level of certainty associated with this belief.
     * @see crminf:J5 holds to be
     */
    certainty: Certainty;
    /**
     * The argumentations providing reasons for this belief.
     * @see crminf:J2i was concluded by
     */
    reasons: AnyArgumentation[];
}
/**
 * An assumption is the reification of a triple. This leverages the
 * `@annotation` element from JSON-LD-star. Any property in the edition
 * can be annotated with a belief to express uncertainty or provide
 * justification for the stated value.
 * @category Format types
 */
export interface Assumption {
    /**
     * An optional annotation expressing a belief about this assumption.
     * Uses the JSON-LD-star `@annotation` mechanism to attach
     * epistemic metadata (certainty and reasons) to any triple.
     *
     * A statement that carries none is stated plainly, and what a
     * program concluded is stated so too: an edition asserts its stemma
     * and its edits, as a printed edition does, and its creation names
     * the principles and the release they were found by
     * (`EditionCreation`). A belief is kept for what the editor doubts.
     */
    '@annotation'?: WithId & {
        /**
         * The belief held about the annotated statement.
         * @see crminf:J4i is subject of
         */
        belief: Belief;
    };
}
/**
 * A value assumption wraps a literal value, e.g. a string, a number, a date, with an optional annotation.
 * Used for properties where the value itself may be uncertain,
 * e.g. dates.
 * @category Format types
 */
export interface ValueAssumption<ValueT> extends Assumption {
    /**
     * The assumed value.
     */
    '@value': ValueT;
}
/**
 * A reference assumption wraps a reference (by `@id`) with an optional annotation.
 * Used when pointing to another entity whose association may be uncertain.
 * @category Format types
 */
export type ReferenceAssumption = Assumption & WithId;
/**
 * An object assumption wraps a complex object with an optional annotation.
 * Used for structured values (e.g. persons, conditions) whose properties
 * may be uncertain.
 * @category Format types
 */
export type ObjectAssumption<O extends object> = Assumption & O;
/**
 * An actor assignment associates a person with an action.
 * It is an object assumption so that the attribution can be
 * annotated with a belief about its certainty.
 * @category Format types
 */
export type ActorAssignment = ObjectAssumption<Person>;
/** @inline */
interface DateWithin {
    /**
     * The day the event falls within.
     * @format date
     * @see crm:P82 at some time within
     */
    within: Date;
}
/** @inline */
interface DateAfter {
    /**
     * The earliest day the event can have happened on: it did not
     * happen before it.
     * @format date
     * @see crm:P82a begin of the begin
     */
    after: Date;
    /**
     * The latest day the event can have happened on: it did not
     * happen after it.
     * @format date
     * @see crm:P82b end of the end
     */
    before?: Date;
}
/** @inline */
interface DateBefore {
    /**
     * The earliest day the event can have happened on: it did not
     * happen before it.
     * @format date
     * @see crm:P82a begin of the begin
     */
    after?: Date;
    /**
     * The latest day the event can have happened on: it did not
     * happen after it.
     * @format date
     * @see crm:P82b end of the end
     */
    before: Date;
}
/**
 * When something happened: the day it falls `within`, or the bounds it
 * lies between. A bound nobody can give is left out, so `after` alone
 * says "not before".
 * @see crm:E52 Time-Span
 * @category Format types
 */
export type TimeSpan = DateWithin | DateAfter | DateBefore;
/**
 * When something happened, as far as the edition can state it, and as
 * an assumption, so that a dating can carry the belief it rests on: the
 * day it falls `within`, or the bounds it lies between. A bound nobody
 * can give is left out, so `after` alone says "not before".
 * @see crm:E52 Time-Span
 * @category Format types
 */
export type DateAssignment = Assumption & TimeSpan;
/**
 * The value the assumption holds, without the belief about it.
 * @category Assumptions and beliefs
 */
export declare function valueOf<ValueT>(assumption: ValueAssumption<ValueT>): ValueT;
/**
 * The values the assumptions hold, in their order.
 * @category Assumptions and beliefs
 */
export declare function valuesOf<ValueT>(assumptions: ValueAssumption<ValueT>[]): ValueT[];
/**
 * The id of the entity the reference points to.
 * @category Lookups
 */
export declare function idOf(assumption: ReferenceAssumption): string;
/**
 * The ids of the entities the references point to, in their order.
 * @category Lookups
 */
export declare function idsOf(assumptions: ReferenceAssumption[]): string[];
/**
 * The value stated plainly: an assumption that carries no belief, and
 * so is held true.
 * @category Assumptions and beliefs
 */
export declare function assignValue<ValueT>(value: ValueT): ValueAssumption<ValueT>;
/**
 * A reference to the entity with the id, stated plainly: an assumption
 * that carries no belief, and so is held true.
 * @category Assumptions and beliefs
 */
export declare function assignReference(id: string): ReferenceAssumption;
/**
 * The object stated plainly: an assumption that carries no belief, and
 * so is held true. The object given is copied rather than changed.
 * @category Assumptions and beliefs
 */
export declare function assignObject<O extends object>(obj: O): ObjectAssumption<O>;
/**
 * A date the edition states: the day the event falls within.
 * @category Assumptions and beliefs
 */
export declare const assignDate: (within: Date) => DateAssignment;
/**
 * A date the edition can only bound from below, as in "not before 1924".
 * @category Assumptions and beliefs
 */
export declare const notBefore: (after: Date) => DateAssignment;
/**
 * A date the edition can only bound from above.
 * @category Assumptions and beliefs
 */
export declare const notAfter: (before: Date) => DateAssignment;
/**
 * The day the event falls within, where the edition states one.
 * @category Assumptions and beliefs
 */
export declare const dateOf: (assignment: DateAssignment) => Date | undefined;
/**
 * The earliest the event can have happened, as far as the edition states it.
 * @category Assumptions and beliefs
 */
export declare const earliestOf: (assignment: DateAssignment) => Date | undefined;
/**
 * The latest the event can have happened, as far as the edition states it.
 * @category Assumptions and beliefs
 */
export declare const latestOf: (assignment: DateAssignment) => Date | undefined;
export {};