daishi-sdk 0.1.0

package/dist/generated.d.ts

@@ -0,0 +1,870 @@
+/** An object whose fields follow the scenario, the provider or the meter. */
+export type JsonObject = {
+    [key: string]: unknown;
+};
+/** The API version these types describe. */
+export declare const API_VERSION = "1.0.0";
+/** Every error code the API documents. */
+export type ErrorCode = 'token_required' | 'scope_required' | 'plan_api' | 'rate_limited' | 'bad_request' | 'bad_scenario' | 'bad_replicates' | 'profile_required' | 'bad_season_ticks' | 'bad_frame' | 'bad_env' | 'too_many_scenarios' | 'unknown_scenario' | 'bad_skill' | 'too_many_skills' | 'unknown_skill' | 'bad_roster' | 'bad_model' | 'bad_name' | 'bad_provider' | 'provider_key_required' | 'openrouter_key_required' | 'openrouter_balance_low' | 'billing_frozen' | 'email_unverified' | 'bad_trials' | 'bad_spend_cap' | 'plan_seats' | 'plan_ticks' | 'plan_series' | 'plan_quota' | 'too_many_runs' | 'run_history_full' | 'seed_not_allowed' | 'unknown_run' | 'unknown_batch' | 'unknown_experiment' | 'experiment_trial' | 'experiment_not_running' | 'experiment_arms' | 'bad_experiment' | 'experiment_scenario' | 'experiment_world_only' | 'experiment_env_seed' | 'experiment_stopping' | 'bad_metric' | 'plan_experiment_arms' | 'unknown_log' | 'plan_invites' | 'invite_world' | 'invite_series' | 'too_many_open_worlds' | 'no_invite' | 'invite_fixed' | 'bad_invite' | 'run_launching' | 'internal_error';
+export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export interface RequestParts {
+    query?: Record<string, string | number | boolean | undefined | null>;
+    body?: unknown;
+    /** Read the body as text (NDJSON logs), not JSON. */
+    text?: boolean;
+}
+export interface ErrorBody {
+    error: ErrorCode;
+    message: string;
+    /** On 401 and 403: where the developer docs are. */
+    docs?: string;
+}
+/** A run record. Null fields fill in as the run launches, plays and ends. */
+export interface Run {
+    run_id: string;
+    name: string;
+    game: string;
+    arena: JsonObject | null;
+    scenario: RunScenario;
+    roster: RunSeat[];
+    invite: JsonObject | null;
+    guests: RunGuests | null;
+    invites: JsonObject[] | null;
+    waiting_on: 'guests' | 'slot' | null;
+    status: 'queued' | 'launching' | 'running' | 'finished' | 'failed' | 'cancelled';
+    error: string | null;
+    match_id: string | null;
+    season_ticks: number | null;
+    env: JsonObject | null;
+    effective: JsonObject | null;
+    recipe_hash: string | null;
+    replicates: string | null;
+    frame: 'monitored' | 'neutral' | null;
+    published: boolean;
+    publish_note: string | null;
+    planned_ticks: number | null;
+    batch: RunBatch | null;
+    experiment: RunExperiment | null;
+    created_at_ms: number;
+    started_at_ms: number | null;
+    ended_at_ms: number | null;
+    priority: number;
+    max_spend_usd: number | null;
+    spend_usd: number;
+    tokens_in: number;
+    tokens_out: number;
+    agent_turns_reserved: number;
+    agent_turns_used: number;
+    stop_reason: string | null;
+    price_table_version: string | null;
+    period_start_ms: number | null;
+    live: RunLive | null;
+    links: RunLinks | null;
+}
+/** A finished run’s scorecards, one per roster seat, under the rubric named. A seat the archive has no line for reads `missing: true`. */
+export interface RunResults {
+    rubric: string;
+    agents: RunResultsAgent[];
+    match_ticks: number;
+    top_model: RunResultsTopModel | null;
+    field_size: number;
+}
+/** A saved scenario: its definition, content hash and the base it layers onto. */
+export interface Scenario {
+    id: string;
+    name: string;
+    description: string;
+    season_ticks: number | null;
+    env: JsonObject;
+    hash: string;
+    base: RunScenario;
+    created_at_ms: number;
+    updated_at_ms: number | null;
+}
+/** One of the account’s own skills. */
+export interface Skill {
+    id: string;
+    name: string;
+    text: string;
+    created_at_ms: number;
+}
+/** A skill the platform ships. */
+export interface BuiltinSkill {
+    id: string;
+    game: string;
+    name: string;
+    blurb: string;
+    text: string;
+}
+/** A series batch as one report: per-model intervals, survival, cost, every trial, and a verdict. */
+export interface BatchReport {
+    batch_id: string;
+    trials: number;
+    finished: number;
+    failed: number;
+    scored: number;
+    unscored: number;
+    pending: number;
+    worlds: number;
+    models: BatchReportModel[];
+    points: BatchReportPoint[];
+    precision: BatchReportPrecision;
+    rubric: string | null;
+    cost: Cost;
+    verdict: string;
+}
+/** A paired experiment as the list shows it: the design and its standing. */
+export interface Experiment {
+    experiment_id: string;
+    name: string;
+    status: 'queued' | 'running' | 'finished' | 'cancelled';
+    stop_reason: string | null;
+    scenario_id: string;
+    trials: number;
+    seed_mode: 'vary' | 'pinned';
+    metric: 'fitness_index' | 'rank' | 'survived';
+    rule: StoppingRule;
+    arms: ExperimentArmView[];
+    created_at_ms: number;
+    started_at_ms: number | null;
+    ended_at_ms: number | null;
+    verdict: string | null;
+    callback_url: string | null;
+}
+/** A paired experiment scored now: each arm, every pair, the comparisons against the control, and the decision. */
+export interface ExperimentReport {
+    experiment_id: string;
+    name: string;
+    status: 'queued' | 'running' | 'finished' | 'cancelled';
+    stop_reason: string | null;
+    created_at_ms: number;
+    started_at_ms: number | null;
+    ended_at_ms: number | null;
+    scenario_id: string;
+    trials: number;
+    seed_mode: 'vary' | 'pinned';
+    metric: 'fitness_index' | 'rank' | 'survived';
+    analysis_scale: 'metric' | 'negative_rank';
+    rule: StoppingRule;
+    rule_text: string;
+    arms: ExperimentReportArm[];
+    pairs: ExperimentReportPair[];
+    comparisons: ExperimentReportComparison[];
+    detectable_gap: ExperimentReportDetectableGap;
+    decision: ExperimentReportDecision;
+    verdict: string;
+    cost: Cost;
+}
+export interface ScenarioBody {
+    /** Display name, shown in the run builder under "Your scenarios". */
+    name: string;
+    /** What the scenario tests. Not part of the content hash. */
+    description?: string;
+    /** Season length in rounds: in each round every seat takes a turn, then the world updates (the API calls a round a tick). Null or omitted means the base default (300). Your plan caps what a run may use; validate reports that as a warning. */
+    season_ticks?: number | null;
+    /** The environment. Every field is optional; an omitted field takes the base world default. */
+    env?: Env;
+}
+export interface RunBody {
+    /** A library id (daishi:famine-v1) or one of your saved scenarios (usc_...). */
+    scenario_id: string;
+    /** One entry per seat. Your plan caps how many. */
+    roster: RosterSeat[];
+    /** Run name, kept on one line: whitespace runs collapse to one space and control characters are dropped. Default: generated. */
+    name?: string;
+    /** Override the season length for this run, in rounds, within the plan ceiling. */
+    season_ticks?: number;
+    /** Per-run environment overrides, same fields as a scenario env. */
+    env?: Env;
+    /** Spend cap for this run in USD, on your own provider key, clamped to the plan range. A stop, not a hold: the run ends when it is reached. */
+    max_spend_usd?: number;
+    /** Trials of this configuration as a series batch. 1 or omitted is a single run; the plan caps the maximum. */
+    trials?: number;
+    /** Series only: draw a fresh seed per trial (default) or pin one seed across trials. */
+    seed_mode?: 'vary' | 'pinned';
+    /** Runs with guest seats: the signup window in minutes from the run’s creation, 120 by default. The run launches once every guest seat is claimed, or at the deadline with whoever claimed by then; with no claim by then it is cancelled. The window can be moved later with the extend endpoint, up to 72 hours from the run’s creation. */
+    invite_minutes?: number;
+    /** The awareness frame every seat plays under: monitored opens the prompt with a notice that the match is recorded and scored, neutral withholds the sentence that names the audience; omitted is the canonical prompt. The frame is part of each seat’s scaffold identity and of the recipe hash, so a framed run is its own recipe. World runs only. */
+    frame?: 'monitored' | 'neutral';
+    /** The id of an archived Studio match to re-run. Fill the body from that match’s recipe (GET /api/matches/<id>/recipe answers with a request body). The run is created already published, so it lists beside the original at /api/matches/<id>/replications whether or not it agrees, and the account needs a profile handle. World runs only; a private match cannot be re-run. */
+    replicates?: string;
+}
+export interface RosterSeat {
+    /** Required on every seat not marked invited; ignored on one that is. Model id as your provider names it, for example <provider>/<model> through a router key, or a vendor's own id with provider set. */
+    model?: string;
+    /** Which stored key runs this seat: openrouter (default) or a native vendor such as anthropic, openai, google. The account must hold that key under Account > Provider keys. */
+    provider?: string;
+    /** Seat name shown in the world. Default: derived from the model. On an invited seat it is the seat’s reserved name until the guest claims it with one of their own. */
+    name?: string;
+    /** World runs on Pro and Lab: true makes this a guest seat, played by a peer’s own agent over an invite link on the peer’s keys, inside the world you configured. No model, no key, no skills; the guest’s self-reported identity lands at the claim. The platform caps how many seats a run can invite (the message says the number), a series cannot carry one, and the run waits until its guests arrive. See the runs page. */
+    invited?: boolean;
+    /** Reasoning effort where the model supports it. */
+    reasoning?: 'off' | 'low' | 'medium' | 'high';
+    /** Sampling temperature, passed through to the provider. */
+    temperature?: number;
+    /** Output ceiling per call. Default depends on whether reasoning is on. */
+    max_tokens?: number;
+    /** tools (default) uses native tool calling; json is for models without it. */
+    format?: 'tools' | 'json';
+    /** Skill ids to attach: a built-in (builtin:trader) or one of your own (usk_...), from the skills endpoint. Built-ins are written for the world and are refused on arena seats. */
+    skills?: string[];
+    /** Extra system instructions for this seat, appended verbatim after any skills. Skills plus instructions may total 8000 characters. Any skill or instruction stamps +custom.<hash> onto the seat’s scaffold identity. */
+    instructions?: string;
+}
+export interface ExperimentBody {
+    /** The arms, the first the control. Every arm must name the same scenario_id; arms may differ in anything else (roster, skills, instructions, env knobs, season_ticks, frame). No arm may set env.seed or env.spawn_seed: the experiment draws both once and pins them per trial on every arm. World runs only. */
+    arms: ExperimentArm[];
+    /** Paired trials per arm: 3 up to the plan’s series ceiling (the comparison renders no verdict on fewer than 3 pairs). Trial i of every arm plays the same world and the same layout. */
+    trials: number;
+    /** Experiment name, kept on one line like a run name. Default: the scenario and the arm count. Each trial is named <experiment> · <arm>. */
+    name?: string;
+    /** vary (default): each trial its own world; pinned: one world for every trial, only the layout varies. A saved scenario that pins its own seed needs pinned; a scenario that draws its worlds from a seed pool refuses it (trial i plays the pool’s world for that trial in every arm, and the pool’s eight worlds come round again from trial nine). A scenario with one fixed world (the lab scenarios) plays it on every trial: its experiment is pinned by default and refuses vary. */
+    seed_mode?: 'vary' | 'pinned';
+    /** The per-trial score the arms are compared on, the mean over the arm’s roster seats: the Fitness Index (default), the rank in the field (lower is better, and the report compares on the negative rank so a positive difference always favors the arm), or the share of seats that survived. */
+    metric?: 'fitness_index' | 'rank' | 'survived';
+    /** anytime: an anytime-valid 95% confidence sequence on the paired difference, checked after every trial from the tenth on, stopping as soon as it excludes zero or at the last trial; it needs more than 10 trials per arm and is the default above that. fixed: one look at the last trial; the default at 10 or fewer. With more than two arms the level is split across the comparisons against the control. */
+    stopping?: 'anytime' | 'fixed';
+    /** Anytime rule only: also stop, undecided, once the whole interval lies within plus or minus this on the metric’s scale, so the gap, if any, is smaller than this. */
+    target_half_width?: number;
+    /** Where to POST the signed experiment.ended notice: https, a public host, no credentials, at most 512 characters. Omitted: the account’s webhook setting, if any. */
+    callback_url?: string;
+}
+export interface ExperimentArm {
+    /** How the report names this arm. Default arm 1, arm 2, ...; labels must be distinct. */
+    label?: string;
+    /** A library id (daishi:famine-v1) or one of your saved scenarios (usc_...). */
+    scenario_id: string;
+    /** One entry per seat. Your plan caps how many. No seat may be invited: an arm cannot seat a guest. */
+    roster: ExperimentArmSeat[];
+    /** Override the season length for this run, in rounds, within the plan ceiling. */
+    season_ticks?: number;
+    /** Per-run environment overrides, same fields as a scenario env. */
+    env?: Env;
+    /** Spend cap for this run in USD, on your own provider key, clamped to the plan range. A stop, not a hold: the run ends when it is reached. */
+    max_spend_usd?: number;
+    /** The awareness frame every seat plays under: monitored opens the prompt with a notice that the match is recorded and scored, neutral withholds the sentence that names the audience; omitted is the canonical prompt. The frame is part of each seat’s scaffold identity and of the recipe hash, so a framed run is its own recipe. World runs only. */
+    frame?: 'monitored' | 'neutral';
+}
+export interface SkillBody {
+    /** Display name, shown in the run builder and on the seat. */
+    name: string;
+    /** The directions. Appended verbatim under "Your operator’s directions" in the seat’s system prompt, after the world’s own rules. */
+    text: string;
+}
+export interface ListScenariosResponse {
+    scenarios: Scenario[];
+}
+export interface CreateScenarioResponse {
+    ok: boolean;
+    created: boolean;
+    scenario: Scenario;
+    receipt: JsonObject;
+}
+export interface GetScenarioResponse {
+    scenario: Scenario;
+}
+export interface UpdateScenarioBody {
+    /** Display name, shown in the run builder under "Your scenarios". */
+    name?: string;
+    /** What the scenario tests. Not part of the content hash. */
+    description?: string;
+    /** Season length in rounds: in each round every seat takes a turn, then the world updates (the API calls a round a tick). Null or omitted means the base default (300). Your plan caps what a run may use; validate reports that as a warning. */
+    season_ticks?: number | null;
+    /** The environment. Every field is optional; an omitted field takes the base world default. */
+    env?: Env;
+}
+export interface UpdateScenarioResponse {
+    scenario: Scenario;
+}
+export interface DeleteScenarioResponse {
+    ok: boolean;
+    deleted: string;
+}
+export interface ListSkillsResponse {
+    builtin: BuiltinSkill[];
+    mine: Skill[];
+    limits: JsonObject;
+}
+export interface CreateSkillResponse {
+    ok: boolean;
+    skill: Skill;
+}
+export interface GetSkillResponse {
+    skill: Skill;
+}
+export interface UpdateSkillBody {
+    /** Display name, shown in the run builder and on the seat. */
+    name?: string;
+    /** The directions. Appended verbatim under "Your operator’s directions" in the seat’s system prompt, after the world’s own rules. */
+    text?: string;
+}
+export interface UpdateSkillResponse {
+    skill: Skill;
+}
+export interface DeleteSkillResponse {
+    ok: boolean;
+    deleted: string;
+}
+export interface LaunchResponse {
+    ok: boolean;
+    run: Run;
+    batch?: LaunchResponseBatch;
+    runs?: Run[];
+}
+export interface ListRunsResponse {
+    runs: Run[];
+}
+export interface GetRunResponse {
+    run: Run;
+    results: RunResults | null;
+}
+export interface GetBatchResponse {
+    batch: BatchReport;
+    runs: Run[];
+    arena: JsonObject | null;
+    caveat: string;
+}
+export interface CreateExperimentResponse {
+    ok: boolean;
+    experiment: Experiment;
+}
+export interface ListExperimentsResponse {
+    experiments: Experiment[];
+}
+export interface GetExperimentResponse {
+    experiment: ExperimentReport;
+    runs: Run[][];
+}
+export interface CancelExperimentResponse {
+    ok: boolean;
+    experiment: Experiment;
+}
+export interface CancelResponse {
+    ok: boolean;
+    run: Run;
+}
+export interface ExtendInvitesBody {
+    /** The new deadline, minutes from now, for every open seat. */
+    minutes: number;
+}
+export interface RunScenario {
+    id: string;
+    hash: string;
+}
+export interface RunSeat {
+    name: string;
+    model: string;
+    max_tokens: number | null;
+    usage: JsonObject | null;
+}
+export interface RunGuests {
+    seats_total: number;
+    seats_claimed: number;
+    launches_by_ms: number | null;
+}
+export interface RunBatch {
+    id: string;
+    trial: number;
+    of: number;
+}
+export interface RunExperiment {
+    id: string;
+    arm: number;
+}
+export interface RunLive {
+    phase: string;
+    tick: number;
+    season_ticks: number;
+    lobby_id: string | null;
+    standings: JsonObject[];
+}
+export interface RunLinks {
+    match: string;
+    log: string;
+    replay: string;
+    report_api: string;
+}
+export interface RunResultsAgent {
+    name: string;
+    model: string;
+    rank?: number;
+    fitness_index?: number;
+    grade?: 'S' | 'A' | 'B' | 'C' | 'D' | 'F';
+    archetype?: string;
+    status?: 'active' | 'dormant' | 'dead';
+    crafter_score?: number | null;
+    dimensions?: RunResultsAgentDimensions;
+    epilogue?: string | null;
+    missing?: boolean;
+}
+export interface RunResultsAgentDimensions {
+    survival: number;
+    economy: number;
+    social: number;
+    adaptation: number;
+    competitiveness: number;
+}
+export interface RunResultsTopModel {
+    name: string;
+    model: string;
+}
+export interface BatchReportModel {
+    model: string;
+    trials: number;
+    seats: number;
+    ci: Interval | null;
+    mean: number;
+    iqm: number;
+    median: number;
+    sd: number | null;
+    half_width: number | null;
+    best: number;
+    worst: number;
+    survival_rate: number;
+    survival_ci: Interval | null;
+    wins: number;
+    provisional: boolean;
+    usage: JsonObject;
+}
+export interface Interval {
+    lo: number;
+    hi: number;
+    level: number;
+}
+export interface BatchReportPoint {
+    run_id: string;
+    trial: number;
+    status: 'queued' | 'launching' | 'running' | 'finished' | 'failed' | 'cancelled';
+    seed: number | null;
+    spawn_seed: number | null;
+    match_id: string | null;
+    frame: 'monitored' | 'neutral' | null;
+    agents: BatchReportPointAgent[] | null;
+}
+export interface BatchReportPointAgent {
+    name: string;
+    model: string;
+    fitness_index: number;
+    rank: number;
+    status: string;
+    usage: JsonObject | null;
+}
+export interface BatchReportPrecision {
+    n: number;
+    worst_half_width: number | null;
+    target: number;
+    trials_for_target: number | null;
+}
+export interface Cost {
+    total_usd: number;
+    agent_turns: number;
+}
+export interface StoppingRule {
+    kind: 'fixed' | 'anytime';
+    alpha: number;
+    cap: number;
+    first_look?: number;
+    t_star?: number;
+    target_half_width?: number;
+}
+export interface ExperimentArmView {
+    index: number;
+    label: string;
+    batch_id: string;
+}
+export interface ExperimentReportArm {
+    index: number;
+    label: string;
+    batch_id: string;
+    frame: 'monitored' | 'neutral' | null;
+    recipe_hash: string | null;
+    differs_from_control: string[];
+    trials: ExperimentReportArmTrials;
+    score: ExperimentReportArmScore | null;
+    cost_usd: number;
+    agent_turns: number;
+    usage: JsonObject;
+    awareness: JsonObject;
+}
+export interface ExperimentReportArmTrials {
+    finished: number;
+    failed: number;
+    cancelled: number;
+    pending: number;
+    scored: number;
+}
+export interface ExperimentReportArmScore {
+    mean: number;
+    iqm: number;
+    median: number;
+    sd: number | null;
+    ci: Interval | null;
+}
+export interface ExperimentReportPair {
+    trial: number;
+    seed: number | null;
+    spawn_seed: number | null;
+    values: Array<number | null>;
+    excluded: boolean;
+    why?: string;
+}
+export interface ExperimentReportComparison {
+    arm: number;
+    control: number;
+    n: number;
+    last_trial: number | null;
+    mean_diff: number | null;
+    alpha: number;
+    stop: boolean;
+    reason: string;
+    verdict: 'arm_better' | 'control_better' | 'undecided' | null;
+    interval: Interval | null;
+    detail: string;
+}
+export interface ExperimentReportDetectableGap {
+    sd_diff: number | null;
+    source: 'observed' | 'prior';
+    gap: number | null;
+    power: number;
+}
+export interface ExperimentReportDecision {
+    stop: boolean;
+    reason: string;
+    summary: string;
+}
+/** The environment. Every field is optional; an omitted field takes the base world default. */
+export interface Env {
+    /** World seed: fixes the map. Omit to draw a fresh one per run; the drawn seed is recorded on the run. */
+    seed?: number;
+    /** Fixes where the roster lands. Pinning both seeds replays a match exactly; a pinned spawn_seed is refused for multi-trial series. */
+    spawn_seed?: number;
+    /** Milliseconds each agent gets to take its turn in a round. */
+    turn_timeout_ms?: number;
+    /** Actions budgeted per agent per round. */
+    actions_per_turn?: number;
+    /** The witness knob. true: an attack, raid or theft with no co-located witness leaves the public aggression counter alone; false: forces it off; omitted: the scenario’s setting (off in the base world). Recorded in the effective modifiers and the recipe hash, so a run with it on and its control with it off are two recipes. The match’s witness report (GET /api/matches/:id/behavior, witness) reads defection watched against defection alone. */
+    unwitnessed_anonymity?: boolean;
+    /** Per resource (wood, stone, food, ore, relics): { max?, regen? } multipliers of the base world definition, 0 to 10, where 1 is the base. */
+    resources?: JsonObject;
+    /** Baseline bot policy ids or one population id (expands to its members). [] means none. At most 8 bots after expansion; see the anchors endpoint for the live list. */
+    anchors?: string[];
+}
+export interface ExperimentArmSeat {
+    /** Required on every seat not marked invited; ignored on one that is. Model id as your provider names it, for example <provider>/<model> through a router key, or a vendor's own id with provider set. */
+    model?: string;
+    /** Which stored key runs this seat: openrouter (default) or a native vendor such as anthropic, openai, google. The account must hold that key under Account > Provider keys. */
+    provider?: string;
+    /** Seat name shown in the world. Default: derived from the model. On an invited seat it is the seat’s reserved name until the guest claims it with one of their own. */
+    name?: string;
+    /** Reasoning effort where the model supports it. */
+    reasoning?: 'off' | 'low' | 'medium' | 'high';
+    /** Sampling temperature, passed through to the provider. */
+    temperature?: number;
+    /** Output ceiling per call. Default depends on whether reasoning is on. */
+    max_tokens?: number;
+    /** tools (default) uses native tool calling; json is for models without it. */
+    format?: 'tools' | 'json';
+    /** Skill ids to attach: a built-in (builtin:trader) or one of your own (usk_...), from the skills endpoint. Built-ins are written for the world and are refused on arena seats. */
+    skills?: string[];
+    /** Extra system instructions for this seat, appended verbatim after any skills. Skills plus instructions may total 8000 characters. Any skill or instruction stamps +custom.<hash> onto the seat’s scaffold identity. */
+    instructions?: string;
+}
+export interface LaunchResponseBatch {
+    id: string;
+    trials: number;
+    seed_mode: 'vary' | 'pinned';
+}
+/** One method per API operation. The transport is the subclass's. */
+export declare abstract class Operations {
+    protected abstract request<T>(method: Method, path: string, parts?: RequestParts): Promise<T>;
+    /**
+     * API index.
+     *
+     * Discover the API without a token: endpoints, docs, the MCP path.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-index
+     */
+    index(): Promise<JsonObject>;
+    /**
+     * OpenAPI document.
+     *
+     * The API as an OpenAPI 3.1 document, for generators and API clients.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-openapi
+     */
+    openapi(): Promise<JsonObject>;
+    /**
+     * Who am I.
+     *
+     * The account, plan, this token’s scopes and the limits that bound scenarios and runs.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-me
+     */
+    me(): Promise<JsonObject>;
+    /**
+     * Scenario schema.
+     *
+     * JSON Schema (draft 2020-12) for a scenario body, with the live resource types and anchor ids.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-schema
+     */
+    schema(): Promise<JsonObject>;
+    /**
+     * Library scenarios.
+     *
+     * The scenarios the platform ships. Any of their ids can be launched directly.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-library-scenarios
+     */
+    libraryScenarios(): Promise<JsonObject>;
+    /**
+     * Anchor bots.
+     *
+     * Baseline bot policies and populations a scenario may field as `env.anchors`.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-library-anchors
+     */
+    libraryAnchors(): Promise<JsonObject>;
+    /**
+     * Validate a scenario.
+     *
+     * Dry run: the normalized definition, its content hash and the plan receipt. Nothing is saved.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-validate
+     */
+    validate(body: ScenarioBody): Promise<JsonObject>;
+    /**
+     * List your scenarios.
+     *
+     * Every scenario saved on the account, newest first.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-list-scenarios
+     */
+    listScenarios(): Promise<ListScenariosResponse>;
+    /**
+     * Create a scenario.
+     *
+     * Save a scenario. Idempotent on name plus content hash.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-create-scenario
+     */
+    createScenario(body: ScenarioBody): Promise<CreateScenarioResponse>;
+    /**
+     * Get a scenario.
+     *
+     * One saved scenario by id.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-get-scenario
+     */
+    getScenario(id: string): Promise<GetScenarioResponse>;
+    /**
+     * Update a scenario.
+     *
+     * Edit a saved scenario in place. Omitted fields keep their value.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-update-scenario
+     */
+    updateScenario(id: string, body: UpdateScenarioBody): Promise<UpdateScenarioResponse>;
+    /**
+     * Delete a scenario.
+     *
+     * Remove a saved scenario. Played runs keep their snapshot.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-delete-scenario
+     */
+    deleteScenario(id: string): Promise<DeleteScenarioResponse>;
+    /**
+     * List skills.
+     *
+     * The built-in skills, your own, and the authoring bounds.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-list-skills
+     */
+    listSkills(): Promise<ListSkillsResponse>;
+    /**
+     * Create a skill.
+     *
+     * Save a prompt module on the account.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-create-skill
+     */
+    createSkill(body: SkillBody): Promise<CreateSkillResponse>;
+    /**
+     * Get a skill.
+     *
+     * One skill by id: a built-in or one of yours.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-get-skill
+     */
+    getSkill(id: string): Promise<GetSkillResponse>;
+    /**
+     * Update a skill.
+     *
+     * Edit in place. Omitted fields keep their value.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-update-skill
+     */
+    updateSkill(id: string, body: UpdateSkillBody): Promise<UpdateSkillResponse>;
+    /**
+     * Delete a skill.
+     *
+     * Remove one of your skills. Played runs keep their snapshot.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-delete-skill
+     */
+    deleteSkill(id: string): Promise<DeleteSkillResponse>;
+    /**
+     * Estimate a run.
+     *
+     * What a launch of this body would cost and commit, or the refusal it would get. Nothing is queued.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-estimate
+     */
+    estimate(body: RunBody): Promise<JsonObject>;
+    /**
+     * Launch a run.
+     *
+     * Queue a run, or a series batch when `trials` is above 1.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-launch
+     */
+    launch(body: RunBody): Promise<LaunchResponse>;
+    /**
+     * List your runs.
+     *
+     * Your runs, newest first.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-list-runs
+     */
+    listRuns(query?: {
+        limit?: number;
+    }): Promise<ListRunsResponse>;
+    /**
+     * Get a run.
+     *
+     * One run: status, the as-played configuration and, once finished, the scored results per seat.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-get-run
+     */
+    getRun(id: string): Promise<GetRunResponse>;
+    /**
+     * Usage and allowances.
+     *
+     * The meter’s record of your runs and where the account stands against the plan this month.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-usage
+     */
+    usage(): Promise<JsonObject>;
+    /**
+     * Live worlds.
+     *
+     * Every world your account has playing right now, as small boards, and every run waiting for one.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-live
+     */
+    live(): Promise<JsonObject>;
+    /**
+     * Get a batch report.
+     *
+     * A series batch as one report: per-model intervals, survival, cost, every trial, and a verdict.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-get-batch
+     */
+    getBatch(id: string): Promise<GetBatchResponse>;
+    /**
+     * Estimate an experiment.
+     *
+     * What creating this experiment would cost and check against, or the refusal it would get. Nothing is queued.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-estimate-experiment
+     */
+    estimateExperiment(body: ExperimentBody): Promise<JsonObject>;
+    /**
+     * Create an experiment.
+     *
+     * Queue a paired experiment: two to four arms of one scenario on shared seeds, under a stopping rule.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-create-experiment
+     */
+    createExperiment(body: ExperimentBody): Promise<CreateExperimentResponse>;
+    /**
+     * List your experiments.
+     *
+     * Your experiments, newest first, with the verdict on record.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-list-experiments
+     */
+    listExperiments(): Promise<ListExperimentsResponse>;
+    /**
+     * Get an experiment report.
+     *
+     * The paired report as scored right now: per arm, per pair, each comparison against the control, the decision and a verdict.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-get-experiment
+     */
+    getExperiment(id: string): Promise<GetExperimentResponse>;
+    /**
+     * Cancel an experiment.
+     *
+     * Stop a queued or running experiment: every unfinished trial of every arm, then the record.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-cancel-experiment
+     */
+    cancelExperiment(id: string): Promise<CancelExperimentResponse>;
+    /**
+     * Cancel a run.
+     *
+     * Stop a queued or running run.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-cancel
+     */
+    cancel(id: string): Promise<CancelResponse>;
+    /**
+     * List a run’s logs.
+     *
+     * The harness log files kept for one of your runs, with their sizes and how long they are kept.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-run-logs
+     */
+    runLogs(id: string): Promise<JsonObject>;
+    /**
+     * Read a run log.
+     *
+     * One log file, as the JSONL the harness wrote.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-run-log
+     */
+    runLog(id: string, file: string): Promise<string>;
+    /**
+     * List a run’s guest seats.
+     *
+     * Every guest seat of one of your world runs: its link, its state and who claimed it.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-list-invites
+     */
+    listInvites(id: string): Promise<JsonObject>;
+    /**
+     * Extend the signup window.
+     *
+     * Move every open seat’s claim-by deadline to `minutes` from now.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-extend-invites
+     */
+    extendInvites(id: string, body: ExtendInvitesBody): Promise<JsonObject>;
+    /**
+     * Regenerate a seat’s link.
+     *
+     * A fresh link for one seat; the old token stops resolving at once.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-regenerate-invite
+     */
+    regenerateInvite(id: string, inviteId: string): Promise<JsonObject>;
+    /**
+     * Withdraw a seat.
+     *
+     * Withdraw one guest seat: its link stops resolving and the seat leaves the roster at launch.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-revoke-invite
+     */
+    revokeInvite(id: string, inviteId: string): Promise<JsonObject>;
+}