avouch 0.1.22

package/dist/src/expr.d.ts

@@ -0,0 +1,209 @@
+export type Scalar = "enum" | "timestamp" | "duration" | "date" | "timezone" | "id" | "integer" | "number" | "boolean" | "string" | {
+    ref: string;
+};
+export type Type = Scalar | {
+    set: Scalar;
+};
+export declare const SCALAR_TYPE_NAMES: readonly ["enum", "timestamp", "duration", "date", "timezone", "id", "integer", "number", "boolean", "string"];
+export declare const EXPR_NODES: readonly ["ref", "lit", "plus", "dateIn", "derived", "eq", "neq", "lt", "lte", "gt", "gte", "and", "or", "not", "in", "subsetOf", "isNull", "isNotNull", "exists", "none", "all", "nav"];
+export type Lit = string | number | (string | number)[];
+export type Nav = {
+    nav: {
+        from: {
+            ref: string;
+        };
+        link: string;
+        dir: "forward" | "reverse";
+    };
+};
+export type Quantifier = {
+    as: string;
+    in: Nav;
+    where?: Expr;
+};
+export type ValueExpr = {
+    ref: string;
+} | {
+    lit: Lit;
+} | {
+    plus: [Expr, Expr];
+} | {
+    dateIn: [Expr, Expr];
+} | {
+    derived: {
+        id: string;
+        of: {
+            ref: string;
+        };
+    };
+};
+export type PredicateExpr = {
+    eq: [Expr, Expr];
+} | {
+    neq: [Expr, Expr];
+} | {
+    lt: [Expr, Expr];
+} | {
+    lte: [Expr, Expr];
+} | {
+    gt: [Expr, Expr];
+} | {
+    gte: [Expr, Expr];
+} | {
+    and: Expr[];
+} | {
+    or: Expr[];
+} | {
+    not: [Expr];
+} | {
+    in: [Expr, Expr];
+} | {
+    subsetOf: [Expr, Expr];
+} | {
+    isNull: [Expr];
+} | {
+    isNotNull: [Expr];
+} | {
+    exists: Quantifier;
+} | {
+    none: Quantifier;
+} | {
+    all: Quantifier;
+};
+export type Expr = ValueExpr | PredicateExpr;
+export declare const DISPOSITION_CLASSES: readonly ["rejected", "recorded", "pending", "applied"];
+export type DispositionClass = (typeof DISPOSITION_CLASSES)[number];
+export declare const INVOCATION_RESULTS: readonly ["REPLAYED", "IDEMPOTENCY_CONFLICT", "INVALID_BINDING", "SCOPE_DENIED", "PERMISSION_DENIED"];
+export type Principals = {
+    kinds: string[];
+    cite?: unknown;
+};
+export type Alt = {
+    keys: string[];
+    conditional_keys?: string[];
+    conditional_when?: Expr;
+    principals?: Principals;
+};
+export type Permission = "unknown" | {
+    none: string;
+    principals?: Principals;
+} | Alt | {
+    any_of: Alt[];
+};
+export type DecisionRow = {
+    when: {
+        passes: string;
+    } | {
+        fails: string;
+    };
+    result: string;
+    next?: unknown;
+};
+export type Decision = {
+    hitPolicy: "first";
+    rows: DecisionRow[];
+    otherwise?: {
+        result: string;
+        next?: unknown;
+    };
+};
+export type Condition = {
+    id: string;
+    expr?: Expr;
+    unspecified?: string;
+};
+export type ActionType = {
+    parameters?: Record<string, {
+        type?: Type;
+        optional?: true;
+        values?: string[];
+        projectedFrom?: string[];
+        unresolved?: "domain";
+    }>;
+    permission: Permission;
+    conditions: Condition[];
+    decision?: Decision;
+};
+export declare function projectedFields(p: {
+    type?: unknown;
+    projectedFrom?: unknown;
+}): string[] | null;
+export declare function resolvesInDomain(p: {
+    type?: unknown;
+    optional?: unknown;
+    projectedFrom?: unknown;
+    unresolved?: unknown;
+}): boolean;
+export interface Stage1Ontology {
+    scope?: {
+        by: string;
+        global?: {
+            type: string;
+        }[];
+        root?: {
+            type: string;
+        };
+    };
+    dispositions?: Record<string, {
+        class: DispositionClass;
+    }>;
+    objectTypes: Record<string, {
+        datasource: string;
+        properties: Record<string, {
+            type?: Type;
+            from?: {
+                field: string;
+                key: string;
+            };
+        }>;
+    }>;
+    linkTypes: {
+        id: string;
+        from: string;
+        to: string;
+        via: string;
+        table?: string;
+    }[];
+    derivedProperties?: Record<string, {
+        of: string;
+        type?: Type;
+        expr?: Expr;
+    }>;
+    actionTypes: Record<string, ActionType>;
+}
+export declare class ExprError extends Error {
+    readonly path: string;
+    constructor(path: string, msg: string);
+}
+export interface ExprReads {
+    reads: {
+        prop: string;
+        lit?: string;
+    }[];
+    literals: (string | number)[];
+    undefinedDerived: Set<string>;
+}
+export declare const newReads: () => ExprReads;
+export type ExprContext = {
+    action?: string;
+    self?: string;
+    locals: Record<string, string>;
+    collect?: ExprReads;
+    nested?: boolean;
+};
+export declare const RESERVED_NAMES: readonly ["now", "actor", "self"];
+export declare const DATE_RE: RegExp;
+export declare const TIMESTAMP_MIN = -62135510400000;
+export declare const TIMESTAMP_MAX = 253402214399999;
+export declare const isObj: (x: unknown) => x is Record<string, any>;
+export declare const own: <V>(r: Readonly<Record<string, V>> | undefined, k: string) => V | undefined;
+export declare function typeEquals(a: Type | "string", b: Type | "string"): boolean;
+export declare function validTimezone(v: string): boolean;
+export declare function fitsType(v: unknown, t: Type | "string"): boolean;
+export declare function objectBinding(ont: Stage1Ontology, name: string, ctx: ExprContext): string | undefined;
+export declare function isPureLink(ont: Stage1Ontology, link: Stage1Ontology["linkTypes"][number]): boolean;
+export declare function navType(ont: Stage1Ontology, n: unknown, ctx: ExprContext, at: string): string;
+export declare function checkPredicate(ont: Stage1Ontology, expr: unknown, ctx: ExprContext): void;
+export declare function checkPermissionWhen(ont: Stage1Ontology, expr: unknown, action: string, collect?: ExprReads): void;
+export declare function derivedPropertyType(ont: Stage1Ontology, id: string, collect?: ExprReads): Type;
+export declare function valueType(ont: Stage1Ontology, expr: unknown, ctx: ExprContext, expected?: Type): Type;