@google-cloud/kcmd 0.0.0-stage → 0.2.0

package/build/ts/kcmd/semantic/ir.d.ts

@@ -0,0 +1,589 @@
+/**
+ * AI-first annotations, from the open format's `ai_context`.
+ *
+ * The format allows either a bare instructions string (shorthand) or a
+ * structured object; the loader normalizes both to this one shape, so the IR
+ * always sees the structured form. The parts are grouped in a single object
+ * (mirroring the format, e.g. Apache Ossie's `ai_context`) rather than scattered
+ * as sibling fields, so nothing is lost and an emitter can still route each part
+ * to its own destination (e.g. `instructions` -> a Guidelines aspect,
+ * `synonyms` -> glossary links).
+ */
+export interface AiContext {
+    instructions?: string;
+    synonyms?: string[];
+    examples?: string[];
+    additionalProperties?: Record<string, unknown>;
+}
+/**
+ * A vendor-scoped extension block, carried verbatim from the open format's
+ * `custom_extensions` (e.g. Apache Ossie's `OSICustomExtension`).
+ *
+ * `data` is opaque to the IR — a vendor-serialized payload (typically a JSON
+ * string) — and is preserved unparsed so nothing is lost and a 1P round-trip
+ * stays lossless. Typed views over specific vendors are derived by the
+ * consumers that need them, from this same source.
+ */
+export interface CustomExtension {
+    vendorName: string;
+    data: string;
+}
+/**
+ * A semantic model: a graph of entities (nodes) connected by relationships
+ * (edges), with model-level metrics defined over them.
+ *
+ * The IR is primarily semantics. The loader reads a model's named
+ * `deployments:` list onto `deployments`. In the Google flavor it also folds
+ * their target URIs into a model-level GOOGLE `custom_extensions` block for the
+ * consumers that read it. A vanilla model lists its deployments in its GOOGLE
+ * block, which the loader reads and does not fold.
+ */
+export interface SemanticModel {
+    name: string;
+    description?: string;
+    aiContext?: AiContext;
+    entities: Entity[];
+    relationships: Relationship[];
+    metrics: Metric[];
+    actions?: Action[];
+    constraints?: Constraint[];
+    customExtensions?: CustomExtension[];
+    version?: '0.2.0.dev0' | '0.2.0.dev0/google';
+    profiles?: ProfileSpec[];
+    deployments?: DeploymentSpec[];
+    excludedMetrics?: string[];
+}
+/**
+ * An entity: a node in the semantic graph. Backed by a physical table
+ * (`dataSource`), identified by `keys`, and carrying its dimension `fields`.
+ */
+export interface Entity {
+    name: string;
+    dataSource: string;
+    authoredSource?: string;
+    sourceDialect?: string;
+    keys: string[];
+    uniqueKeys?: string[][];
+    extends?: string[];
+    abstract?: boolean;
+    description?: string;
+    aiContext?: AiContext;
+    fields: Field[];
+    customExtensions?: CustomExtension[];
+    excludedFields?: string[];
+}
+/**
+ * Dimension metadata on a field, mirroring the open format's `dimension` block
+ * (e.g. Apache Ossie's `OSIDimension`). An empty block still marks the field as
+ * a dimension, which enables temporal inference from `type` (see
+ * isTimeDimension).
+ */
+export interface Dimension {
+    isTime?: boolean;
+}
+export declare const ALLOWED_DIALECTS: readonly ["ANSI_SQL", "BIGQUERY", "SPANNER", "MYSQL", "POSTGRES", "ALLOYDB", "SQLSERVER", "SNOWFLAKE", "DATABRICKS"];
+export type SqlDialect = (typeof ALLOWED_DIALECTS)[number];
+export interface DialectExpression {
+    dialect: SqlDialect;
+    expression: string;
+}
+/**
+ * A field: a dimension / attribute of an entity or relationship.
+ *
+ * Fields describe the data; aggregates are expressed as model-level `Metric`s,
+ * not fields.
+ *
+ * Expression fidelity: the format may supply an expression in several SQL
+ * dialects (or as a single string in the Google flavor). The loader keeps every
+ * entry in `dialects` in the order written and records `stringForm` (`true`
+ * when authored as `expression: "<sql>"`, `false` when authored as a `dialects`
+ * list). It also populates `expression` (the target-dialect text, or else the
+ * `ANSI_SQL` one) and `importedExpression` (the first other vendor entry, with
+ * its `importedDialect`) via `pickDialect`. A bound field sets at least one of
+ * `expression`, `importedExpression` or a non-empty `dialects` (the loader sets
+ * one of the first two whenever it writes the third). When only
+ * `importedExpression` is present, `expression` awaits a transpile pass (see
+ * ./transpile) that fills it from the imported form.
+ */
+export interface Field {
+    name: string;
+    expression?: string;
+    importedExpression?: string;
+    importedDialect?: string;
+    dialects?: DialectExpression[];
+    stringForm?: boolean;
+    dimension?: Dimension;
+    label?: string;
+    description?: string;
+    type?: DataType;
+    aiContext?: AiContext;
+    customExtensions?: CustomExtension[];
+}
+/**
+ * The open format's `datatype` vocabulary, mirroring Apache Ossie's `DataType`:
+ * a CLOSED, case-sensitive set of logical types, independent of physical
+ * representation. It is optional; omit it when the type is unknown. `Opaque`
+ * marks an unknown type: the loader reads it as no type, and the catalog stores
+ * it where a type is required. No custom extension supplies a real type for
+ * it. The loader enforces this set at parse time, so a `type` on the IR is
+ * always one of these.
+ */
+export declare const DATA_TYPES: readonly ["String", "Integer", "Decimal", "Float", "Boolean", "Date", "Time", "DateTime", "DateTimeTz", "Opaque"];
+export type DataType = typeof DATA_TYPES[number];
+/**
+ * Normalizes a raw `datatype` string according to the document's flavor.
+ *
+ * In `0.2.0.dev0`, matching is strictly case-sensitive. In `0.2.0.dev0/google`,
+ * matching is case-insensitive and returns the canonical spelling. In both
+ * flavors, an omitted `datatype` and `Opaque` normalize to `type: undefined`.
+ */
+export declare function normalizeDataType(raw: string | undefined, version: '0.2.0.dev0' | '0.2.0.dev0/google'): {
+    ok: true;
+    type: Exclude<DataType, 'Opaque'> | undefined;
+} | {
+    ok: false;
+};
+/**
+ * A field's effective temporal-dimension role, mirroring the open format's
+ * `is_time_dimension()` (e.g. Apache Ossie's `OSIField`): a field must carry
+ * `dimension` metadata to be a dimension at all; within it an explicit `isTime`
+ * takes precedence, otherwise the role defaults from a temporal `type`.
+ */
+export declare function isTimeDimension(field: Field): boolean;
+export declare function fieldBinding(field: Pick<Field, 'expression' | 'importedExpression'>): string | undefined;
+export declare const FIELD_BINDING_KEYS: readonly ["expression", "dialects", "stringForm", "importedExpression", "importedDialect"];
+export declare const FIELD_DEFINITION_KEYS: readonly ["type", "label", "dimension", "description", "aiContext", "customExtensions"];
+/**
+ * Whether a field is bound to a column under the current binding: it carries an
+ * expression, an imported vendor expression, or a non-empty dialect list.
+ * `stringForm` and `importedDialect` describe a binding and are not one on
+ * their own. Inheritance, profile pruning and push validation use this test.
+ * A graph generator asks a narrower question, whether the field has SQL for its
+ * engine (see expressionForDialect), so a bound field can still be left out of
+ * one engine's graph.
+ */
+export declare function isFieldBound(field: Pick<Field, 'expression' | 'importedExpression' | 'dialects'>): boolean;
+/**
+ * Whether a relationship's `to_columns` cover the primary key or a unique key.
+ * A key is covered when every one of its columns is among `to_columns`, so a
+ * superset of a key covers it, since each row still matches at most one target
+ * row. Column names compare as BigQuery compares them: ignoring case, and
+ * without the backticks that only quote a name.
+ */
+export declare function coversKey(toColumns: string[], primaryKey: string[], uniqueKeys: string[][]): boolean;
+/**
+ * Selects the SQL expression for a target engine from a Field or Metric.
+ *
+ * With a non-empty `dialects` list, returns the entry matching `targetDialect`;
+ * failing that, and where the target is not already `ANSI_SQL`, falls back to
+ * the `ANSI_SQL` entry; failing both, returns `undefined`. With `dialects`
+ * empty or absent, returns `item.importedExpression` when `importedDialect` is
+ * the target, and `item.expression` otherwise.
+ */
+export declare function expressionForDialect(item: {
+    expression?: string;
+    dialects?: DialectExpression[];
+    importedExpression?: string;
+    importedDialect?: string;
+}, targetDialect: (typeof ALLOWED_DIALECTS)[number]): string | undefined;
+/**
+ * A relationship: a directed foreign-key edge in the semantic graph, from
+ * `source` to `destination`. The join pairs the endpoints' columns positionally
+ * (`source.columns[i] = destination.columns[i]`): the source's foreign-key
+ * columns referencing the destination's key columns.
+ */
+export interface Relationship {
+    name: string;
+    source: RelationshipEnd;
+    destination: RelationshipEnd;
+    association?: Association;
+    description?: string;
+    aiContext?: AiContext;
+    customExtensions?: CustomExtension[];
+}
+/**
+ * One endpoint of a relationship: the entity it attaches to and the columns on
+ * that entity's own table that participate in the join.
+ */
+export interface RelationshipEnd {
+    entity: string;
+    columns: string[];
+}
+/**
+ * An association (junction) table backing a many-to-many relationship.
+ *
+ * A many-to-many link cannot be a foreign key: an FK column holds a single
+ * value and so references at most one row (a to-one direction), which cannot
+ * encode a pairing where each side maps to many of the other. The pairs instead
+ * live in a separate junction table, one row per (source, destination) -- e.g.
+ * an `enrollment` row per (student, course).
+ *
+ * Unlike a direct foreign key -- which the open format expresses and the loader
+ * produces -- a junction edge is backed by its OWN table (`dataSource`) with
+ * its OWN key (`keys`) and may carry edge `fields` (properties of the
+ * association itself, e.g. an enrollment's grade). Each side names the columns
+ * ON THE JUNCTION TABLE that reference the key of the endpoint entity's node
+ * (see nodeKey). The open format has no association-table syntax yet, so this
+ * is produced by hand-built IR (or a future format extension), not the loader.
+ */
+export interface Association {
+    dataSource: string;
+    keys: string[];
+    sourceColumns: string[];
+    destinationColumns: string[];
+    fields?: Field[];
+}
+/**
+ * A metric: a model-level, named aggregate.
+ *
+ * Because it lives on the model rather than a single entity, a metric may span
+ * multiple entities — its `expression` can reference fields across the graph,
+ * joined via relationships. See `entity` for the single attach point and how
+ * it's derived.
+ *
+ * Expression fidelity mirrors `Field`: a target/canonical `expression` and/or
+ * the original vendor `importedExpression` (+ `importedDialect`).
+ */
+export interface Metric {
+    name: string;
+    expression?: string;
+    importedExpression?: string;
+    importedDialect?: string;
+    dialects?: DialectExpression[];
+    stringForm?: boolean;
+    entity?: string;
+    authoredEntity?: string;
+    description?: string;
+    type?: DataType;
+    aiContext?: AiContext;
+    customExtensions?: CustomExtension[];
+}
+/**
+ * An action: a model-level, named write operation over the ontology -- the
+ * write-side counterpart to a metric's read. Like a metric it lives on the
+ * model (not a single entity) and may span several entities via its typed
+ * `parameters`.
+ *
+ * The model contributes only what the ontology can say that a plain tool schema
+ * cannot: parameters typed from the ontology (a projected one takes its type
+ * and its wording from the field it names) and the
+ * constraints that gate the call. The mechanics of running it are delegated to
+ * an `executor` (e.g. an MCP tool in Agent Registry); `description` is
+ * informational and does not affect runtime.
+ */
+export interface Action {
+    name: string;
+    description?: string;
+    executor?: Executor;
+    parameters: ActionParameter[];
+    guards?: string[];
+    affects?: AffectedConcept[];
+    aiContext?: AiContext;
+    customExtensions?: CustomExtension[];
+}
+/**
+ * One concept an action changes, and how.
+ *
+ * `concept` is the authored name of an entity or a relationship, kept verbatim
+ * for a lossless round-trip. Which of the two it is, is deliberately NOT
+ * recorded: it is a fact about the model, it changes nothing about what the
+ * entry means, and the same three operations apply either way. Whoever needs
+ * the distinction -- validate does, to know which fields the concept has --
+ * resolves it against the model, so there is one place it can be wrong instead
+ * of two. The loader warns about a name that resolves to neither.
+ *
+ * `operation` and `fields` are optional, and their absence means "unspecified"
+ * rather than "nothing". The open format accepts a bare name as shorthand for
+ * an entry with neither -- `affects: [Order]` is the coarse blast radius the
+ * proposal describes -- so a model can start there and add precision only
+ * where a rule needs it.
+ */
+export interface AffectedConcept {
+    concept: string;
+    operation?: ConceptOperation;
+    fields?: string[];
+}
+/**
+ * What an action does to a concept it affects.
+ *
+ * One vocabulary covers entities and relationships alike, because both admit
+ * the same three acts. An edge is not only added and removed: a many-to-many
+ * relationship is backed by a junction table with fields of its own (see
+ * Association), so modifying an enrollment's grade is as ordinary as modifying
+ * an order's total. Splitting the vocabulary by kind would make that change
+ * inexpressible and would buy a policy predicate nothing.
+ */
+export declare const CONCEPT_OPERATIONS: readonly ["create", "modify", "delete"];
+export type ConceptOperation = typeof CONCEPT_OPERATIONS[number];
+/**
+ * One input to an action. Always a SCALAR value: a parameter carries a value,
+ * never an object the runtime has to go and find first.
+ *
+ * There are two ways to author one.
+ *
+ * DERIVED. `concept` plus `field` PROJECT the parameter from a field the model
+ * already declares -- of an entity or of a relationship, the same two things
+ * `affects` may name:
+ *
+ *     - {concept: Account, field: accountId}
+ *     - {name: sourceAccountId, concept: Account, field: accountId,
+ *        description: The account money leaves.}
+ *
+ * `name` defaults to the field's name, so the one-key form above declares a
+ * parameter called `accountId`. `type` MUST NOT be authored: it is the field's,
+ * and a parameter restating it is a second place for it to be wrong. The
+ * loader copies `type`, `description`, `label` and `aiContext` down from the
+ * field; the parameter's own wording wins over the field's where it states any,
+ * and the type never does.
+ *
+ * STANDALONE. Nothing in the model corresponds -- a free-text `memo`, a reason
+ * code -- so the parameter declares its own scalar `type` and names no field:
+ *
+ *     - {name: memo, type: String, description: Why the credit was issued.}
+ *
+ * `concept` and `field` are kept on the IR ALONGSIDE what they resolved to, so
+ * the reference round-trips as the author wrote it while a consumer that does
+ * not have the model -- a catalog reader, an agent holding only the published
+ * aspect -- can still read the resolved type.
+ *
+ * `required` and `default` are always the parameter's own and are never
+ * inherited: a field describes what a thing HAS, and says nothing about whether
+ * a CALL must supply a value for it.
+ *
+ * `type` is optional only as an AUTHORED key. After a load it is populated on
+ * every parameter -- stated by a standalone one, resolved from the field by a
+ * derived one. The single exception is a parameter the loader could resolve
+ * neither way, which is kept verbatim and warned about, and which validate.ts
+ * then rejects.
+ */
+export interface ActionParameter {
+    name: string;
+    type?: string;
+    concept?: string;
+    field?: string;
+    description?: string;
+    label?: string;
+    aiContext?: AiContext;
+    required?: boolean;
+    default?: unknown;
+}
+/**
+ * The mechanics of how an action is executed: exactly one kind, tagged so
+ * consumers can switch on it. The open format expresses it as an object with a
+ * single kind key (`mcp` / `rest` / `grpc`); the loader normalizes that to this
+ * discriminated union. Other kinds (SQL DML, CLI, ...) can be added later.
+ */
+export type Executor = {
+    kind: 'mcp';
+    mcp: McpExecutor;
+} | {
+    kind: 'rest';
+    rest: RestExecutor;
+} | {
+    kind: 'grpc';
+    grpc: GrpcExecutor;
+} | {
+    kind: 'sql';
+    sql: SqlExecutor;
+};
+/**
+ * A SQL executor: the write itself, declared in the model as an ordered list of
+ * DML statements.
+ *
+ * The other three executor kinds name a system that performs the write, so what
+ * the write does is opaque to the model. This one contains it, which buys two
+ * things the opaque kinds cannot offer.
+ *
+ *   - The blast radius is checkable. `affects` can be read against the
+ *     statements rather than taken on trust.
+ *   - A guard becomes a real gate. An MCP, REST or gRPC call commits inside a
+ *     system the caller does not control, so a write it performed could not be
+ *     rolled back if the rest of the action failed; a statement run in a
+ *     database transaction can be. Guards settle before that transaction opens,
+ *     so a refusal leaves the store untouched and no check ever observes the
+ *     write it gates.
+ *
+ * The narrowness is the safety argument, and validate.ts enforces it. A
+ * statement is a single INSERT, UPDATE or DELETE. Every `@name` it binds names
+ * a parameter the action declares, so an argument reaches the store as a bound
+ * value and never as SQL. There is no control flow, no statement composed at
+ * call time, and no way for a caller to supply a statement of its own: an
+ * action whose body arrives with the call declares nothing, and a gate cannot
+ * check what was never declared.
+ *
+ * A row the statement inserts needs a primary key, and the statement is what
+ * decides where it comes from: a UUID function the store offers, a value the
+ * caller passes as an ordinary parameter, or the key column left out where it
+ * has a default. The runtime generates nothing on its behalf. A key that comes
+ * in as a parameter is one the caller chooses, and the check in validate.ts
+ * reads only a statement's first word, so an upsert passes and overwrites the
+ * row that key names.
+ */
+export interface SqlExecutor {
+    statements: string[];
+}
+export declare const SQL_EXECUTOR_VERBS: readonly ["INSERT", "UPDATE", "DELETE"];
+/**
+ * An MCP executor: references a tool already registered in Agent Registry, by
+ * the MCP server's resource name plus the tool's in-server selector. Agent
+ * Registry is the canonical source consumed at runtime (e.g. by an agent).
+ */
+export interface McpExecutor {
+    server: string;
+    tool: string;
+}
+/** A REST executor: an HTTP endpoint and method. */
+export interface RestExecutor {
+    endpoint: string;
+    method: string;
+}
+/** A gRPC executor: a fully-qualified service and method. */
+export interface GrpcExecutor {
+    service: string;
+    method: string;
+}
+/**
+ * What a violated constraint does to the write that tripped it.
+ *
+ *   - `reject`   the write is refused. Nobody is allowed to approve it, which
+ *                is what makes the rule an invariant rather than a policy.
+ *   - `escalate` the write is held and a person decides. The rule is a business
+ *                threshold, so somebody is allowed to say yes.
+ *   - `warn`     the write proceeds and the violation is reported.
+ *
+ * An engine reading the catalog needs this in order to route. Without it every
+ * rule publishes with the same shape, and a $30 credit that needs a supervisor
+ * is indistinguishable from one that is simply forbidden.
+ *
+ * This is a disposition, not a magnitude, and the two are deliberately separate
+ * keys. `escalate` is not "between" reject and warn on a scale of badness: it is
+ * a different control flow, and what it really states is that an approver
+ * exists. Two rules can be equally grave -- both guarding a million-dollar write
+ * -- and differ only in whether anyone in the organization is entitled to say
+ * yes. See CONSTRAINT_SEVERITIES for the magnitude.
+ *
+ * `escalate` names that an approver exists. It does not name who: an approver
+ * role is not modeled yet.
+ *
+ * The consequence is a field rather than something a `judgment` states in its
+ * own prose, because three things need it without running a judge. An
+ * unrunnable judge -- none configured, a failed call, a timeout -- still has to
+ * route the breach it could not evaluate. A search for the rules that can stop
+ * a write cannot read prose. And a policy DSL states its effect in the rule
+ * head, so a rule whose consequence is only implied by its wording cannot be
+ * lowered into OPA or Cedar.
+ *
+ * A judgment may declare any of the three, `reject` included. What settles a
+ * judgment can decide two identical proposals differently, and `reject` leaves
+ * no appeal, so that pairing is the riskiest thing this model can express. It
+ * is still a bet an organization is entitled to place, and refusing to
+ * represent it would move the policy out of the catalog rather than prevent it.
+ * It is made auditable instead: `evaluation` publishes `judged` beside the
+ * word, so "unappealable rules settled by a model" is one query. `onViolation`
+ * is required on a judgment rather than defaulted, because a forgotten word
+ * would produce exactly that pairing silently.
+ *
+ * A constraint's word is the consequence of the one condition it states. A
+ * policy whose conditions carry different consequences is written as several
+ * constraints, which `guards` on an action lists together; the strictest
+ * consequence among the violated ones is what the action does. See
+ * docs/semantic-model/actions.md for a worked policy.
+ *
+ * STATUS: the declared word is published, read back, and routed on for the
+ * rules something settles. A judgment is settled where an action names it in
+ * `guards`, and `warn` reports while `reject` and `escalate` stop the call;
+ * `escalate` says so in the refusal, because nothing here has an approver to
+ * route to. An expression is still text nothing computes, so its word decides
+ * nothing yet.
+ */
+export declare const VIOLATION_EFFECTS: readonly ["reject", "escalate", "warn"];
+export type ViolationEffect = (typeof VIOLATION_EFFECTS)[number];
+/**
+ * How grave a violation of a constraint is, independent of what the engine does
+ * about it.
+ *
+ * Ranking and reporting want this: which of forty violations in a batch to show
+ * a human first, which to page on. Enforcement does not -- that is
+ * `onViolation`, and the split is the point. A `low` rule may still be an
+ * absolute `reject`, and a `critical` one may be a `warn` because the
+ * organization is not ready to block on it yet.
+ *
+ * The scale is the ordinary four-point one, and it avoids `warning` on purpose:
+ * a severity called `warning` sitting beside an effect called `warn` would read
+ * as the same statement made twice.
+ *
+ * STATUS: authored, published and read back. Nothing ranks or routes on it yet.
+ */
+export declare const CONSTRAINT_SEVERITIES: readonly ["critical", "high", "medium", "low"];
+export type ConstraintSeverity = (typeof CONSTRAINT_SEVERITIES)[number];
+/**
+ * A constraint: a model-level, named invariant over the ontology, stated in
+ * words and settled by a language model reading the call that would break it.
+ *
+ * A `judgment` is the rule as a sentence: *the credit memo must name a specific
+ * service failure*, *the order must be within the customer's standing limit*.
+ * It is the one body a constraint has, so settling any rule is a model call;
+ * `expression` is a reserved key the loader refuses. See "what a judgment
+ * costs" in docs/semantic-model/actions.md.
+ *
+ * A judgment states ONE condition, because the consequence is carried by
+ * `onViolation` and one word cannot route two branches. A policy whose branches
+ * end differently -- a missing approval is held for a person, a disguised
+ * transaction is refused -- is written as one constraint per branch, and
+ * `guards` on the action lists them together.
+ *
+ * What the catalog offers a judged rule is identity and governance, never
+ * determinism: one name, one owner, one version, one declared consequence, and
+ * the same text for every caller instead of prose re-improvised per call. A
+ * language model can still decide two identical proposals differently, and no
+ * schema changes that. `onViolation` is required so that the consequence of
+ * that non-determinism is always stated rather than inherited.
+ *
+ * STATUS: authored, validated, published and enforced. kcmd carries a
+ * constraint to Knowledge Catalog, where an agent can read the rules a model
+ * requires. Where an action names a constraint in `guards`, the judgment is
+ * settled before the transaction opens, which is why it reads the attempted
+ * call and never the state the write produced: a rule about the RESULT of a
+ * write is not something this body states. A caller that supplies no judge gets
+ * nothing settled -- the action is refused rather than run past the rule.
+ *
+ * `description` is the error text a violation would surface, so write it to
+ * steer an agent's next move -- "reduce the order quantity or choose another
+ * customer" -- rather than to label the rule.
+ */
+export interface Constraint {
+    name: string;
+    judgment?: string;
+    description?: string;
+    onViolation?: ViolationEffect;
+    severity?: ConstraintSeverity;
+    aiContext?: AiContext;
+}
+export interface DeploymentSpec {
+    name: string;
+    target: string;
+    profile?: string;
+}
+export interface ProfileEntityBinding {
+    name: string;
+    source?: string;
+    primaryKey?: string[];
+    uniqueKeys?: string[][];
+    fields?: Array<Pick<Field, 'name' | 'expression' | 'dialects' | 'stringForm' | 'importedExpression' | 'importedDialect'>>;
+    fieldsExclude?: string[];
+}
+export interface ProfileRelationshipBinding {
+    name: string;
+    fromColumns: string[];
+    toColumns: string[];
+}
+export interface ProfileSpec {
+    name: string;
+    entities: ProfileEntityBinding[];
+    relationships: ProfileRelationshipBinding[];
+    metricsExclude?: '*' | string[];
+    actions?: Array<{
+        name: string;
+        executor?: Executor | null;
+    }>;
+}