@memberjunction/core-entities 5.42.0 → 5.44.0

package/dist/generated/remote_operations.d.ts

@@ -0,0 +1,747 @@
+/*************************************************
+* GENERATED CODE - DO NOT MODIFY
+* Generated by MemberJunction CodeGen — Remote Operation typed bases
+*
+* One typed base class per "MJ: Remote Operations" row (a subclass of BaseRemotableOperation),
+* emitted from the operation's metadata: OperationKey, ExecutionMode, RequiredScope, and the raw
+* TypeScript Input/Output type definitions. GenerationType=Manual rows emit a typed SHELL — a
+* hand-authored server subclass (registered via @RegisterClass) supplies the InternalExecute body.
+* GenerationType=AI/Default rows with Approved Code emit a complete, registered class whose body imports
+* the default libraries plus whatever it declared in its Libraries metadata.
+**************************************************/
+import { BaseRemotableOperation } from "@memberjunction/core";
+/** Input for `AISkill.ExportMarkdown`. */
+export interface AISkillExportMarkdownInput {
+    /** The `MJ: AI Skills` ID to export. */
+    skillID: string;
+}
+/** Output of `AISkill.ExportMarkdown`. */
+export interface AISkillExportMarkdownOutput {
+    /** The portable SKILL.md document text. */
+    markdown: string;
+    /** The skill's Name, for the client to use as a suggested filename (e.g. `${name}.SKILL.md`). */
+    suggestedFileName: string;
+}
+/** Input for `AISkill.ImportMarkdown`. */
+export interface AISkillImportMarkdownInput {
+    /** The SKILL.md document text to import. */
+    markdownText: string;
+    /**
+     * When provided, updates this existing skill (and resyncs its Action/sub-agent bundling)
+     * instead of creating a new one. Caller must confirm the current user may edit it.
+     */
+    updateSkillID?: string;
+}
+/** Output of `AISkill.ImportMarkdown`. */
+export interface AISkillImportMarkdownOutput {
+    /** The created/updated `MJ: AI Skills` ID. */
+    skillID: string;
+    /** The skill's Name, for UI confirmation messaging. */
+    skillName: string;
+    /** Action/sub-agent names from the SKILL.md that couldn't be resolved in this instance — non-fatal. */
+    warnings: string[];
+}
+/** The control action to apply to a running/paused experiment session. */
+export type PredictiveStudioExperimentSessionAction = 'pause' | 'resume' | 'cancel';
+/** Input for `PredictiveStudio.ControlExperimentSession`. */
+export interface PredictiveStudioControlExperimentSessionInput {
+    /** Id of the `MJ: Experiment Sessions` row to control. */
+    sessionId: string;
+    /** The control action: pause a running session, resume a paused one, or cancel. */
+    action: PredictiveStudioExperimentSessionAction;
+}
+/** Output of `PredictiveStudio.ControlExperimentSession` — the session's status after the control action. */
+export interface PredictiveStudioControlExperimentSessionOutput {
+    /** The session's status after the control action (e.g. `Paused` / `Running` / `Cancelled`). */
+    status: string;
+}
+/** Input for `PredictiveStudio.CreateScoringProcess`. */
+export interface PredictiveStudioCreateScoringProcessInput {
+    /** Id of the `MJ: ML Models` row the created Record Process scores with. */
+    modelId: string;
+    /** The entity whose rows are scored (e.g. `Memberships`). */
+    targetEntityName: string;
+    /**
+     * The records a run scores. Mirrors the Record Set Processing scope shapes
+     * (Filter / View / List). Populate EXACTLY ONE selector; `all` is the
+     * whole-entity shortcut ("score everyone"), expressed under the hood as a Filter
+     * with the all-rows predicate `(1=1)`.
+     */
+    scope: {
+        /** A SQL filter over the target entity selecting the rows to score. */
+        filter?: string;
+        /** A `User Views` id whose rows are scored. */
+        viewId?: string;
+        /** A `Lists` id whose member rows are scored. */
+        listId?: string;
+        /** Score the WHOLE target entity ("score everyone"); mutually exclusive with the others. */
+        all?: boolean;
+    };
+    /**
+     * Optional. The target-entity column to write the prediction into (e.g.
+     * `RenewalScore`). **When supplied → write-back mode**: each run writes the
+     * prediction into that column AND a `MJ: ML Model Scoring Bindings` lineage row
+     * (`Mode='OnDemand'`) is created. **When omitted → generic output, no binding**:
+     * predictions are recorded in the process run history (`MJ: Process Run Details`)
+     * only, with no write-back column and no scoring binding.
+     */
+    outputField?: string;
+    /**
+     * Which prediction value the write-back lands in `outputField` — the numeric
+     * `'score'` (probability / regression value — the default) or the predicted
+     * `'class'` label (classification). Ignored in generic mode (no `outputField`).
+     */
+    valueKind?: 'score' | 'class';
+    /** Primary-key field on the target entity the model joins on (defaults to `ID`). */
+    primaryKeyField?: string;
+    /** Optional Record Process name; a descriptive default is generated when omitted. */
+    name?: string;
+}
+/** Output of `PredictiveStudio.CreateScoringProcess` — the created on-demand scoring Record Process + write-back lineage. */
+export interface PredictiveStudioCreateScoringProcessOutput {
+    /**
+     * Id of the created `MJ: Record Processes` row (`WorkType='ML Model'`,
+     * `OnDemandEnabled=true`, no schedule). This is the row the generic
+     * "Run Record Process" run-now Remote Op and the generic scheduler dialog target.
+     */
+    recordProcessId: string;
+    /**
+     * Whether write-back was configured — `true` when an `outputField` was supplied
+     * (the Record Process carries an `OutputMapping` and a scoring binding was
+     * created), `false` in generic mode (predictions recorded in run history only).
+     */
+    wroteColumn: boolean;
+    /**
+     * Id of the created `MJ: ML Model Scoring Bindings` lineage row (`Mode='OnDemand'`)
+     * in write-back mode. Omitted in generic mode (no `outputField`, no binding).
+     */
+    scoringBindingId?: string;
+}
+/** The lifecycle status to transition an ML Model to. */
+export type PredictiveStudioModelTargetStatus = 'Validated' | 'Published' | 'Archived';
+/** Input for `PredictiveStudio.PromoteModel`. */
+export interface PredictiveStudioPromoteModelInput {
+    /** Id of the `MJ: ML Models` row to transition. */
+    modelId: string;
+    /** The lifecycle status to move the model to. */
+    targetStatus: PredictiveStudioModelTargetStatus;
+    /** Human/agent sign-off that overrides the leakage gate. Required (true) to promote a leakage-flagged model; ignored for clean models. */
+    signOff?: boolean;
+    /** Optional human-readable reason recorded with the promotion. */
+    reason?: string;
+}
+/** Output of `PredictiveStudio.PromoteModel` — whether the transition was applied + the new status. */
+export interface PredictiveStudioPromoteModelOutput {
+    /** True when the model was transitioned to the target status. */
+    promoted: boolean;
+    /** The model's new lifecycle status on success (the target status); the unchanged current status when not promoted. */
+    status: string;
+}
+/**
+ * Runtime scope override for a Feature Pipeline run. A Feature Pipeline is a
+ * categorized `MJ: Record Processes` row, so this mirrors the Record Process
+ * runtime scope shapes (records / view / list / filter). When omitted, the
+ * pipeline's stored scope is used.
+ */
+export type PredictiveStudioFeaturePipelineScope = {
+    Kind: 'records';
+    RecordIDs: string[];
+} | {
+    Kind: 'view';
+    ViewID: string;
+} | {
+    Kind: 'list';
+    ListID: string;
+} | {
+    Kind: 'filter';
+    Filter?: string;
+};
+/** Input for `PredictiveStudio.RunFeaturePipeline`. */
+export interface PredictiveStudioRunFeaturePipelineInput {
+    /** Id of the `MJ: Record Processes` row (a Feature Pipeline) to run. */
+    featurePipelineID: string;
+    /** When set, processes just this single record instead of the configured/scope rows. */
+    singleRecordID?: string;
+    /** Compute the per-record feature values WITHOUT writing them back (preview). */
+    dryRun?: boolean;
+    /** Runtime scope override (selected rows / a view / list / filter), used instead of the stored scope. */
+    scope?: PredictiveStudioFeaturePipelineScope;
+}
+/** Output of `PredictiveStudio.RunFeaturePipeline` — the underlying Record Process run summary. */
+export interface PredictiveStudioRunFeaturePipelineOutput {
+    /** Id of the persisted `MJ: Process Runs` row produced by the underlying Record Process. */
+    processRunID?: string;
+    /** Run-level status (`Completed` / `Failed` / `Cancelled` / …). */
+    status: string;
+    /** Records the run touched. */
+    processed: number;
+    /** Records whose features were written back (0 in dry-run). */
+    written: number;
+    /** Records skipped (no rule matched / nothing changed). */
+    skipped: number;
+    /** Records that errored. */
+    error: number;
+    /** Run-level error detail when `status` is not `Completed`. */
+    errorMessage?: string;
+}
+/**
+ * The scope of records to score. Mirrors the Record Set Processing scope shapes
+ * (records / view / list / filter / single). Exactly one shape should be populated;
+ * the runner resolves it into a concrete record set.
+ */
+export interface PredictiveStudioScoringScope {
+    /** Explicit record ids / primary-key objects to score. */
+    records?: Array<string | Record<string, unknown>>;
+    /** A `User Views` id whose rows are scored. */
+    viewId?: string;
+    /** A `Lists` id whose member rows are scored. */
+    listId?: string;
+    /** An entity name + SQL filter selecting the rows to score. */
+    filter?: {
+        entityName: string;
+        extraFilter?: string;
+        maxRows?: number;
+    };
+    /** A single record (entity + primary key) to score. */
+    single?: {
+        entityName: string;
+        primaryKey: Record<string, unknown>;
+    };
+}
+/**
+ * Optional write-back directive. `true` enables write-back with the model's default
+ * mapping; an object supplies an explicit `OutputMapping` (target column / child
+ * record). When omitted, predictions are returned ephemerally.
+ */
+export type PredictiveStudioWriteBackDirective = boolean | {
+    OutputMapping: Record<string, unknown>;
+};
+/** Input for `PredictiveStudio.ScoreRecordSet`. */
+export interface PredictiveStudioScoreRecordSetInput {
+    /** Id of the `MJ: ML Models` row to score with. */
+    modelId: string;
+    /** The records to score — populate exactly one selector on the scope. */
+    scope: PredictiveStudioScoringScope;
+    /** Compute the predictions WITHOUT writing them back (preview) when true/omitted with no write-back. */
+    dryRun?: boolean;
+    /** Optional write-back directive; when omitted (or false) predictions are returned ephemerally. */
+    writeBack?: PredictiveStudioWriteBackDirective;
+}
+/** A single ephemeral prediction surfaced when write-back is NOT requested. */
+export interface PredictiveStudioEphemeralPrediction {
+    /** The scored record's id (when known). */
+    recordId?: string;
+    /** Numeric model output (probability or value). */
+    score: number;
+    /** Predicted class (classification only). */
+    class?: string;
+}
+/** Output of `PredictiveStudio.ScoreRecordSet` — the run summary. */
+export interface PredictiveStudioScoreRecordSetOutput {
+    /** Number of records successfully scored. */
+    scored: number;
+    /** Number of records that failed to score. */
+    failed: number;
+    /** Number of records skipped (no selector matched / nothing to score). */
+    skipped: number;
+    /** True when the runner wrote scores back to the target (predictions are then NOT returned ephemerally). */
+    wroteBack: boolean;
+    /** Ephemeral predictions, present only when `wroteBack` is false. */
+    predictions?: PredictiveStudioEphemeralPrediction[];
+}
+/**
+ * Explicit resource budget for an experiment session — the bounded-autonomy
+ * guardrail. Mirrors `Budget` from `@memberjunction/predictive-studio-core`.
+ */
+export interface PredictiveStudioBudget {
+    /** Max total compute cost the session may spend. */
+    MaxComputeCost?: number;
+    /** Max number of training runs/iterations the session may execute. */
+    MaxRuns?: number;
+    /** Max wall-clock minutes the session may run. */
+    MaxWallclockMinutes?: number;
+}
+/**
+ * The strongly-typed modeling plan to execute. Mirrors `ModelingPlanSpec` from
+ * `@memberjunction/predictive-studio-core` — the deterministic orchestrator runs
+ * its `ProposedExperiments` as waves. Must be approved (`Approved=true`) — execution
+ * is gated on user approval.
+ */
+export interface PredictiveStudioModelingPlanSpec {
+    /** Business objective, refined from the user's initial goal. */
+    Goal: string;
+    /** Precise definition of what is being predicted. */
+    TargetDefinition: {
+        /** Training-unit entity (e.g. "Members"). */
+        EntityName: string;
+        /** Label expression/column. */
+        TargetVariable: string;
+        /** Classification or regression. */
+        ProblemType: 'classification' | 'regression';
+        /** The deterministic success metric driving the search (e.g. AUC / F1 / Accuracy / RMSE). */
+        SuccessMetric: string;
+        /** Optional point-in-time assembly strategy. */
+        AsOfStrategy?: {
+            Mode: 'none' | 'column' | 'offset';
+            Column?: string;
+            OffsetDays?: number;
+        };
+    };
+    /** Candidate feed-in sources proposed by the Data Scout, each with rationale. */
+    CandidateSources: Array<{
+        Kind: 'Entity' | 'Query' | 'ExternalEntity' | 'VectorSet' | 'FeaturePipeline';
+        Ref: string;
+        Why: string;
+    }>;
+    /** Candidate features proposed by the Data Scout, each with rationale. */
+    CandidateFeatures: Array<{
+        Name: string;
+        SourceRef: string;
+        Kind: 'numeric' | 'categorical' | 'embedding' | 'llm-derived';
+        Why: string;
+    }>;
+    /** Leakage risks identified by the Data Scout and the chosen action per field. */
+    LeakageNotes: Array<{
+        Field: string;
+        Risk: string;
+        Action: 'exclude' | 'allow';
+    }>;
+    /** Ranked experiments proposed by the Experiment Designer (feature combos × algorithms × hyperparameters). */
+    ProposedExperiments: Array<{
+        Label: string;
+        AlgorithmName: string;
+        FeatureSet: string[];
+        Hyperparameters?: Record<string, unknown>;
+        Rationale: string;
+        Priority: number;
+    }>;
+    /** Validation strategy for the search. */
+    ValidationStrategy: {
+        Strategy: 'train_test_split' | 'kfold' | 'holdout';
+        TestSize?: number;
+        K?: number;
+        LockedHoldoutFraction: number;
+    };
+    /** Proposed resource budget for the experiment session. */
+    ProposedBudget: PredictiveStudioBudget;
+    /** User approval gate — execution does not begin until this is true. */
+    Approved?: boolean;
+}
+/** Input for `PredictiveStudio.StartExperimentSession`. */
+export interface PredictiveStudioStartExperimentSessionInput {
+    /** Optional id of an existing `MJ: Experiments` definition to attach the session to. When omitted, a new durable Experiment is created from the plan. */
+    experimentId?: string;
+    /** The approved modeling plan to execute. Must have `Approved=true`. */
+    planSpec: PredictiveStudioModelingPlanSpec;
+    /** Optional budget override; when omitted the plan's `ProposedBudget` is used. */
+    budget?: PredictiveStudioBudget;
+    /** Optional human-readable session name (defaults to one derived from the plan goal). */
+    sessionName?: string;
+}
+/** Output of `PredictiveStudio.StartExperimentSession` — the created/executed session. */
+export interface PredictiveStudioStartExperimentSessionOutput {
+    /** Id of the `MJ: Experiment Sessions` row that was started. */
+    sessionId: string;
+    /** Id of the durable `MJ: Experiments` definition the session runs under. */
+    experimentId: string;
+    /** The session's status after starting (`Running`, or `Completed`/`Paused` if it ran to a bound synchronously). */
+    status: string;
+}
+/** Optional point-in-time assembly strategy for the train (mirrors the pipeline's stored AsOfStrategy). */
+export interface PredictiveStudioTrainAsOf {
+    /** How to anchor feature assembly in time: no anchoring, a column on the row, or an offset before the label event. */
+    Mode: 'none' | 'column' | 'offset';
+    /** Column carrying the as-of timestamp (when `Mode` is `column`). */
+    Column?: string;
+    /** Days before the label event to assemble features (when `Mode` is `offset`). */
+    OffsetDays?: number;
+}
+/** Input for `PredictiveStudio.TrainModel`. */
+export interface PredictiveStudioTrainModelInput {
+    /** Id of the `MJ: ML Training Pipelines` row to train. */
+    pipelineId: string;
+    /** Optional `MJ: Experiment Session Iterations` id this run belongs to (NULL for a one-off standalone train). */
+    experimentSessionIterationId?: string;
+    /** Optional cap on the number of training rows pulled from the target entity. */
+    maxRows?: number;
+    /** Optional primary-key field on the target entity (defaults to `ID`). */
+    primaryKeyField?: string;
+    /** Optional per-record label-event dates (keyed by record primary key), required when `asOf.Mode` is `offset`. */
+    labelEventDates?: Record<string, string>;
+    /** Optional as-of strategy override; when omitted the pipeline's stored `AsOfStrategy` is used. */
+    asOf?: PredictiveStudioTrainAsOf;
+    /** Sidecar version string recorded in the model lineage for provenance. */
+    sidecarVersion?: string;
+}
+/** Output of `PredictiveStudio.TrainModel` — the produced (Draft) model + its honest metrics. */
+export interface PredictiveStudioTrainModelOutput {
+    /** Id of the produced (Draft) `MJ: ML Models` row. */
+    modelId: string;
+    /** Id of the `MJ: ML Training Runs` row recording this attempt. */
+    trainingRunId: string;
+    /** Monotonic model version under the pipeline (`max(Version)+1`). */
+    version: number;
+    /** JSON of the metrics scored exactly once on the locked holdout the search never saw (the honest performance number). */
+    holdoutMetrics?: string;
+    /** True when one feature dominates the model's predictions (possible target leakage). A flagged model stays Draft and needs human sign-off before promotion. */
+    leakageFlagged: boolean;
+    /** Lifecycle status of the produced model (always `Draft` immediately after training). */
+    status: string;
+}
+/** A single primary-key field/value pair identifying a record to compare. */
+export interface RecordComparisonKeyValuePair {
+    /** Primary-key field name (e.g. "ID"). */
+    FieldName: string;
+    /** Primary-key value, as a string (UUIDs, ints, etc. are all sent as strings). */
+    Value: string;
+}
+/**
+ * One record to compare, expressed as its composite key (one pair for single-PK
+ * entities, multiple for composite-PK entities).
+ */
+export interface RecordComparisonKey {
+    /** The primary-key field/value pairs uniquely identifying this record. */
+    KeyValuePairs: RecordComparisonKeyValuePair[];
+}
+/** Input for `RecordComparison.Compare`. */
+export interface RecordComparisonCompareInput {
+    /** Registered entity name (e.g. "Accounts"), NOT the physical table name. */
+    EntityName: string;
+    /**
+     * The records to compare, in column order. By convention the first key is the
+     * survivor candidate (the reference column); the rest are potential matches.
+     */
+    Keys: RecordComparisonKey[];
+    /**
+     * Optional include-list of field names to restrict the comparison to. When omitted,
+     * all non-PK, non-system fields are compared (matched case-insensitively).
+     */
+    IncludeFields?: string[];
+}
+/** A scalar field value as loaded from the database. */
+export type RecordComparisonFieldValue = string | number | boolean | null;
+/** One loaded record in the comparison. Mirrors the engine's `RecordComparisonRecord`. */
+export interface RecordComparisonRecord {
+    /** Zero-based index aligned with the input `Keys` array (the comparison column). */
+    ColumnIndex: number;
+    /** The composite key identifying this record (as supplied in the input). */
+    Key: unknown;
+    /** A human-readable label for the record. */
+    Label: string;
+    /** Plain field-name → value map for this record (only the compared fields). */
+    Values: Record<string, RecordComparisonFieldValue>;
+}
+/** Per-record value of a single field. Mirrors the engine's `RecordComparisonFieldCell`. */
+export interface RecordComparisonFieldCell {
+    /** Column index aligned with the record's `ColumnIndex`. */
+    ColumnIndex: number;
+    /** The field's value for this record. */
+    Value: RecordComparisonFieldValue;
+    /**
+     * True when this cell's value equals (case-insensitive, trimmed) the reference
+     * cell (column 0). Column 0 is always true.
+     */
+    EqualsReference: boolean;
+}
+/**
+ * The delta for a single field across all compared records. Mirrors the engine's
+ * `RecordComparisonFieldDelta`.
+ */
+export interface RecordComparisonFieldDelta {
+    /** Field name (matches the entity field metadata Name). */
+    FieldName: string;
+    /** Display name for the field. */
+    DisplayName: string;
+    /** Optional grouping category from the field metadata. */
+    Category: string | null;
+    /** Per-record values for this field, in column order. */
+    Cells: RecordComparisonFieldCell[];
+    /** True when at least one record's value differs from the reference (column 0). */
+    Differs: boolean;
+}
+/**
+ * Output of `RecordComparison.Compare` — the loaded records plus the per-field delta
+ * matrix. Logical success/failure is carried by the wrapping `RemoteOpResult` (a failed
+ * comparison surfaces as `Success=false` + `ErrorMessage`), so this payload is the
+ * success body only.
+ */
+export interface RecordComparisonCompareOutput {
+    /** The registered entity name that was compared. */
+    EntityName: string;
+    /** The loaded records, in input column order. */
+    Records: RecordComparisonRecord[];
+    /** The per-field delta matrix. Only fields with at least one non-empty value. */
+    Fields: RecordComparisonFieldDelta[];
+}
+/** Input for the pause / resume / cancel control operations. */
+export interface ProcessRunControlInput {
+    /** The `MJ: Process Runs` row to control. */
+    processRunID: string;
+}
+/** Output of the pause / resume / cancel control operations. */
+export interface ProcessRunControlOutput {
+    /** The run's status after the control action. */
+    status: string;
+}
+/** Input for `RecordProcess.GetRunStatus`. */
+export interface RecordProcessGetRunStatusInput {
+    /** The `MJ: Process Runs` row to query. */
+    processRunID: string;
+}
+/** Output of `RecordProcess.GetRunStatus` — a snapshot of the run's progress. */
+export interface RecordProcessGetRunStatusOutput {
+    status: string;
+    processed: number;
+    total: number | null;
+    success: number;
+    error: number;
+    skipped: number;
+}
+/** Runtime scope override for a Record Process run (instead of the stored Scope). */
+export type RecordProcessScopeOverride = {
+    Kind: 'records';
+    RecordIDs: string[];
+} | {
+    Kind: 'view';
+    ViewID: string;
+} | {
+    Kind: 'list';
+    ListID: string;
+} | {
+    Kind: 'filter';
+    Filter?: string;
+};
+/** Input for `RecordProcess.RunNow`. */
+export interface RecordProcessRunNowInput {
+    /** The `MJ: Record Processes` definition to run. */
+    recordProcessID: string;
+    /** When set, processes just this single record instead of the configured scope. */
+    singleRecordID?: string;
+    /** Compute the per-record changes WITHOUT writing (FieldRules work type) — powers the preview. */
+    dryRun?: boolean;
+    /** Runtime scope override (selected rows / a view / list / filter), used instead of the stored Scope. */
+    scope?: RecordProcessScopeOverride;
+}
+/** Output of `RecordProcess.RunNow` — the run summary. */
+export interface RecordProcessRunNowOutput {
+    /** ID of the persisted `MJ: Process Runs` row. */
+    processRunID?: string;
+    /** Run-level status (`Completed` / `Failed` / `Cancelled` / …). */
+    status: string;
+    /** Records the run touched. */
+    processed: number;
+    /** Records that succeeded (in dry-run, records with a computed preview). */
+    success: number;
+    /** Records that errored. */
+    error: number;
+    /** Records skipped (no rule matched / nothing changed). */
+    skipped: number;
+    /** Run-level error detail when `status` is not `Completed`. */
+    errorMessage?: string;
+}
+/** Input for `Template.Run`. */
+export interface TemplateRunInput {
+    /** The `MJ: Templates` ID to render. */
+    templateID: string;
+    /** Data the template may reference during render (the render context). Omit for none. */
+    data?: Record<string, unknown>;
+}
+/** Output of `Template.Run`. */
+export interface TemplateRunOutput {
+    /** The rendered template output. */
+    output: string;
+    /** Wall-clock render time in milliseconds. */
+    executionTimeMs?: number;
+}
+/**
+ * Export AI Skill Markdown
+ * Exports an MJ: AI Skills record to the portable SKILL.md format (frontmatter + Instructions body). Bundled Action/sub-agent IDs are resolved to their current Names for cross-instance portability. Implemented by AISkillExportMarkdownServerOperation in @memberjunction/ai-agents.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'AISkill.ExportMarkdown'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class AISkillExportMarkdownOperation extends BaseRemotableOperation<AISkillExportMarkdownInput, AISkillExportMarkdownOutput> {
+    readonly OperationKey = "AISkill.ExportMarkdown";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "aiskill:manage";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Import AI Skill Markdown
+ * Imports a SKILL.md document, resolving Action/sub-agent names against this instance's catalog (unresolvable names become non-fatal warnings), and creates or updates the MJ: AI Skills record plus its Action/sub-agent bundling junction rows. Implemented by AISkillImportMarkdownServerOperation in @memberjunction/ai-agents.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'AISkill.ImportMarkdown'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class AISkillImportMarkdownOperation extends BaseRemotableOperation<AISkillImportMarkdownInput, AISkillImportMarkdownOutput> {
+    readonly OperationKey = "AISkill.ImportMarkdown";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "aiskill:manage";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Control Experiment Session
+ * Pause, resume, or cancel an MJ: Experiment Sessions run (honored at the next wave checkpoint). Returns the session's status after the control action. A quick lifecycle transition over the experiment orchestrator's session state.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'PredictiveStudio.ControlExperimentSession'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class PredictiveStudioControlExperimentSessionOperation extends BaseRemotableOperation<PredictiveStudioControlExperimentSessionInput, PredictiveStudioControlExperimentSessionOutput> {
+    readonly OperationKey = "PredictiveStudio.ControlExperimentSession";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "predictive:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Create Scoring Process
+ * Create an on-demand WorkType='ML Model' MJ: Record Processes row that scores a target entity's records with a trained MJ: ML Models (no schedule). The scope selects records (a saved view / a list / an entity filter / the whole entity). When outputField is supplied, the run writes the prediction into that column and a MJ: ML Model Scoring Bindings lineage row (Mode='OnDemand') is created; when omitted, output is generic (run history only) with no binding. Returns the new Record Process id, whether a write-back column was configured, and the scoring binding id (when created). The created row is then run-now via the Run Record Process operation or scheduled via the generic scheduling dialog. Delegates to createScoringProcess in @memberjunction/predictive-studio-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'PredictiveStudio.CreateScoringProcess'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class PredictiveStudioCreateScoringProcessOperation extends BaseRemotableOperation<PredictiveStudioCreateScoringProcessInput, PredictiveStudioCreateScoringProcessOutput> {
+    readonly OperationKey = "PredictiveStudio.CreateScoringProcess";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "predictive:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Promote ML Model
+ * Transition an MJ: ML Models row through its lifecycle (Validated / Published / Archived). Enforces the leakage sign-off gate — a model flagged for possible target leakage cannot be promoted unless signOff=true. Lifecycle-only: never edits metrics or artifact, only Status. Returns whether the model was promoted and its new status. Delegates to the ProductionModelPromotionGate in @memberjunction/predictive-studio-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'PredictiveStudio.PromoteModel'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class PredictiveStudioPromoteModelOperation extends BaseRemotableOperation<PredictiveStudioPromoteModelInput, PredictiveStudioPromoteModelOutput> {
+    readonly OperationKey = "PredictiveStudio.PromoteModel";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "predictive:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Run Feature Pipeline
+ * Run a Feature Pipeline — a categorized MJ: Record Processes row — over an optional runtime scope (selected records / view / list / filter), optionally as a dry-run preview that computes feature values without writing. Returns processed/written/skipped/error counts plus the MJ: Process Runs id. Runs the underlying Record Process (no dedicated entity); delegates to the Record Process substrate.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'PredictiveStudio.RunFeaturePipeline'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class PredictiveStudioRunFeaturePipelineOperation extends BaseRemotableOperation<PredictiveStudioRunFeaturePipelineInput, PredictiveStudioRunFeaturePipelineOutput> {
+    readonly OperationKey = "PredictiveStudio.RunFeaturePipeline";
+    readonly ExecutionMode: "LongRunning";
+    readonly RequiredScope = "predictive:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Score Record Set
+ * Score a set of records with a trained MJ: ML Models row. The scope selects records (explicit ids / a saved view / a list / an entity+filter / a single record). Optionally a dry-run preview, or a write-back to the target. Returns scored/failed/skipped counts plus either the ephemeral predictions or write-back confirmation. Delegates to the MLModelInferenceProcessor scoring work type in @memberjunction/predictive-studio-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'PredictiveStudio.ScoreRecordSet'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class PredictiveStudioScoreRecordSetOperation extends BaseRemotableOperation<PredictiveStudioScoreRecordSetInput, PredictiveStudioScoreRecordSetOutput> {
+    readonly OperationKey = "PredictiveStudio.ScoreRecordSet";
+    readonly ExecutionMode: "LongRunning";
+    readonly RequiredScope = "predictive:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Start Experiment Session
+ * Start an experiment session from an approved ModelingPlanSpec — running its proposed experiments in waves under a Budget, maintaining a leaderboard. Optionally attaches to an existing MJ: Experiments definition or creates a new one. Returns the session id, experiment id, and initial status. Delegates to ExperimentOrchestrator.runSession in @memberjunction/predictive-studio-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'PredictiveStudio.StartExperimentSession'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class PredictiveStudioStartExperimentSessionOperation extends BaseRemotableOperation<PredictiveStudioStartExperimentSessionInput, PredictiveStudioStartExperimentSessionOutput> {
+    readonly OperationKey = "PredictiveStudio.StartExperimentSession";
+    readonly ExecutionMode: "LongRunning";
+    readonly RequiredScope = "predictive:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Train ML Model
+ * Train a predictive model from an MJ: ML Training Pipelines definition. Carves a locked holdout (point-in-time/as-of aware), trains via the sidecar, persists an immutable Draft MJ: ML Models row, and flags single-feature dominance (possible target leakage). Returns the new model id, its honest holdout metrics, the leakage flag, and the model version. Delegates to TrainingEngine.trainModel in @memberjunction/predictive-studio-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'PredictiveStudio.TrainModel'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class PredictiveStudioTrainModelOperation extends BaseRemotableOperation<PredictiveStudioTrainModelInput, PredictiveStudioTrainModelOutput> {
+    readonly OperationKey = "PredictiveStudio.TrainModel";
+    readonly ExecutionMode: "LongRunning";
+    readonly RequiredScope = "predictive:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Compare Records
+ * Load a set of an entity's records (by composite key, column 0 = survivor/reference) and compute the field-level delta matrix between them. Read-only. Returns the loaded records + per-field deltas. Implemented by RecordComparisonCompareServerOperation in @memberjunction/record-comparison.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'RecordComparison.Compare'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class RecordComparisonCompareOperation extends BaseRemotableOperation<RecordComparisonCompareInput, RecordComparisonCompareOutput> {
+    readonly OperationKey = "RecordComparison.Compare";
+    readonly ExecutionMode: "Sync";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Cancel Record Process Run
+ * Request cancellation of a running Record Process (honored at the next checkpoint). Returns the run's status. Implemented by RecordProcessCancelRunOperation in @memberjunction/record-set-processor.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'RecordProcess.CancelRun'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class RecordProcessCancelRunOperation extends BaseRemotableOperation<ProcessRunControlInput, ProcessRunControlOutput> {
+    readonly OperationKey = "RecordProcess.CancelRun";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "recordprocess:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Get Record Process Run Status
+ * Return a snapshot of a Record Process run's progress (status + processed/total/success/error/skipped counts) by ProcessRunID. Implemented by RecordProcessGetRunStatusOperation in @memberjunction/record-set-processor.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'RecordProcess.GetRunStatus'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class RecordProcessGetRunStatusOperation extends BaseRemotableOperation<RecordProcessGetRunStatusInput, RecordProcessGetRunStatusOutput> {
+    readonly OperationKey = "RecordProcess.GetRunStatus";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "recordprocess:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Pause Record Process Run
+ * Request a graceful pause of a running Record Process (honored at the next checkpoint). Returns the run's status. Implemented by RecordProcessPauseRunOperation in @memberjunction/record-set-processor.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'RecordProcess.PauseRun'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class RecordProcessPauseRunOperation extends BaseRemotableOperation<ProcessRunControlInput, ProcessRunControlOutput> {
+    readonly OperationKey = "RecordProcess.PauseRun";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "recordprocess:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Resume Record Process Run
+ * Resume a paused Record Process run. Returns the run's status. Implemented by RecordProcessResumeRunOperation in @memberjunction/record-set-processor.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'RecordProcess.ResumeRun'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class RecordProcessResumeRunOperation extends BaseRemotableOperation<ProcessRunControlInput, ProcessRunControlOutput> {
+    readonly OperationKey = "RecordProcess.ResumeRun";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "recordprocess:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Run Record Process
+ * Run a Record Process on demand over an optional runtime scope (selected records / view / list / filter), optionally as a dry-run preview that computes the per-record changes without writing. Returns the run summary (status + processed/success/error/skipped counts + the MJ: Process Runs ID). Implemented by RecordProcessRunNowServerOperation in @memberjunction/record-set-processor.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'RecordProcess.RunNow'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class RecordProcessRunNowOperation extends BaseRemotableOperation<RecordProcessRunNowInput, RecordProcessRunNowOutput> {
+    readonly OperationKey = "RecordProcess.RunNow";
+    readonly ExecutionMode: "LongRunning";
+    readonly RequiredScope = "recordprocess:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Run Template
+ * Render a template by ID with optional render data. Returns the rendered output + wall-clock render time. Implemented by TemplateRunServerOperation in @memberjunction/templates.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'Template.Run'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class TemplateRunOperation extends BaseRemotableOperation<TemplateRunInput, TemplateRunOutput> {
+    readonly OperationKey = "Template.Run";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "template:execute";
+    readonly RequiresSystemUser = false;
+}
+//# sourceMappingURL=remote_operations.d.ts.map