mtmsdk 0.0.48 → 0.0.50

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

@@ -1,332 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-import { getAuthToken } from '../core/auth.gen';
-import type { QuerySerializerOptions } from '../core/bodySerializer.gen';
-import { jsonBodySerializer } from '../core/bodySerializer.gen';
-import {
-  serializeArrayParam,
-  serializeObjectParam,
-  serializePrimitiveParam,
-} from '../core/pathSerializer.gen';
-import { getUrl } from '../core/utils.gen';
-import type { Client, ClientOptions, Config, RequestOptions } from './types.gen';
-
-export const createQuerySerializer = <T = unknown>({
-  parameters = {},
-  ...args
-}: 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;
-        }
-
-        const options = parameters[name] || args;
-
-        if (Array.isArray(value)) {
-          const serializedArray = serializeArrayParam({
-            allowReserved: options.allowReserved,
-            explode: true,
-            name,
-            style: 'form',
-            value,
-            ...options.array,
-          });
-          if (serializedArray) search.push(serializedArray);
-        } else if (typeof value === 'object') {
-          const serializedObject = serializeObjectParam({
-            allowReserved: options.allowReserved,
-            explode: true,
-            name,
-            style: 'deepObject',
-            value: value as Record<string, unknown>,
-            ...options.object,
-          });
-          if (serializedObject) search.push(serializedObject);
-        } else {
-          const serializedPrimitive = serializePrimitiveParam({
-            allowReserved: options.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;
-};
-
-const headersEntries = (headers: Headers): Array<[string, string]> => {
-  const entries: Array<[string, string]> = [];
-  headers.forEach((value, key) => {
-    entries.push([key, value]);
-  });
-  return entries;
-};
-
-export const mergeHeaders = (
-  ...headers: Array<Required<Config>['headers'] | undefined>
-): Headers => {
-  const mergedHeaders = new Headers();
-  for (const header of headers) {
-    if (!header) {
-      continue;
-    }
-
-    const iterator =
-      header instanceof Headers
-        ? headersEntries(header)
-        : 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: Array<Interceptor | null> = [];
-
-  clear(): void {
-    this.fns = [];
-  }
-
-  eject(id: number | Interceptor): void {
-    const index = this.getInterceptorIndex(id);
-    if (this.fns[index]) {
-      this.fns[index] = null;
-    }
-  }
-
-  exists(id: number | Interceptor): boolean {
-    const index = this.getInterceptorIndex(id);
-    return Boolean(this.fns[index]);
-  }
-
-  getInterceptorIndex(id: number | Interceptor): number {
-    if (typeof id === 'number') {
-      return this.fns[id] ? id : -1;
-    }
-    return this.fns.indexOf(id);
-  }
-
-  update(
-    id: number | Interceptor,
-    fn: Interceptor,
-  ): number | Interceptor | false {
-    const index = this.getInterceptorIndex(id);
-    if (this.fns[index]) {
-      this.fns[index] = fn;
-      return id;
-    }
-    return false;
-  }
-
-  use(fn: Interceptor): number {
-    this.fns.push(fn);
-    return this.fns.length - 1;
-  }
-}
-
-export interface Middleware<Req, Res, Err, Options> {
-  error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
-  request: Interceptors<ReqInterceptor<Req, Options>>;
-  response: Interceptors<ResInterceptor<Res, Req, Options>>;
-}
-
-export const createInterceptors = <Req, Res, Err, Options>(): Middleware<
-  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/api_hatchet/client.gen.ts

@@ -1,16 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-import { type ClientOptions, type Config, createClient, createConfig } from './client';
-import type { ClientOptions as ClientOptions2 } from './types.gen';
-
-/**
- * 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 = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
-
-export const client = createClient(createConfig<ClientOptions2>());

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

@@ -1,42 +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/api_hatchet/core/bodySerializer.gen.ts

@@ -1,100 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-import type {
-  ArrayStyle,
-  ObjectStyle,
-  SerializerOptions,
-} from './pathSerializer.gen';
-
-export type QuerySerializer = (query: Record<string, unknown>) => string;
-
-export type BodySerializer = (body: any) => any;
-
-type QuerySerializerOptionsObject = {
-  allowReserved?: boolean;
-  array?: Partial<SerializerOptions<ArrayStyle>>;
-  object?: Partial<SerializerOptions<ObjectStyle>>;
-};
-
-export type QuerySerializerOptions = QuerySerializerOptionsObject & {
-  /**
-   * Per-parameter serialization overrides. When provided, these settings
-   * override the global array/object settings for specific parameter names.
-   */
-  parameters?: Record<string, QuerySerializerOptionsObject>;
-};
-
-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();
-  },
-};

package/src/api_hatchet/core/params.gen.ts

@@ -1,176 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-type Slot = 'body' | 'headers' | 'path' | 'query';
-
-export type Field =
-  | {
-      in: Exclude<Slot, 'body'>;
-      /**
-       * Field name. This is the name we want the user to see and use.
-       */
-      key: string;
-      /**
-       * Field mapped name. This is the name we want to use in the request.
-       * If omitted, we use the same value as `key`.
-       */
-      map?: string;
-    }
-  | {
-      in: Extract<Slot, 'body'>;
-      /**
-       * Key isn't required for bodies.
-       */
-      key?: string;
-      map?: string;
-    }
-  | {
-      /**
-       * Field name. This is the name we want the user to see and use.
-       */
-      key: string;
-      /**
-       * Field mapped name. This is the name we want to use in the request.
-       * If `in` is omitted, `map` aliases `key` to the transport layer.
-       */
-      map: Slot;
-    };
-
-export interface Fields {
-  allowExtra?: Partial<Record<Slot, boolean>>;
-  args?: ReadonlyArray<Field>;
-}
-
-export type FieldsConfig = ReadonlyArray<Field | Fields>;
-
-const extraPrefixesMap: Record<string, Slot> = {
-  $body_: 'body',
-  $headers_: 'headers',
-  $path_: 'path',
-  $query_: 'query',
-};
-const extraPrefixes = Object.entries(extraPrefixesMap);
-
-type KeyMap = Map<
-  string,
-  | {
-      in: Slot;
-      map?: string;
-    }
-  | {
-      in?: never;
-      map: Slot;
-    }
->;
-
-const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
-  if (!map) {
-    map = new Map();
-  }
-
-  for (const config of fields) {
-    if ('in' in config) {
-      if (config.key) {
-        map.set(config.key, {
-          in: config.in,
-          map: config.map,
-        });
-      }
-    } else if ('key' in config) {
-      map.set(config.key, {
-        map: config.map,
-      });
-    } else if (config.args) {
-      buildKeyMap(config.args, map);
-    }
-  }
-
-  return map;
-};
-
-interface Params {
-  body: unknown;
-  headers: Record<string, unknown>;
-  path: Record<string, unknown>;
-  query: Record<string, unknown>;
-}
-
-const stripEmptySlots = (params: Params) => {
-  for (const [slot, value] of Object.entries(params)) {
-    if (value && typeof value === 'object' && !Object.keys(value).length) {
-      delete params[slot as Slot];
-    }
-  }
-};
-
-export const buildClientParams = (
-  args: ReadonlyArray<unknown>,
-  fields: FieldsConfig,
-) => {
-  const params: Params = {
-    body: {},
-    headers: {},
-    path: {},
-    query: {},
-  };
-
-  const map = buildKeyMap(fields);
-
-  let config: FieldsConfig[number] | undefined;
-
-  for (const [index, arg] of args.entries()) {
-    if (fields[index]) {
-      config = fields[index];
-    }
-
-    if (!config) {
-      continue;
-    }
-
-    if ('in' in config) {
-      if (config.key) {
-        const field = map.get(config.key)!;
-        const name = field.map || config.key;
-        if (field.in) {
-          (params[field.in] as Record<string, unknown>)[name] = arg;
-        }
-      } else {
-        params.body = arg;
-      }
-    } else {
-      for (const [key, value] of Object.entries(arg ?? {})) {
-        const field = map.get(key);
-
-        if (field) {
-          if (field.in) {
-            const name = field.map || key;
-            (params[field.in] as Record<string, unknown>)[name] = value;
-          } else {
-            params[field.map] = value;
-          }
-        } else {
-          const extra = extraPrefixes.find(([prefix]) =>
-            key.startsWith(prefix),
-          );
-
-          if (extra) {
-            const [prefix, slot] = extra;
-            (params[slot] as Record<string, unknown>)[
-              key.slice(prefix.length)
-            ] = value;
-          } else if ('allowExtra' in config && config.allowExtra) {
-            for (const [slot, allowed] of Object.entries(config.allowExtra)) {
-              if (allowed) {
-                (params[slot as Slot] as Record<string, unknown>)[key] = value;
-                break;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  stripEmptySlots(params);
-
-  return params;
-};