@zyraxon-ai/sdk 19.0.2 → 19.0.4

package/src/gen/client/types.gen.ts

@@ -1,222 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-import type { Auth } from "../core/auth.gen.js"
-import type { ServerSentEventsOptions, ServerSentEventsResult } from "../core/serverSentEvents.gen.js"
-import type { Client as CoreClient, Config as CoreConfig } from "../core/types.gen.js"
-import type { Middleware } from "./utils.gen.js"
-
-export type ResponseStyle = "data" | "fields"
-
-export interface Config<T extends ClientOptions = ClientOptions>
-  extends Omit<RequestInit, "body" | "headers" | "method">,
-    CoreConfig {
-  /**
-   * Base URL for all requests made by this client.
-   */
-  baseUrl?: T["baseUrl"]
-  /**
-   * Fetch API implementation. You can use this option to provide a custom
-   * fetch instance.
-   *
-   * @default globalThis.fetch
-   */
-  fetch?: (request: Request) => ReturnType<typeof fetch>
-  /**
-   * Please don't use the Fetch client for Next.js applications. The `next`
-   * options won't have any effect.
-   *
-   * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
-   */
-  next?: never
-  /**
-   * Return the response data parsed in a specified format. By default, `auto`
-   * will infer the appropriate method from the `Content-Type` response header.
-   * You can override this behavior with any of the {@link Body} methods.
-   * Select `stream` if you don't want to parse response data at all.
-   *
-   * @default 'auto'
-   */
-  parseAs?: "arrayBuffer" | "auto" | "blob" | "formData" | "json" | "stream" | "text"
-  /**
-   * Should we return only data or multiple fields (data, error, response, etc.)?
-   *
-   * @default 'fields'
-   */
-  responseStyle?: ResponseStyle
-  /**
-   * Throw an error instead of returning it in the response?
-   *
-   * @default false
-   */
-  throwOnError?: T["throwOnError"]
-}
-
-export interface RequestOptions<
-  TData = unknown,
-  TResponseStyle extends ResponseStyle = "fields",
-  ThrowOnError extends boolean = boolean,
-  Url extends string = string,
-> extends Config<{
-      responseStyle: TResponseStyle
-      throwOnError: ThrowOnError
-    }>,
-    Pick<
-      ServerSentEventsOptions<TData>,
-      "onSseError" | "onSseEvent" | "sseDefaultRetryDelay" | "sseMaxRetryAttempts" | "sseMaxRetryDelay"
-    > {
-  /**
-   * Any body that you want to add to your request.
-   *
-   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
-   */
-  body?: unknown
-  path?: Record<string, unknown>
-  query?: Record<string, unknown>
-  /**
-   * Security mechanism(s) to use for the request.
-   */
-  security?: ReadonlyArray<Auth>
-  url: Url
-}
-
-export interface ResolvedRequestOptions<
-  TResponseStyle extends ResponseStyle = "fields",
-  ThrowOnError extends boolean = boolean,
-  Url extends string = string,
-> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
-  serializedBody?: string
-}
-
-export type RequestResult<
-  TData = unknown,
-  TError = unknown,
-  ThrowOnError extends boolean = boolean,
-  TResponseStyle extends ResponseStyle = "fields",
-> = ThrowOnError extends true
-  ? Promise<
-      TResponseStyle extends "data"
-        ? TData extends Record<string, unknown>
-          ? TData[keyof TData]
-          : TData
-        : {
-            data: TData extends Record<string, unknown> ? TData[keyof TData] : TData
-            request: Request
-            response: Response
-          }
-    >
-  : Promise<
-      TResponseStyle extends "data"
-        ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined
-        : (
-            | {
-                data: TData extends Record<string, unknown> ? TData[keyof TData] : TData
-                error: undefined
-              }
-            | {
-                data: undefined
-                error: TError extends Record<string, unknown> ? TError[keyof TError] : TError
-              }
-          ) & {
-            request: Request
-            response: Response
-          }
-    >
-
-export interface ClientOptions {
-  baseUrl?: string
-  responseStyle?: ResponseStyle
-  throwOnError?: boolean
-}
-
-type MethodFnBase = <
-  TData = unknown,
-  TError = unknown,
-  ThrowOnError extends boolean = false,
-  TResponseStyle extends ResponseStyle = "fields",
->(
-  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">,
-) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>
-
-type MethodFnServerSentEvents = <
-  TData = unknown,
-  TError = unknown,
-  ThrowOnError extends boolean = false,
-  TResponseStyle extends ResponseStyle = "fields",
->(
-  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">,
-) => Promise<ServerSentEventsResult<TData, TError>>
-
-type MethodFn = MethodFnBase & {
-  sse: MethodFnServerSentEvents
-}
-
-type RequestFn = <
-  TData = unknown,
-  TError = unknown,
-  ThrowOnError extends boolean = false,
-  TResponseStyle extends ResponseStyle = "fields",
->(
-  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> &
-    Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">,
-) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>
-
-type BuildUrlFn = <
-  TData extends {
-    body?: unknown
-    path?: Record<string, unknown>
-    query?: Record<string, unknown>
-    url: string
-  },
->(
-  options: Pick<TData, "url"> & Options<TData>,
-) => string
-
-export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
-  interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>
-}
-
-/**
- * The `createClientConfig()` function will be called on client initialization
- * and the returned object will become the client's initial configuration.
- *
- * You may want to initialize your client this way instead of calling
- * `setConfig()`. This is useful for example if you're using Next.js
- * to ensure your client always has the correct values.
- */
-export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
-  override?: Config<ClientOptions & T>,
-) => Config<Required<ClientOptions> & T>
-
-export interface TDataShape {
-  body?: unknown
-  headers?: unknown
-  path?: unknown
-  query?: unknown
-  url: string
-}
-
-type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>
-
-export type Options<
-  TData extends TDataShape = TDataShape,
-  ThrowOnError extends boolean = boolean,
-  TResponse = unknown,
-  TResponseStyle extends ResponseStyle = "fields",
-> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, "body" | "path" | "query" | "url"> &
-  Omit<TData, "url">
-
-export type OptionsLegacyParser<
-  TData = unknown,
-  ThrowOnError extends boolean = boolean,
-  TResponseStyle extends ResponseStyle = "fields",
-> = TData extends { body?: any }
-  ? TData extends { headers?: any }
-    ? OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "body" | "headers" | "url"> & TData
-    : OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "body" | "url"> &
-        TData &
-        Pick<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "headers">
-  : TData extends { headers?: any }
-    ? OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "headers" | "url"> &
-        TData &
-        Pick<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "body">
-    : OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "url"> & TData

package/src/gen/client/utils.gen.ts

@@ -1,287 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-import { getAuthToken } from "../core/auth.gen.js"
-import type { QuerySerializerOptions } from "../core/bodySerializer.gen.js"
-import { jsonBodySerializer } from "../core/bodySerializer.gen.js"
-import { serializeArrayParam, serializeObjectParam, serializePrimitiveParam } from "../core/pathSerializer.gen.js"
-import { getUrl } from "../core/utils.gen.js"
-import type { Client, ClientOptions, Config, RequestOptions } from "./types.gen.js"
-
-export const createQuerySerializer = <T = unknown>({ allowReserved, array, object }: QuerySerializerOptions = {}) => {
-  const querySerializer = (queryParams: T) => {
-    const search: string[] = []
-    if (queryParams && typeof queryParams === "object") {
-      for (const name in queryParams) {
-        const value = queryParams[name]
-
-        if (value === undefined || value === null) {
-          continue
-        }
-
-        if (Array.isArray(value)) {
-          const serializedArray = serializeArrayParam({
-            allowReserved,
-            explode: true,
-            name,
-            style: "form",
-            value,
-            ...array,
-          })
-          if (serializedArray) search.push(serializedArray)
-        } else if (typeof value === "object") {
-          const serializedObject = serializeObjectParam({
-            allowReserved,
-            explode: true,
-            name,
-            style: "deepObject",
-            value: value as Record<string, unknown>,
-            ...object,
-          })
-          if (serializedObject) search.push(serializedObject)
-        } else {
-          const serializedPrimitive = serializePrimitiveParam({
-            allowReserved,
-            name,
-            value: value as string,
-          })
-          if (serializedPrimitive) search.push(serializedPrimitive)
-        }
-      }
-    }
-    return search.join("&")
-  }
-  return querySerializer
-}
-
-/**
- * Infers parseAs value from provided Content-Type header.
- */
-export const getParseAs = (contentType: string | null): Exclude<Config["parseAs"], "auto"> => {
-  if (!contentType) {
-    // If no Content-Type header is provided, the best we can do is return the raw response body,
-    // which is effectively the same as the 'stream' option.
-    return "stream"
-  }
-
-  const cleanContent = contentType.split(";")[0]?.trim()
-
-  if (!cleanContent) {
-    return
-  }
-
-  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
-    return "json"
-  }
-
-  if (cleanContent === "multipart/form-data") {
-    return "formData"
-  }
-
-  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
-    return "blob"
-  }
-
-  if (cleanContent.startsWith("text/")) {
-    return "text"
-  }
-
-  return
-}
-
-const checkForExistence = (
-  options: Pick<RequestOptions, "auth" | "query"> & {
-    headers: Headers
-  },
-  name?: string,
-): boolean => {
-  if (!name) {
-    return false
-  }
-  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
-    return true
-  }
-  return false
-}
-
-export const setAuthParams = async ({
-  security,
-  ...options
-}: Pick<Required<RequestOptions>, "security"> &
-  Pick<RequestOptions, "auth" | "query"> & {
-    headers: Headers
-  }) => {
-  for (const auth of security) {
-    if (checkForExistence(options, auth.name)) {
-      continue
-    }
-
-    const token = await getAuthToken(auth, options.auth)
-
-    if (!token) {
-      continue
-    }
-
-    const name = auth.name ?? "Authorization"
-
-    switch (auth.in) {
-      case "query":
-        if (!options.query) {
-          options.query = {}
-        }
-        options.query[name] = token
-        break
-      case "cookie":
-        options.headers.append("Cookie", `${name}=${token}`)
-        break
-      case "header":
-      default:
-        options.headers.set(name, token)
-        break
-    }
-  }
-}
-
-export const buildUrl: Client["buildUrl"] = (options) =>
-  getUrl({
-    baseUrl: options.baseUrl as string,
-    path: options.path,
-    query: options.query,
-    querySerializer:
-      typeof options.querySerializer === "function"
-        ? options.querySerializer
-        : createQuerySerializer(options.querySerializer),
-    url: options.url,
-  })
-
-export const mergeConfigs = (a: Config, b: Config): Config => {
-  const config = { ...a, ...b }
-  if (config.baseUrl?.endsWith("/")) {
-    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1)
-  }
-  config.headers = mergeHeaders(a.headers, b.headers)
-  return config
-}
-
-export const mergeHeaders = (...headers: Array<Required<Config>["headers"] | undefined>): Headers => {
-  const mergedHeaders = new Headers()
-  for (const header of headers) {
-    if (!header || typeof header !== "object") {
-      continue
-    }
-
-    const iterator = header instanceof Headers ? header.entries() : Object.entries(header)
-
-    for (const [key, value] of iterator) {
-      if (value === null) {
-        mergedHeaders.delete(key)
-      } else if (Array.isArray(value)) {
-        for (const v of value) {
-          mergedHeaders.append(key, v as string)
-        }
-      } else if (value !== undefined) {
-        // assume object headers are meant to be JSON stringified, i.e. their
-        // content value in OpenAPI specification is 'application/json'
-        mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : (value as string))
-      }
-    }
-  }
-  return mergedHeaders
-}
-
-type ErrInterceptor<Err, Res, Req, Options> = (
-  error: Err,
-  response: Res,
-  request: Req,
-  options: Options,
-) => Err | Promise<Err>
-
-type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>
-
-type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>
-
-class Interceptors<Interceptor> {
-  _fns: (Interceptor | null)[]
-
-  constructor() {
-    this._fns = []
-  }
-
-  clear() {
-    this._fns = []
-  }
-
-  getInterceptorIndex(id: number | Interceptor): number {
-    if (typeof id === "number") {
-      return this._fns[id] ? id : -1
-    } else {
-      return this._fns.indexOf(id)
-    }
-  }
-  exists(id: number | Interceptor) {
-    const index = this.getInterceptorIndex(id)
-    return !!this._fns[index]
-  }
-
-  eject(id: number | Interceptor) {
-    const index = this.getInterceptorIndex(id)
-    if (this._fns[index]) {
-      this._fns[index] = null
-    }
-  }
-
-  update(id: number | Interceptor, fn: Interceptor) {
-    const index = this.getInterceptorIndex(id)
-    if (this._fns[index]) {
-      this._fns[index] = fn
-      return id
-    } else {
-      return false
-    }
-  }
-
-  use(fn: Interceptor) {
-    this._fns = [...this._fns, fn]
-    return this._fns.length - 1
-  }
-}
-
-// `createInterceptors()` response, meant for external use as it does not
-// expose internals
-export interface Middleware<Req, Res, Err, Options> {
-  error: Pick<Interceptors<ErrInterceptor<Err, Res, Req, Options>>, "eject" | "use">
-  request: Pick<Interceptors<ReqInterceptor<Req, Options>>, "eject" | "use">
-  response: Pick<Interceptors<ResInterceptor<Res, Req, Options>>, "eject" | "use">
-}
-
-// do not add `Middleware` as return type so we can use _fns internally
-export const createInterceptors = <Req, Res, Err, Options>() => ({
-  error: new Interceptors<ErrInterceptor<Err, Res, Req, Options>>(),
-  request: new Interceptors<ReqInterceptor<Req, Options>>(),
-  response: new Interceptors<ResInterceptor<Res, Req, Options>>(),
-})
-
-const defaultQuerySerializer = createQuerySerializer({
-  allowReserved: false,
-  array: {
-    explode: true,
-    style: "form",
-  },
-  object: {
-    explode: true,
-    style: "deepObject",
-  },
-})
-
-const defaultHeaders = {
-  "Content-Type": "application/json",
-}
-
-export const createConfig = <T extends ClientOptions = ClientOptions>(
-  override: Config<Omit<ClientOptions, keyof T> & T> = {},
-): Config<Omit<ClientOptions, keyof T> & T> => ({
-  ...jsonBodySerializer,
-  headers: defaultHeaders,
-  parseAs: "auto",
-  querySerializer: defaultQuerySerializer,
-  ...override,
-})

package/src/gen/core/auth.gen.ts

@@ -1,41 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-export type AuthToken = string | undefined
-
-export interface Auth {
-  /**
-   * Which part of the request do we use to send the auth?
-   *
-   * @default 'header'
-   */
-  in?: "header" | "query" | "cookie"
-  /**
-   * Header or query parameter name.
-   *
-   * @default 'Authorization'
-   */
-  name?: string
-  scheme?: "basic" | "bearer"
-  type: "apiKey" | "http"
-}
-
-export const getAuthToken = async (
-  auth: Auth,
-  callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken,
-): Promise<string | undefined> => {
-  const token = typeof callback === "function" ? await callback(auth) : callback
-
-  if (!token) {
-    return
-  }
-
-  if (auth.scheme === "bearer") {
-    return `Bearer ${token}`
-  }
-
-  if (auth.scheme === "basic") {
-    return `Basic ${btoa(token)}`
-  }
-
-  return token
-}

package/src/gen/core/bodySerializer.gen.ts

@@ -1,74 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-import type { ArrayStyle, ObjectStyle, SerializerOptions } from "./pathSerializer.gen.js"
-
-export type QuerySerializer = (query: Record<string, unknown>) => string
-
-export type BodySerializer = (body: any) => any
-
-export interface QuerySerializerOptions {
-  allowReserved?: boolean
-  array?: SerializerOptions<ArrayStyle>
-  object?: SerializerOptions<ObjectStyle>
-}
-
-const serializeFormDataPair = (data: FormData, key: string, value: unknown): void => {
-  if (typeof value === "string" || value instanceof Blob) {
-    data.append(key, value)
-  } else if (value instanceof Date) {
-    data.append(key, value.toISOString())
-  } else {
-    data.append(key, JSON.stringify(value))
-  }
-}
-
-const serializeUrlSearchParamsPair = (data: URLSearchParams, key: string, value: unknown): void => {
-  if (typeof value === "string") {
-    data.append(key, value)
-  } else {
-    data.append(key, JSON.stringify(value))
-  }
-}
-
-export const formDataBodySerializer = {
-  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T): FormData => {
-    const data = new FormData()
-
-    Object.entries(body).forEach(([key, value]) => {
-      if (value === undefined || value === null) {
-        return
-      }
-      if (Array.isArray(value)) {
-        value.forEach((v) => serializeFormDataPair(data, key, v))
-      } else {
-        serializeFormDataPair(data, key, value)
-      }
-    })
-
-    return data
-  },
-}
-
-export const jsonBodySerializer = {
-  bodySerializer: <T>(body: T): string =>
-    JSON.stringify(body, (_key, value) => (typeof value === "bigint" ? value.toString() : value)),
-}
-
-export const urlSearchParamsBodySerializer = {
-  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T): string => {
-    const data = new URLSearchParams()
-
-    Object.entries(body).forEach(([key, value]) => {
-      if (value === undefined || value === null) {
-        return
-      }
-      if (Array.isArray(value)) {
-        value.forEach((v) => serializeUrlSearchParamsPair(data, key, v))
-      } else {
-        serializeUrlSearchParamsPair(data, key, value)
-      }
-    })
-
-    return data.toString()
-  },
-}