syllable-sdk 0.0.9

package/src/sdk/organizations.ts

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { organizationsList } from "../funcs/organizationsList.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Organizations extends ClientSDK {
+  /**
+   * Organizations List
+   *
+   * @remarks
+   * List all organizations
+   */
+  async list(
+    options?: RequestOptions,
+  ): Promise<Array<components.Organization>> {
+    return unwrapAsync(organizationsList(
+      this,
+      options,
+    ));
+  }
+}

package/src/sdk/prompts.ts

@@ -0,0 +1,100 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { promptsCreate } from "../funcs/promptsCreate.js";
+import { promptsDelete } from "../funcs/promptsDelete.js";
+import { promptsGetById } from "../funcs/promptsGetById.js";
+import { promptsList } from "../funcs/promptsList.js";
+import { promptsUpdate } from "../funcs/promptsUpdate.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Prompts extends ClientSDK {
+  /**
+   * Prompt List
+   *
+   * @remarks
+   * List the existing prompts
+   */
+  async list(
+    request: operations.PromptsListRequest,
+    options?: RequestOptions,
+  ): Promise<components.ListResponsePrompt> {
+    return unwrapAsync(promptsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create Prompt
+   *
+   * @remarks
+   * Create a new prompt
+   */
+  async create(
+    request: components.PromptCreate,
+    options?: RequestOptions,
+  ): Promise<components.Prompt> {
+    return unwrapAsync(promptsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update Prompt
+   *
+   * @remarks
+   * Update an existing prompt
+   */
+  async update(
+    request: components.Prompt,
+    options?: RequestOptions,
+  ): Promise<components.Prompt> {
+    return unwrapAsync(promptsUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Prompt By Id
+   *
+   * @remarks
+   * Get a prompt by ID
+   */
+  async getById(
+    request: operations.PromptsGetByIdRequest,
+    options?: RequestOptions,
+  ): Promise<components.Prompt> {
+    return unwrapAsync(promptsGetById(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete Prompt
+   *
+   * @remarks
+   * Delete an prompt by ID
+   */
+  async delete(
+    request: operations.PromptsDeleteRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(promptsDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/sdk.ts

@@ -0,0 +1,67 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ClientSDK } from "../lib/sdks.js";
+import { Agents } from "./agents.js";
+import { Channels } from "./channels.js";
+import { Conversations } from "./conversations.js";
+import { CustomMessages } from "./custommessages.js";
+import { Dashboards } from "./dashboards.js";
+import { Events } from "./events.js";
+import { Organizations } from "./organizations.js";
+import { Prompts } from "./prompts.js";
+import { Sessions } from "./sessions.js";
+import { Tools } from "./tools.js";
+
+export class SyllableSDK extends ClientSDK {
+  private _agents?: Agents;
+  get agents(): Agents {
+    return (this._agents ??= new Agents(this._options));
+  }
+
+  private _channels?: Channels;
+  get channels(): Channels {
+    return (this._channels ??= new Channels(this._options));
+  }
+
+  private _conversations?: Conversations;
+  get conversations(): Conversations {
+    return (this._conversations ??= new Conversations(this._options));
+  }
+
+  private _dashboards?: Dashboards;
+  get dashboards(): Dashboards {
+    return (this._dashboards ??= new Dashboards(this._options));
+  }
+
+  private _events?: Events;
+  get events(): Events {
+    return (this._events ??= new Events(this._options));
+  }
+
+  private _customMessages?: CustomMessages;
+  get customMessages(): CustomMessages {
+    return (this._customMessages ??= new CustomMessages(this._options));
+  }
+
+  private _prompts?: Prompts;
+  get prompts(): Prompts {
+    return (this._prompts ??= new Prompts(this._options));
+  }
+
+  private _sessions?: Sessions;
+  get sessions(): Sessions {
+    return (this._sessions ??= new Sessions(this._options));
+  }
+
+  private _tools?: Tools;
+  get tools(): Tools {
+    return (this._tools ??= new Tools(this._options));
+  }
+
+  private _organizations?: Organizations;
+  get organizations(): Organizations {
+    return (this._organizations ??= new Organizations(this._options));
+  }
+}

package/src/sdk/sessions.ts

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sessionsList } from "../funcs/sessionsList.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Sessions extends ClientSDK {
+  /**
+   * Sessions List
+   */
+  async list(
+    request: operations.SessionsListRequest,
+    options?: RequestOptions,
+  ): Promise<components.ListResponseSession> {
+    return unwrapAsync(sessionsList(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/targets.ts

@@ -0,0 +1,91 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { channelsTargetsAvailableTargets } from "../funcs/channelsTargetsAvailableTargets.js";
+import { channelsTargetsCreate } from "../funcs/channelsTargetsCreate.js";
+import { channelsTargetsGetById } from "../funcs/channelsTargetsGetById.js";
+import { channelsTargetsList } from "../funcs/channelsTargetsList.js";
+import { channelsTargetsUpdate } from "../funcs/channelsTargetsUpdate.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Targets extends ClientSDK {
+  /**
+   * Available Targets List
+   *
+   * @remarks
+   * List the available phone numbers
+   */
+  async availableTargets(
+    request: operations.AvailableTargetsRequest,
+    options?: RequestOptions,
+  ): Promise<components.ListResponseAvailableTarget> {
+    return unwrapAsync(channelsTargetsAvailableTargets(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Channel Targets
+   */
+  async list(
+    request: operations.ChannelTargetsListRequest,
+    options?: RequestOptions,
+  ): Promise<components.ListResponseChannelTarget> {
+    return unwrapAsync(channelsTargetsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Assign A Channel Target
+   */
+  async create(
+    request: operations.ChannelTargetsCreateRequest,
+    options?: RequestOptions,
+  ): Promise<components.ChannelTarget> {
+    return unwrapAsync(channelsTargetsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get A Channel Target
+   */
+  async getById(
+    request: operations.ChannelTargetsGetByIdRequest,
+    options?: RequestOptions,
+  ): Promise<components.ChannelTarget> {
+    return unwrapAsync(channelsTargetsGetById(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Edit Channel Target
+   *
+   * @remarks
+   * Update channel target by ID
+   */
+  async update(
+    request: operations.ChannelsTargetUpdateRequest,
+    options?: RequestOptions,
+  ): Promise<components.ChannelTarget> {
+    return unwrapAsync(channelsTargetsUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/test.ts

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { agentsTestSendTestMessage } from "../funcs/agentsTestSendTestMessage.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Test extends ClientSDK {
+  /**
+   * Send New Message
+   *
+   * @remarks
+   * Send a new message
+   */
+  async sendTestMessage(
+    request: components.TestMessage,
+    options?: RequestOptions,
+  ): Promise<components.TestMessageResponse> {
+    return unwrapAsync(agentsTestSendTestMessage(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/tools.ts

@@ -0,0 +1,46 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { toolsGetByName } from "../funcs/toolsGetByName.js";
+import { toolsList } from "../funcs/toolsList.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Tools extends ClientSDK {
+  /**
+   * Tool List
+   *
+   * @remarks
+   * List the existing agents
+   */
+  async list(
+    request: operations.ToolListRequest,
+    options?: RequestOptions,
+  ): Promise<components.ListResponseSchemasBubblegumV2ToolsTool> {
+    return unwrapAsync(toolsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Tool Info
+   *
+   * @remarks
+   * Get the details of a specific tool
+   */
+  async getByName(
+    request: operations.ToolGetByNameRequest,
+    options?: RequestOptions,
+  ): Promise<components.ToolDetailResponse> {
+    return unwrapAsync(toolsGetByName(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/types/blobs.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+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/constdatetime.ts

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+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 equivelant to ${val}`);
+}

package/src/types/enums.ts

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+declare const __brand: unique symbol;
+export type Unrecognized<T> = T & { [__brand]: "unrecognized" };
+
+export function catchUnrecognizedEnum<T>(value: T): Unrecognized<T> {
+  return value as Unrecognized<T>;
+}
+
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+export type ClosedEnum<T> = T[keyof T];
+export type OpenEnum<T> =
+  | Prettify<T[keyof T]>
+  | Unrecognized<T[keyof T] extends number ? number : string>;

package/src/types/fp.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/**
+ * A monad that captures the result of a function call or an error if it was not
+ * successful. Railway programming, enabled by this type, can be a nicer
+ * alternative to traditional exception throwing because it allows functions to
+ * declare all _known_ errors with static types and then check for them
+ * exhaustively in application code. Thrown exception have a type of `unknown`
+ * and break out of regular control flow of programs making them harder to
+ * inspect and more verbose work with due to try-catch blocks.
+ */
+export type Result<T, E = unknown> =
+  | { ok: true; value: T; error?: never }
+  | { ok: false; value?: never; error: E };
+
+export function OK<V>(value: V): Result<V, never> {
+  return { ok: true, value };
+}
+
+export function ERR<E>(error: E): Result<never, E> {
+  return { ok: false, error };
+}
+
+/**
+ * unwrap is a convenience function for extracting a value from a result or
+ * throwing if there was an error.
+ */
+export function unwrap<T>(r: Result<T, unknown>): T {
+  if (!r.ok) {
+    throw r.error;
+  }
+  return r.value;
+}
+
+/**
+ * unwrapAsync is a convenience function for resolving a value from a Promise
+ * of a result or rejecting if an error occurred.
+ */
+export async function unwrapAsync<T>(
+  pr: Promise<Result<T, unknown>>,
+): Promise<T> {
+  const r = await pr;
+  if (!r.ok) {
+    throw r.error;
+  }
+
+  return r.value;
+}

package/src/types/index.ts

@@ -0,0 +1,11 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export { blobLikeSchema, isBlobLike } from "./blobs.js";
+export { catchUnrecognizedEnum } from "./enums.js";
+export type { ClosedEnum, OpenEnum, Unrecognized } from "./enums.js";
+export type { Result } from "./fp.js";
+export type { PageIterator, Paginator } from "./operations.js";
+export { createPageIterator } from "./operations.js";
+export { RFCDate } from "./rfcdate.js";

package/src/types/operations.ts

@@ -0,0 +1,99 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { Result } from "./fp.js";
+
+export type Paginator<V> = () => Promise<V & { next: Paginator<V> }> | null;
+
+export type PageIterator<V> = V & {
+  next: Paginator<V>;
+  [Symbol.asyncIterator]: () => AsyncIterableIterator<V>;
+};
+
+export function createPageIterator<V>(
+  page: V & { next: Paginator<V> },
+  halt: (v: V) => boolean,
+): {
+  [Symbol.asyncIterator]: () => AsyncIterableIterator<V>;
+} {
+  return {
+    [Symbol.asyncIterator]: async function* paginator() {
+      yield page;
+      if (halt(page)) {
+        return;
+      }
+
+      let p: typeof page | null = page;
+      for (p = await p.next(); p != null; p = await p.next()) {
+        yield p;
+        if (halt(p)) {
+          return;
+        }
+      }
+    },
+  };
+}
+
+/**
+ * This utility create a special iterator that yields a single value and
+ * terminates. It is useful in paginated SDK functions that have early return
+ * paths when things go wrong.
+ */
+export function haltIterator<V extends object>(v: V): PageIterator<V> {
+  return {
+    ...v,
+    next: () => null,
+    [Symbol.asyncIterator]: async function* paginator() {
+      yield v;
+    },
+  };
+}
+
+/**
+ * Converts an async iterator of `Result<V, E>` into an async iterator of `V`.
+ * When error results occur, the underlying error value is thrown.
+ */
+export async function unwrapResultIterator<V>(
+  iteratorPromise: Promise<PageIterator<Result<V, unknown>>>,
+): Promise<PageIterator<V>> {
+  const resultIter = await iteratorPromise;
+
+  if (!resultIter.ok) {
+    throw resultIter.error;
+  }
+
+  return {
+    ...resultIter.value,
+    next: unwrapPaginator(resultIter.next),
+    [Symbol.asyncIterator]: async function* paginator() {
+      for await (const page of resultIter) {
+        if (!page.ok) {
+          throw page.error;
+        }
+        yield page.value;
+      }
+    },
+  };
+}
+
+function unwrapPaginator<V>(
+  paginator: Paginator<Result<V, unknown>>,
+): Paginator<V> {
+  return () => {
+    const nextResult = paginator();
+    if (nextResult == null) {
+      return null;
+    }
+    return nextResult.then((res) => {
+      if (!res.ok) {
+        throw res.error;
+      }
+      const out = {
+        ...res.value,
+        next: unwrapPaginator(res.next),
+      };
+      return out;
+    });
+  };
+}

package/src/types/rfcdate.ts

@@ -0,0 +1,54 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+const dateRE = /^\d{4}-\d{2}-\d{2}$/;
+
+export class RFCDate {
+  private serialized: string;
+
+  /**
+   * Creates a new RFCDate instance using today's date.
+   */
+  static today(): RFCDate {
+    return new RFCDate(new Date());
+  }
+
+  /**
+   * Creates a new RFCDate instance using the provided input.
+   * If a string is used then in must be in the format YYYY-MM-DD.
+   *
+   * @param date A Date object or a date string in YYYY-MM-DD format
+   * @example
+   * new RFCDate("2022-01-01")
+   * @example
+   * new RFCDate(new Date())
+   */
+  constructor(date: Date | string) {
+    if (typeof date === "string" && !dateRE.test(date)) {
+      throw new RangeError(
+        "RFCDate: date strings must be in the format YYYY-MM-DD: " + date,
+      );
+    }
+
+    const value = new Date(date);
+    if (isNaN(+value)) {
+      throw new RangeError("RFCDate: invalid date provided: " + date);
+    }
+
+    this.serialized = value.toISOString().slice(0, "YYYY-MM-DD".length);
+    if (!dateRE.test(this.serialized)) {
+      throw new TypeError(
+        `RFCDate: failed to build valid date with given value: ${date} serialized to ${this.serialized}`,
+      );
+    }
+  }
+
+  toJSON(): string {
+    return this.toString();
+  }
+
+  toString(): string {
+    return this.serialized;
+  }
+}

package/src/types/streams.ts

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export function isReadableStream<T = Uint8Array>(
+  val: unknown,
+): val is ReadableStream<T> {
+  if (typeof val !== "object" || val === null) {
+    return false;
+  }
+
+  // Check for the presence of methods specific to ReadableStream
+  const stream = val as ReadableStream<Uint8Array>;
+
+  // ReadableStream has methods like getReader, cancel, and tee
+  return (
+    typeof stream.getReader === "function" &&
+    typeof stream.cancel === "function" &&
+    typeof stream.tee === "function"
+  );
+}

package/types/blobs.d.ts

@@ -0,0 +1,4 @@
+import * as z from "zod";
+export declare const blobLikeSchema: z.ZodType<Blob, z.ZodTypeDef, Blob>;
+export declare function isBlobLike(val: unknown): val is Blob;
+//# sourceMappingURL=blobs.d.ts.map