/*************************************************
* 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