/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import { memoryArchivesSync } from "../funcs/memory-archives-sync.js";
import { memoryConflictsResolve } from "../funcs/memory-conflicts-resolve.js";
import { memoryContextAssemble } from "../funcs/memory-context-assemble.js";
import { memoryEvalsRun } from "../funcs/memory-evals-run.js";
import { memoryGraphAdd } from "../funcs/memory-graph-add.js";
import { memoryGraphSearch } from "../funcs/memory-graph-search.js";
import { memoryItemsDelete } from "../funcs/memory-items-delete.js";
import { memoryItemsGet } from "../funcs/memory-items-get.js";
import { memoryItemsSearch } from "../funcs/memory-items-search.js";
import { memoryItemsUpdate } from "../funcs/memory-items-update.js";
import { memoryJobsCreate } from "../funcs/memory-jobs-create.js";
import { memoryJobsGet } from "../funcs/memory-jobs-get.js";
import { memoryLayersSearch } from "../funcs/memory-layers-search.js";
import { memoryList } from "../funcs/memory-list.js";
import { memoryLoop } from "../funcs/memory-loop.js";
import { memoryLoopsGet } from "../funcs/memory-loops-get.js";
import { memoryLoopsList } from "../funcs/memory-loops-list.js";
import { memoryPatternsGet } from "../funcs/memory-patterns-get.js";
import { memoryPatternsList } from "../funcs/memory-patterns-list.js";
import { memoryPatternsPromote } from "../funcs/memory-patterns-promote.js";
import { memoryPatternsValidate } from "../funcs/memory-patterns-validate.js";
import { memoryRemember } from "../funcs/memory-remember.js";
import { memoryRerank } from "../funcs/memory-rerank.js";
import { memorySchedulesCreate } from "../funcs/memory-schedules-create.js";
import { memorySchedulesDelete } from "../funcs/memory-schedules-delete.js";
import { memorySchedulesList } from "../funcs/memory-schedules-list.js";
import { memorySchedulesPause } from "../funcs/memory-schedules-pause.js";
import { memorySchedulesResume } from "../funcs/memory-schedules-resume.js";
import { memorySchedulesTrigger } from "../funcs/memory-schedules-trigger.js";
import { memorySessionsCompress } from "../funcs/memory-sessions-compress.js";
import { memorySessionsWorkingGet } from "../funcs/memory-sessions-working-get.js";
import { memorySessionsWorkingUpdate } from "../funcs/memory-sessions-working-update.js";
import { memorySkillsGet } from "../funcs/memory-skills-get.js";
import { memorySkillsList } from "../funcs/memory-skills-list.js";
import { memoryStatsGet } from "../funcs/memory-stats-get.js";
import { memoryTranscriptGet } from "../funcs/memory-transcript-get.js";
import { memoryTranscriptStore } from "../funcs/memory-transcript-store.js";
import { memoryTranscriptsIndex } from "../funcs/memory-transcripts-index.js";
import { memoryTurnRecord } from "../funcs/memory-turn-record.js";
import { memoryVectorIndex } from "../funcs/memory-vector-index.js";
import { memoryVectorSearch } from "../funcs/memory-vector-search.js";
import { ClientSDK, RequestOptions } from "../lib/sdks.js";
import * as models from "../models/index.js";
import * as operations from "../models/operations/index.js";
import { unwrapAsync } from "../types/fp.js";

export class Memory extends ClientSDK {
  /**
   * Assemble compact pre-turn memory context.
   *
   * @remarks
   * Agent-first memory loop step. Call before reasoning or tool use. Returns a
   * compact prompt and structured memory items across working, scene, graph,
   * patterns, archives, and vectors.
   */
  async contextAssemble(
    request: models.AgentMemoryContextRequest,
    options?: RequestOptions,
  ): Promise<models.AgentMemoryContextResponse> {
    return unwrapAsync(memoryContextAssemble(
      this,
      request,
      options,
    ));
  }

  /**
   * Persist the completed turn.
   *
   * @remarks
   * Agent-first memory loop step. Call after the assistant final answer to store
   * transcript, working memory, and vector memory for later retrieval.
   */
  async turnRecord(
    request: models.AgentMemoryRecordTurnRequest,
    options?: RequestOptions,
  ): Promise<models.AgentMemoryRecordTurnResponse> {
    return unwrapAsync(memoryTurnRecord(
      this,
      request,
      options,
    ));
  }

  /**
   * Save an explicit durable fact or preference.
   *
   * @remarks
   * Agent-first memory loop step. Call when the agent identifies a durable fact,
   * preference, correction, decision, or operational lesson.
   */
  async remember(
    request: models.AgentMemoryRememberRequest,
    options?: RequestOptions,
  ): Promise<models.AgentMemoryRememberResponse> {
    return unwrapAsync(memoryRemember(
      this,
      request,
      options,
    ));
  }

  /**
   * Single endpoint for the agent memory loop.
   *
   * @remarks
   * Minimal-token agent surface. Set `step` to `pre_turn`, `post_turn`, or
   * `remember`; each response returns the next valid loop steps.
   */
  async loop(
    request: models.AgentMemoryLoopRequest,
    options?: RequestOptions,
  ): Promise<operations.LoopResponse> {
    return unwrapAsync(memoryLoop(
      this,
      request,
      options,
    ));
  }

  /**
   * List compact agent-first memory loop manifests.
   */
  async loopsList(
    options?: RequestOptions,
  ): Promise<models.MemoryLoopListResponse> {
    return unwrapAsync(memoryLoopsList(
      this,
      options,
    ));
  }

  /**
   * Fetch one compact memory loop manifest.
   */
  async loopsGet(
    request: operations.LoopsGetRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryLoopResponse> {
    return unwrapAsync(memoryLoopsGet(
      this,
      request,
      options,
    ));
  }

  /**
   * List learned procedural memory patterns.
   */
  async patternsList(
    request?: operations.PatternsListRequest | undefined,
    options?: RequestOptions,
  ): Promise<models.ProceduralPatternListResponse> {
    return unwrapAsync(memoryPatternsList(
      this,
      request,
      options,
    ));
  }

  /**
   * Fetch one procedural memory pattern.
   */
  async patternsGet(
    request: operations.PatternsGetRequest,
    options?: RequestOptions,
  ): Promise<models.ProceduralPatternResponse> {
    return unwrapAsync(memoryPatternsGet(
      this,
      request,
      options,
    ));
  }

  /**
   * Validate a procedural memory pattern before promotion.
   */
  async patternsValidate(
    request: operations.PatternsValidateRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryPatternValidation> {
    return unwrapAsync(memoryPatternsValidate(
      this,
      request,
      options,
    ));
  }

  /**
   * Promote a validated procedural pattern into a learned skill.
   */
  async patternsPromote(
    request: operations.PatternsPromoteRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryPatternPromoteResponse> {
    return unwrapAsync(memoryPatternsPromote(
      this,
      request,
      options,
    ));
  }

  /**
   * List learned memory skills.
   */
  async skillsList(
    request?: operations.SkillsListRequest | undefined,
    options?: RequestOptions,
  ): Promise<models.LearnedSkillListResponse> {
    return unwrapAsync(memorySkillsList(
      this,
      request,
      options,
    ));
  }

  /**
   * Fetch one learned memory skill.
   */
  async skillsGet(
    request: operations.SkillsGetRequest,
    options?: RequestOptions,
  ): Promise<models.LearnedSkillResponse> {
    return unwrapAsync(memorySkillsGet(
      this,
      request,
      options,
    ));
  }

  /**
   * Add graph memory through the configured graph provider.
   */
  async graphAdd(
    request: models.MemoryAddRequest,
    options?: RequestOptions,
  ): Promise<Array<models.GraphMemoryItem>> {
    return unwrapAsync(memoryGraphAdd(
      this,
      request,
      options,
    ));
  }

  /**
   * Search graph memory through the configured graph provider.
   */
  async graphSearch(
    request: models.MemorySearchRequest,
    options?: RequestOptions,
  ): Promise<Array<models.GraphMemoryItem>> {
    return unwrapAsync(memoryGraphSearch(
      this,
      request,
      options,
    ));
  }

  /**
   * List memories for an agent wallet.
   */
  async list(
    request: operations.ListRequest,
    options?: RequestOptions,
  ): Promise<Array<models.GraphMemoryItem>> {
    return unwrapAsync(memoryList(
      this,
      request,
      options,
    ));
  }

  /**
   * Search vector memory.
   */
  async vectorSearch(
    request: models.VectorSearchRequest,
    options?: RequestOptions,
  ): Promise<models.VectorSearchResponse> {
    return unwrapAsync(memoryVectorSearch(
      this,
      request,
      options,
    ));
  }

  /**
   * Index a memory vector.
   */
  async vectorIndex(
    request: models.VectorIndexRequest,
    options?: RequestOptions,
  ): Promise<models.VectorIndexResponse> {
    return unwrapAsync(memoryVectorIndex(
      this,
      request,
      options,
    ));
  }

  /**
   * Store a session transcript.
   */
  async transcriptStore(
    request: models.TranscriptStoreRequest,
    options?: RequestOptions,
  ): Promise<models.SuccessResponse> {
    return unwrapAsync(memoryTranscriptStore(
      this,
      request,
      options,
    ));
  }

  /**
   * Fetch a transcript by session or thread id.
   */
  async transcriptGet(
    request: operations.TranscriptGetRequest,
    options?: RequestOptions,
  ): Promise<models.SessionTranscript> {
    return unwrapAsync(memoryTranscriptGet(
      this,
      request,
      options,
    ));
  }

  /**
   * Store, index, and optionally update working memory from a transcript.
   */
  async transcriptsIndex(
    request: models.TranscriptIndexRequest,
    options?: RequestOptions,
  ): Promise<models.TranscriptIndexResponse> {
    return unwrapAsync(memoryTranscriptsIndex(
      this,
      request,
      options,
    ));
  }

  /**
   * Fetch hot working memory for a session.
   */
  async sessionsWorkingGet(
    request: operations.SessionsWorkingGetRequest,
    options?: RequestOptions,
  ): Promise<models.SessionMemoryResponse> {
    return unwrapAsync(memorySessionsWorkingGet(
      this,
      request,
      options,
    ));
  }

  /**
   * Update hot working memory for a session.
   */
  async sessionsWorkingUpdate(
    request: operations.SessionsWorkingUpdateRequest,
    options?: RequestOptions,
  ): Promise<models.WorkingSessionUpdateResponse> {
    return unwrapAsync(memorySessionsWorkingUpdate(
      this,
      request,
      options,
    ));
  }

  /**
   * Compress a long transcript into durable archive memory.
   */
  async sessionsCompress(
    request: operations.SessionsCompressRequest,
    options?: RequestOptions,
  ): Promise<models.SessionCompressResponse> {
    return unwrapAsync(memorySessionsCompress(
      this,
      request,
      options,
    ));
  }

  /**
   * Sync a memory archive to durable external storage.
   */
  async archivesSync(
    request: operations.ArchivesSyncRequest,
    options?: RequestOptions,
  ): Promise<models.ArchiveSyncResponse> {
    return unwrapAsync(memoryArchivesSync(
      this,
      request,
      options,
    ));
  }

  /**
   * List Temporal memory schedule status.
   */
  async schedulesList(
    request?: operations.SchedulesListRequest | undefined,
    options?: RequestOptions,
  ): Promise<models.MemoryScheduleListResponse> {
    return unwrapAsync(memorySchedulesList(
      this,
      request,
      options,
    ));
  }

  /**
   * Create or replace memory maintenance schedules.
   */
  async schedulesCreate(
    request: models.MemoryScheduleCreateRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryScheduleCreateResponse> {
    return unwrapAsync(memorySchedulesCreate(
      this,
      request,
      options,
    ));
  }

  /**
   * Delete memory maintenance schedules.
   */
  async schedulesDelete(
    request?: operations.SchedulesDeleteRequest | undefined,
    options?: RequestOptions,
  ): Promise<models.MemoryScheduleDeleteResponse> {
    return unwrapAsync(memorySchedulesDelete(
      this,
      request,
      options,
    ));
  }

  /**
   * Pause one memory maintenance schedule.
   */
  async schedulesPause(
    request: operations.SchedulesPauseRequest,
    options?: RequestOptions,
  ): Promise<models.MemorySchedulePauseResponse> {
    return unwrapAsync(memorySchedulesPause(
      this,
      request,
      options,
    ));
  }

  /**
   * Resume one memory maintenance schedule.
   */
  async schedulesResume(
    request: operations.SchedulesResumeRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryScheduleResumeResponse> {
    return unwrapAsync(memorySchedulesResume(
      this,
      request,
      options,
    ));
  }

  /**
   * Trigger one memory maintenance schedule immediately.
   */
  async schedulesTrigger(
    request: operations.SchedulesTriggerRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryScheduleTriggerResponse> {
    return unwrapAsync(memorySchedulesTrigger(
      this,
      request,
      options,
    ));
  }

  /**
   * Rerank candidate memory documents.
   */
  async rerank(
    request: operations.RerankRequest,
    options?: RequestOptions,
  ): Promise<models.RerankResponse> {
    return unwrapAsync(memoryRerank(
      this,
      request,
      options,
    ));
  }

  /**
   * Search all memory layers.
   */
  async layersSearch(
    request: models.MemorySearchRequest,
    options?: RequestOptions,
  ): Promise<models.LayeredSearchResponse> {
    return unwrapAsync(memoryLayersSearch(
      this,
      request,
      options,
    ));
  }

  /**
   * Get memory statistics for an agent wallet.
   */
  async statsGet(
    request: operations.StatsGetRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryStatsResponse> {
    return unwrapAsync(memoryStatsGet(
      this,
      request,
      options,
    ));
  }

  /**
   * Search productized memory items across layers.
   */
  async itemsSearch(
    request: models.MemorySearchRequest,
    options?: RequestOptions,
  ): Promise<models.LayeredSearchResponse> {
    return unwrapAsync(memoryItemsSearch(
      this,
      request,
      options,
    ));
  }

  /**
   * Fetch one durable memory item.
   */
  async itemsGet(
    request: operations.ItemsGetRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryItemResponse> {
    return unwrapAsync(memoryItemsGet(
      this,
      request,
      options,
    ));
  }

  /**
   * Update one durable memory item.
   */
  async itemsUpdate(
    request: operations.ItemsUpdateRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryItemUpdateResponse> {
    return unwrapAsync(memoryItemsUpdate(
      this,
      request,
      options,
    ));
  }

  /**
   * Delete or soft-delete one durable memory item.
   */
  async itemsDelete(
    request: operations.ItemsDeleteRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryItemDeleteResponse> {
    return unwrapAsync(memoryItemsDelete(
      this,
      request,
      options,
    ));
  }

  /**
   * Resolve a memory conflict.
   */
  async conflictsResolve(
    request: operations.ConflictsResolveRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryConflictResolveResponse> {
    return unwrapAsync(memoryConflictsResolve(
      this,
      request,
      options,
    ));
  }

  /**
   * Run a memory maintenance job.
   */
  async jobsCreate(
    request: models.MemoryJobCreateRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryJobRecord> {
    return unwrapAsync(memoryJobsCreate(
      this,
      request,
      options,
    ));
  }

  /**
   * Fetch a memory maintenance job.
   */
  async jobsGet(
    request: operations.JobsGetRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryJobRecord> {
    return unwrapAsync(memoryJobsGet(
      this,
      request,
      options,
    ));
  }

  /**
   * Run a memory retrieval evaluation.
   */
  async evalsRun(
    request: models.MemoryEvalRunRequest,
    options?: RequestOptions,
  ): Promise<models.MemoryEvalRunResponse> {
    return unwrapAsync(memoryEvalsRun(
      this,
      request,
      options,
    ));
  }
}