@redis-iris/agent-playbook 0.0.0-stage → 0.1.0-alpha.3

package/src/sdk/sdk.ts

@@ -0,0 +1,557 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 70777130d3ff
+ */
+
+import { acceptProposal } from "../funcs/accept-proposal.js";
+import { appendFaqVersion } from "../funcs/append-faq-version.js";
+import { appendSkillVersion } from "../funcs/append-skill-version.js";
+import { createFaq } from "../funcs/create-faq.js";
+import { createProposal } from "../funcs/create-proposal.js";
+import { createSkill } from "../funcs/create-skill.js";
+import { deleteFaq } from "../funcs/delete-faq.js";
+import { deleteFaqs } from "../funcs/delete-faqs.js";
+import { deleteSkill } from "../funcs/delete-skill.js";
+import { deleteSkills } from "../funcs/delete-skills.js";
+import { discoverEntries } from "../funcs/discover-entries.js";
+import { dismissProposal } from "../funcs/dismiss-proposal.js";
+import { getFaqVersion } from "../funcs/get-faq-version.js";
+import { getFaq } from "../funcs/get-faq.js";
+import { getPlaybookHealth } from "../funcs/get-playbook-health.js";
+import { getProposal } from "../funcs/get-proposal.js";
+import { getSkillResource } from "../funcs/get-skill-resource.js";
+import { getSkillVersion } from "../funcs/get-skill-version.js";
+import { getSkill } from "../funcs/get-skill.js";
+import { listFaqVersions } from "../funcs/list-faq-versions.js";
+import { listFaqs } from "../funcs/list-faqs.js";
+import { listProposals } from "../funcs/list-proposals.js";
+import { listSkillVersions } from "../funcs/list-skill-versions.js";
+import { listSkills } from "../funcs/list-skills.js";
+import { lookupEntries } from "../funcs/lookup-entries.js";
+import { publishFaq } from "../funcs/publish-faq.js";
+import { publishSkill } from "../funcs/publish-skill.js";
+import { purgeProposal } from "../funcs/purge-proposal.js";
+import { replaceProposal } from "../funcs/replace-proposal.js";
+import { restoreProposal } from "../funcs/restore-proposal.js";
+import { searchFaqs } from "../funcs/search-faqs.js";
+import { searchProposals } from "../funcs/search-proposals.js";
+import { searchSkills } from "../funcs/search-skills.js";
+import { submitProposalEvidence } from "../funcs/submit-proposal-evidence.js";
+import { withdrawFaq } from "../funcs/withdraw-faq.js";
+import { withdrawSkill } from "../funcs/withdraw-skill.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 Playbook extends ClientSDK {
+  async discoverEntries(
+    request: models.DiscoverEntriesRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.DiscoverEntriesResponseContent> {
+    return unwrapAsync(discoverEntries(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Resolves bounded entry references to compact management state. Results preserve input order and report misses explicitly. Each item is authoritative when read, but the batch is not a global snapshot.
+   */
+  async lookupEntries(
+    request: models.LookupEntriesRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.LookupEntriesResponseContent> {
+    return unwrapAsync(lookupEntries(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Deletes the requested FAQ families sequentially. Each family deletion is atomic, but the batch is not: deletions completed before an error remain applied. Retrying the same request is safe because already absent entries are ignored.
+   */
+  async deleteFaqs(
+    request: models.DeleteFaqsRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.DeleteFaqsResponseContent> {
+    return unwrapAsync(deleteFaqs(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listFaqs(
+    sortBy?: models.EntrySort | undefined,
+    sortOrder?: models.SortOrder | undefined,
+    createdAfter?: Date | undefined,
+    createdBefore?: Date | undefined,
+    published?: boolean | undefined,
+    limit?: number | undefined,
+    cursor?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListFaqsResponseContent> {
+    return unwrapAsync(listFaqs(
+      this,
+      sortBy,
+      sortOrder,
+      createdAfter,
+      createdBefore,
+      published,
+      limit,
+      cursor,
+      options,
+    ));
+  }
+
+  async createFaq(
+    request: models.CreateFaqRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.CreateFaqResponseContent> {
+    return unwrapAsync(createFaq(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async searchFaqs(
+    request: models.SearchFaqsRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.SearchFaqsResponseContent> {
+    return unwrapAsync(searchFaqs(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async deleteFaq(
+    faqId: string,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(deleteFaq(
+      this,
+      faqId,
+      options,
+    ));
+  }
+
+  async getFaq(
+    faqId: string,
+    options?: RequestOptions,
+  ): Promise<models.GetFaqResponseContent> {
+    return unwrapAsync(getFaq(
+      this,
+      faqId,
+      options,
+    ));
+  }
+
+  /**
+   * Withdraws the FAQ publication without changing version content. An already-unpublished entry is a no-op. Concurrent publication changes are last-write-wins in Playbook v1.
+   */
+  async withdrawFaq(
+    faqId: string,
+    options?: RequestOptions,
+  ): Promise<models.WithdrawFaqResponseContent> {
+    return unwrapAsync(withdrawFaq(
+      this,
+      faqId,
+      options,
+    ));
+  }
+
+  /**
+   * Publishes the selected immutable FAQ version. Repeating the currently published version is a no-op. Concurrent publication changes are last-write-wins in Playbook v1.
+   */
+  async publishFaq(
+    faqId: string,
+    body: models.PublishFaqRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.PublishFaqResponseContent> {
+    return unwrapAsync(publishFaq(
+      this,
+      faqId,
+      body,
+      options,
+    ));
+  }
+
+  async listFaqVersions(
+    faqId: string,
+    createdAfter?: Date | undefined,
+    createdBefore?: Date | undefined,
+    limit?: number | undefined,
+    cursor?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListFaqVersionsResponseContent> {
+    return unwrapAsync(listFaqVersions(
+      this,
+      faqId,
+      createdAfter,
+      createdBefore,
+      limit,
+      cursor,
+      options,
+    ));
+  }
+
+  async appendFaqVersion(
+    faqId: string,
+    body: models.AppendFaqVersionRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.AppendFaqVersionResponseContent> {
+    return unwrapAsync(appendFaqVersion(
+      this,
+      faqId,
+      body,
+      options,
+    ));
+  }
+
+  async getFaqVersion(
+    faqId: string,
+    version: number,
+    options?: RequestOptions,
+  ): Promise<models.GetFaqVersionResponseContent> {
+    return unwrapAsync(getFaqVersion(
+      this,
+      faqId,
+      version,
+      options,
+    ));
+  }
+
+  async getPlaybookHealth(
+    request?: operations.GetPlaybookHealthRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.GetPlaybookHealthResponseContent> {
+    return unwrapAsync(getPlaybookHealth(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listProposals(
+    view: models.ProposalView,
+    sortBy?: models.ProposalSort | undefined,
+    sortOrder?: models.SortOrder | undefined,
+    limit?: number | undefined,
+    cursor?: string | undefined,
+    actionType?: models.ProposalActionType | undefined,
+    entryType?: models.EntryType | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListProposalsResponseContent> {
+    return unwrapAsync(listProposals(
+      this,
+      view,
+      sortBy,
+      sortOrder,
+      limit,
+      cursor,
+      actionType,
+      entryType,
+      options,
+    ));
+  }
+
+  async createProposal(
+    request: models.CreateProposalRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.CreateProposalResponseContent> {
+    return unwrapAsync(createProposal(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async searchProposals(
+    request: models.SearchProposalsRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.SearchProposalsResponseContent> {
+    return unwrapAsync(searchProposals(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async purgeProposal(
+    proposalId: string,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(purgeProposal(
+      this,
+      proposalId,
+      options,
+    ));
+  }
+
+  async getProposal(
+    proposalId: string,
+    options?: RequestOptions,
+  ): Promise<models.GetProposalResponseContent> {
+    return unwrapAsync(getProposal(
+      this,
+      proposalId,
+      options,
+    ));
+  }
+
+  async replaceProposal(
+    proposalId: string,
+    body: models.ReplaceProposalRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.ReplaceProposalResponseContent> {
+    return unwrapAsync(replaceProposal(
+      this,
+      proposalId,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Promotes the reviewed revision to one canonical unpublished FAQ.
+   * Concurrent calls and retries resume or return the proposal's recorded target.
+   * A complete target may be visible to management before the proposal reaches
+   * promoted, but remains absent from serving until separately published.
+   */
+  async acceptProposal(
+    proposalId: string,
+    body: models.AcceptProposalRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.AcceptProposalResponseContent> {
+    return unwrapAsync(acceptProposal(
+      this,
+      proposalId,
+      body,
+      options,
+    ));
+  }
+
+  async restoreProposal(
+    proposalId: string,
+    options?: RequestOptions,
+  ): Promise<models.RestoreProposalResponseContent> {
+    return unwrapAsync(restoreProposal(
+      this,
+      proposalId,
+      options,
+    ));
+  }
+
+  async dismissProposal(
+    proposalId: string,
+    body?: models.DismissProposalRequestContent | undefined,
+    options?: RequestOptions,
+  ): Promise<models.DismissProposalResponseContent> {
+    return unwrapAsync(dismissProposal(
+      this,
+      proposalId,
+      body,
+      options,
+    ));
+  }
+
+  async submitProposalEvidence(
+    proposalId: string,
+    evidenceId: string,
+    body: models.SubmitProposalEvidenceRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.SubmitProposalEvidenceResponseContent> {
+    return unwrapAsync(submitProposalEvidence(
+      this,
+      proposalId,
+      evidenceId,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Deletes the requested Skill families sequentially. Each family deletion is atomic, but the batch is not: deletions completed before an error remain applied. Retrying the same request is safe because already absent entries are ignored.
+   */
+  async deleteSkills(
+    request: models.DeleteSkillsRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.DeleteSkillsResponseContent> {
+    return unwrapAsync(deleteSkills(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listSkills(
+    sortBy?: models.EntrySort | undefined,
+    sortOrder?: models.SortOrder | undefined,
+    createdAfter?: Date | undefined,
+    createdBefore?: Date | undefined,
+    published?: boolean | undefined,
+    limit?: number | undefined,
+    cursor?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListSkillsResponseContent> {
+    return unwrapAsync(listSkills(
+      this,
+      sortBy,
+      sortOrder,
+      createdAfter,
+      createdBefore,
+      published,
+      limit,
+      cursor,
+      options,
+    ));
+  }
+
+  async createSkill(
+    request: models.CreateSkillRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.CreateSkillResponseContent> {
+    return unwrapAsync(createSkill(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async searchSkills(
+    request: models.SearchSkillsRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.SearchSkillsResponseContent> {
+    return unwrapAsync(searchSkills(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async deleteSkill(
+    skillId: string,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(deleteSkill(
+      this,
+      skillId,
+      options,
+    ));
+  }
+
+  async getSkill(
+    skillId: string,
+    options?: RequestOptions,
+  ): Promise<models.GetSkillResponseContent> {
+    return unwrapAsync(getSkill(
+      this,
+      skillId,
+      options,
+    ));
+  }
+
+  /**
+   * Withdraws the Skill publication without changing version content. An already-unpublished entry is a no-op. Concurrent publication changes are last-write-wins in Playbook v1.
+   */
+  async withdrawSkill(
+    skillId: string,
+    options?: RequestOptions,
+  ): Promise<models.WithdrawSkillResponseContent> {
+    return unwrapAsync(withdrawSkill(
+      this,
+      skillId,
+      options,
+    ));
+  }
+
+  /**
+   * Publishes the selected immutable Skill version. Repeating the currently published version is a no-op. Concurrent publication changes are last-write-wins in Playbook v1.
+   */
+  async publishSkill(
+    skillId: string,
+    body: models.PublishSkillRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.PublishSkillResponseContent> {
+    return unwrapAsync(publishSkill(
+      this,
+      skillId,
+      body,
+      options,
+    ));
+  }
+
+  async listSkillVersions(
+    skillId: string,
+    createdAfter?: Date | undefined,
+    createdBefore?: Date | undefined,
+    limit?: number | undefined,
+    cursor?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListSkillVersionsResponseContent> {
+    return unwrapAsync(listSkillVersions(
+      this,
+      skillId,
+      createdAfter,
+      createdBefore,
+      limit,
+      cursor,
+      options,
+    ));
+  }
+
+  async appendSkillVersion(
+    skillId: string,
+    body: models.AppendSkillVersionRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.AppendSkillVersionResponseContent> {
+    return unwrapAsync(appendSkillVersion(
+      this,
+      skillId,
+      body,
+      options,
+    ));
+  }
+
+  async getSkillVersion(
+    skillId: string,
+    version: number,
+    options?: RequestOptions,
+  ): Promise<models.GetSkillVersionResponseContent> {
+    return unwrapAsync(getSkillVersion(
+      this,
+      skillId,
+      version,
+      options,
+    ));
+  }
+
+  /**
+   * Returns the exact immutable Skill resource bytes as a streamed response.
+   *
+   * Every successful resource read includes a required `Content-Digest` response
+   * header. Header names are case-insensitive. The header uses the RFC 9530
+   * `sha-256=:<base64>:` representation, while the resource descriptor in the
+   * Skill version uses `sha256:<lowercase-hex>`. Both encode the same SHA-256
+   * digest bytes and must not be compared as strings.
+   */
+  async getSkillResource(
+    skillId: string,
+    version: number,
+    resourceId: string,
+    options?: RequestOptions,
+  ): Promise<operations.GetSkillResourceResponse> {
+    return unwrapAsync(getSkillResource(
+      this,
+      skillId,
+      version,
+      resourceId,
+      options,
+    ));
+  }
+}

package/src/types/async.ts

@@ -0,0 +1,70 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8869c9443f28
+ */
+
+export type APICall =
+  | {
+      status: "complete";
+      request: Request;
+      response: Response;
+    }
+  | {
+      status: "request-error";
+      request: Request;
+      response?: undefined;
+    }
+  | {
+      status: "invalid";
+      request?: undefined;
+      response?: undefined;
+    };
+
+export class APIPromise<T> implements Promise<T> {
+  readonly #promise: Promise<[T, APICall]>;
+  #unwrapped: Promise<T> | null;
+
+  readonly [Symbol.toStringTag] = "APIPromise";
+
+  constructor(p: [T, APICall] | Promise<[T, APICall]>) {
+    this.#promise = p instanceof Promise ? p : Promise.resolve(p);
+    this.#unwrapped = p instanceof Promise ? null : Promise.resolve(p[0]);
+  }
+
+  #getUnwrapped(): Promise<T> {
+    return (this.#unwrapped ??= this.#promise.then(([value]) => value));
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | null
+      | undefined,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | null
+      | undefined,
+  ): Promise<TResult1 | TResult2> {
+    return this.#promise.then(
+      onfulfilled ? ([value]) => onfulfilled(value) : void 0,
+      onrejected,
+    );
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: any) => TResult | PromiseLike<TResult>)
+      | null
+      | undefined,
+  ): Promise<T | TResult> {
+    return this.#getUnwrapped().catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.#getUnwrapped().finally(onfinally);
+  }
+
+  $inspect(): Promise<[T, APICall]> {
+    return this.#promise;
+  }
+}

package/src/types/blobs.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 28ae8d452d1f
+ */
+
+import * as z from "zod/v3";
+
+export const blobLikeSchema: z.ZodType<Blob, z.ZodTypeDef, Blob> = z.custom<
+  Blob
+>(isBlobLike, {
+  message: "expected a Blob, File or Blob-like object",
+  fatal: true,
+});
+
+export function isBlobLike(val: unknown): val is Blob {
+  if (val instanceof Blob) {
+    return true;
+  }
+
+  if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+    return false;
+  }
+
+  const name = val[Symbol.toStringTag];
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name !== "Blob" && name !== "File") {
+    return false;
+  }
+
+  return "stream" in val && typeof val.stream === "function";
+}

package/src/types/const-date-time.ts

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 42ad5865ce47
+ */
+
+import * as z from "zod/v3";
+
+export function constDateTime(
+  val: string,
+): z.ZodType<string, z.ZodTypeDef, unknown> {
+  return z.custom<string>((v) => {
+    return (
+      typeof v === "string" && new Date(v).getTime() === new Date(val).getTime()
+    );
+  }, `Value must be equivalent to ${val}`);
+}