@compose-market/sdk 0.4.3 → 0.5.0

package/generated/inference/src/sdk/inference.ts

@@ -0,0 +1,209 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { inferenceInferenceAudioSpeechCreate } from "../funcs/inference-inference-audio-speech-create.js";
+import { inferenceInferenceAudioTranscriptionsCreateMultipart } from "../funcs/inference-inference-audio-transcriptions-create-multipart.js";
+import { inferenceInferenceAudioTranscriptionsCreate } from "../funcs/inference-inference-audio-transcriptions-create.js";
+import { inferenceInferenceChatCompletionsCreate } from "../funcs/inference-inference-chat-completions-create.js";
+import { inferenceInferenceEmbeddingsCreate } from "../funcs/inference-inference-embeddings-create.js";
+import { inferenceInferenceImagesEdit } from "../funcs/inference-inference-images-edit.js";
+import { inferenceInferenceImagesGenerate } from "../funcs/inference-inference-images-generate.js";
+import { inferenceInferenceLegacyCreate } from "../funcs/inference-inference-legacy-create.js";
+import { inferenceInferenceResponsesCancel } from "../funcs/inference-inference-responses-cancel.js";
+import { inferenceInferenceResponsesCreate } from "../funcs/inference-inference-responses-create.js";
+import { inferenceInferenceResponsesGet } from "../funcs/inference-inference-responses-get.js";
+import { inferenceInferenceResponsesInputItemsList } from "../funcs/inference-inference-responses-input-items-list.js";
+import { inferenceInferenceVideosGenerate } from "../funcs/inference-inference-videos-generate.js";
+import { inferenceInferenceVideosGet } from "../funcs/inference-inference-videos-get.js";
+import { inferenceInferenceVideosStream } from "../funcs/inference-inference-videos-stream.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Inference extends ClientSDK {
+  async inferenceChatCompletionsCreate(
+    security: operations.InferenceChatCompletionsCreateSecurity,
+    request: operations.InferenceChatCompletionsCreateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceChatCompletionsCreateResponse> {
+    return unwrapAsync(inferenceInferenceChatCompletionsCreate(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceResponsesCreate(
+    security: operations.InferenceResponsesCreateSecurity,
+    request: operations.InferenceResponsesCreateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceResponsesCreateResponse> {
+    return unwrapAsync(inferenceInferenceResponsesCreate(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceResponsesGet(
+    request: operations.InferenceResponsesGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceResponsesGetResponse> {
+    return unwrapAsync(inferenceInferenceResponsesGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceResponsesInputItemsList(
+    request: operations.InferenceResponsesInputItemsListRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceResponsesInputItemsListResponse> {
+    return unwrapAsync(inferenceInferenceResponsesInputItemsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceResponsesCancel(
+    request: operations.InferenceResponsesCancelRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceResponsesCancelResponse> {
+    return unwrapAsync(inferenceInferenceResponsesCancel(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceEmbeddingsCreate(
+    security: operations.InferenceEmbeddingsCreateSecurity,
+    request: operations.InferenceEmbeddingsCreateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceEmbeddingsCreateResponse> {
+    return unwrapAsync(inferenceInferenceEmbeddingsCreate(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceImagesGenerate(
+    security: operations.InferenceImagesGenerateSecurity,
+    request: operations.InferenceImagesGenerateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceImagesGenerateResponse> {
+    return unwrapAsync(inferenceInferenceImagesGenerate(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceImagesEdit(
+    security: operations.InferenceImagesEditSecurity,
+    request: operations.InferenceImagesEditRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceImagesEditResponse> {
+    return unwrapAsync(inferenceInferenceImagesEdit(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceAudioSpeechCreate(
+    security: operations.InferenceAudioSpeechCreateSecurity,
+    request: operations.InferenceAudioSpeechCreateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceAudioSpeechCreateResponse> {
+    return unwrapAsync(inferenceInferenceAudioSpeechCreate(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceAudioTranscriptionsCreate(
+    security: operations.InferenceAudioTranscriptionsCreateSecurity,
+    request: operations.InferenceAudioTranscriptionsCreateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceAudioTranscriptionsCreateResponse> {
+    return unwrapAsync(inferenceInferenceAudioTranscriptionsCreate(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceAudioTranscriptionsCreateMultipart(
+    security: operations.InferenceAudioTranscriptionsCreateMultipartSecurity,
+    request: operations.InferenceAudioTranscriptionsCreateMultipartRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceAudioTranscriptionsCreateMultipartResponse> {
+    return unwrapAsync(inferenceInferenceAudioTranscriptionsCreateMultipart(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceVideosGenerate(
+    security: operations.InferenceVideosGenerateSecurity,
+    request: operations.InferenceVideosGenerateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceVideosGenerateResponse> {
+    return unwrapAsync(inferenceInferenceVideosGenerate(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceVideosGet(
+    request: operations.InferenceVideosGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceVideosGetResponse> {
+    return unwrapAsync(inferenceInferenceVideosGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceVideosStream(
+    request: operations.InferenceVideosStreamRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InferenceVideosStreamResponse> {
+    return unwrapAsync(inferenceInferenceVideosStream(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async inferenceLegacyCreate(
+    security: operations.InferenceLegacyCreateSecurity,
+    request: { [k: string]: any },
+    options?: RequestOptions,
+  ): Promise<operations.InferenceLegacyCreateResponse> {
+    return unwrapAsync(inferenceInferenceLegacyCreate(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+}

package/generated/inference/src/sdk/modality.ts

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { modalityModalityGet } from "../funcs/modality-modality-get.js";
+import { modalityModalityList } from "../funcs/modality-modality-list.js";
+import { modalityModalityOperationModelsList } from "../funcs/modality-modality-operation-models-list.js";
+import { modalityModalityOperationsList } from "../funcs/modality-modality-operations-list.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Modality extends ClientSDK {
+  async modalityList(
+    options?: RequestOptions,
+  ): Promise<operations.ModalityListResponse> {
+    return unwrapAsync(modalityModalityList(
+      this,
+      options,
+    ));
+  }
+
+  async modalityGet(
+    request: operations.ModalityGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ModalityGetResponse> {
+    return unwrapAsync(modalityModalityGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async modalityOperationsList(
+    request: operations.ModalityOperationsListRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ModalityOperationsListResponse> {
+    return unwrapAsync(modalityModalityOperationsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async modalityOperationModelsList(
+    request: operations.ModalityOperationModelsListRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ModalityOperationModelsListResponse> {
+    return unwrapAsync(modalityModalityOperationModelsList(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/generated/inference/src/sdk/models.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { modelsModelsGet } from "../funcs/models-models-get.js";
+import { modelsModelsListAll } from "../funcs/models-models-list-all.js";
+import { modelsModelsList } from "../funcs/models-models-list.js";
+import { modelsModelsParamsGet } from "../funcs/models-models-params-get.js";
+import { modelsModelsSearch } from "../funcs/models-models-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 Models extends ClientSDK {
+  async modelsList(
+    request?: operations.ModelsListRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ModelsListResponse> {
+    return unwrapAsync(modelsModelsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async modelsListAll(
+    options?: RequestOptions,
+  ): Promise<operations.ModelsListAllResponse> {
+    return unwrapAsync(modelsModelsListAll(
+      this,
+      options,
+    ));
+  }
+
+  async modelsSearch(
+    request: models.ModelSearchRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ModelsSearchResponse> {
+    return unwrapAsync(modelsModelsSearch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async modelsGet(
+    request: operations.ModelsGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ModelsGetResponse> {
+    return unwrapAsync(modelsModelsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async modelsParamsGet(
+    request: operations.ModelsParamsGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ModelsParamsGetResponse> {
+    return unwrapAsync(modelsModelsParamsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/generated/inference/src/sdk/sdk.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ClientSDK } from "../lib/sdks.js";
+import { Health } from "./health.js";
+import { Inference } from "./inference.js";
+import { Modality } from "./modality.js";
+import { Models } from "./models.js";
+
+export class ComposeMarket extends ClientSDK {
+  private _health?: Health;
+  get health(): Health {
+    return (this._health ??= new Health(this._options));
+  }
+
+  private _models?: Models;
+  get models(): Models {
+    return (this._models ??= new Models(this._options));
+  }
+
+  private _modality?: Modality;
+  get modality(): Modality {
+    return (this._modality ??= new Modality(this._options));
+  }
+
+  private _inference?: Inference;
+  get inference(): Inference {
+    return (this._inference ??= new Inference(this._options));
+  }
+}

package/generated/inference/src/types/async.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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]>;
+  readonly #unwrapped: Promise<T>;
+
+  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
+        ? this.#promise.then(([value]) => value)
+        : Promise.resolve(p[0]);
+  }
+
+  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.#unwrapped.catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.#unwrapped.finally(onfinally);
+  }
+
+  $inspect(): Promise<[T, APICall]> {
+    return this.#promise;
+  }
+}

package/generated/inference/src/types/blobs.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export const blobLikeSchema: z.ZodMiniType<Blob, Blob> = z.custom<Blob>(
+  isBlobLike,
+  {
+    message: "expected a Blob, File or Blob-like object",
+    abort: 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/generated/inference/src/types/const-date-time.ts

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

package/generated/inference/src/types/default-to-zero-value.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { type Unrecognized, unrecognized } from "./unrecognized.js";
+
+let globalCount = 0;
+let refCount = 0;
+
+export function defaultToZeroValue<T>(value: T): Unrecognized<T> {
+  globalCount++;
+  return unrecognized(value);
+}
+
+export function startCountingDefaultToZeroValue() {
+  refCount++;
+  const start = globalCount;
+  return {
+    /**
+     * Ends counting and returns the delta.
+     * @param delta - If provided, only this amount is added to the parent counter
+     *   (used for nested unions where we only want to record the winning option's count).
+     *   If not provided, records all counts since start().
+     */
+    end: (delta?: number) => {
+      const count = globalCount - start;
+      // Reset globalCount back to start, then add only the specified delta
+      globalCount = start + (delta ?? count);
+      if (--refCount === 0) globalCount = 0;
+      return count;
+    },
+  };
+}

package/generated/inference/src/types/enums.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { Unrecognized, unrecognized } from "./unrecognized.js";
+
+export type ClosedEnum<T extends Readonly<Record<string, string | number>>> =
+  T[keyof T];
+export type OpenEnum<T extends Readonly<Record<string, string | number>>> =
+  | T[keyof T]
+  | Unrecognized<T[keyof T] extends number ? number : string>;
+
+export function inboundSchema<T extends Record<string, string>>(
+  enumObj: T,
+): z.ZodMiniType<OpenEnum<T>, unknown> {
+  const options = Object.values(enumObj);
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.pipe(z.string(), z.transform(x => unrecognized(x))),
+  ] as any);
+}
+
+export function inboundSchemaInt<T extends Record<string, number | string>>(
+  enumObj: T,
+): z.ZodMiniType<OpenEnum<T>, unknown> {
+  // For numeric enums, Object.values returns both numbers and string keys
+  const options = Object.values(enumObj).filter(v => typeof v === "number");
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.pipe(z.int(), z.transform(x => unrecognized(x))),
+  ] as any);
+}
+
+export function outboundSchema<T extends Record<string, string>>(
+  _: T,
+): z.ZodMiniType<string, OpenEnum<T>> {
+  return z.string() as any;
+}
+
+export function outboundSchemaInt<T extends Record<string, number | string>>(
+  _: T,
+): z.ZodMiniType<number, OpenEnum<T>> {
+  return z.int() as any;
+}

package/generated/inference/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/generated/inference/src/types/index.ts

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