@studyfetch/sdk 1.1.1 → 1.3.0

package/src/internal/qs/utils.ts

@@ -0,0 +1,265 @@
+import { RFC1738 } from './formats';
+import type { DefaultEncoder, Format } from './types';
+import { isArray } from '../utils/values';
+
+export let has = (obj: object, key: PropertyKey): boolean => (
+  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
+  has(obj, key)
+);
+
+const hex_table = /* @__PURE__ */ (() => {
+  const array = [];
+  for (let i = 0; i < 256; ++i) {
+    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+  }
+
+  return array;
+})();
+
+function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
+  while (queue.length > 1) {
+    const item = queue.pop();
+    if (!item) continue;
+
+    const obj = item.obj[item.prop];
+
+    if (isArray(obj)) {
+      const compacted: unknown[] = [];
+
+      for (let j = 0; j < obj.length; ++j) {
+        if (typeof obj[j] !== 'undefined') {
+          compacted.push(obj[j]);
+        }
+      }
+
+      // @ts-ignore
+      item.obj[item.prop] = compacted;
+    }
+  }
+}
+
+function array_to_object(source: any[], options: { plainObjects: boolean }) {
+  const obj = options && options.plainObjects ? Object.create(null) : {};
+  for (let i = 0; i < source.length; ++i) {
+    if (typeof source[i] !== 'undefined') {
+      obj[i] = source[i];
+    }
+  }
+
+  return obj;
+}
+
+export function merge(
+  target: any,
+  source: any,
+  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
+) {
+  if (!source) {
+    return target;
+  }
+
+  if (typeof source !== 'object') {
+    if (isArray(target)) {
+      target.push(source);
+    } else if (target && typeof target === 'object') {
+      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
+        target[source] = true;
+      }
+    } else {
+      return [target, source];
+    }
+
+    return target;
+  }
+
+  if (!target || typeof target !== 'object') {
+    return [target].concat(source);
+  }
+
+  let mergeTarget = target;
+  if (isArray(target) && !isArray(source)) {
+    // @ts-ignore
+    mergeTarget = array_to_object(target, options);
+  }
+
+  if (isArray(target) && isArray(source)) {
+    source.forEach(function (item, i) {
+      if (has(target, i)) {
+        const targetItem = target[i];
+        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+          target[i] = merge(targetItem, item, options);
+        } else {
+          target.push(item);
+        }
+      } else {
+        target[i] = item;
+      }
+    });
+    return target;
+  }
+
+  return Object.keys(source).reduce(function (acc, key) {
+    const value = source[key];
+
+    if (has(acc, key)) {
+      acc[key] = merge(acc[key], value, options);
+    } else {
+      acc[key] = value;
+    }
+    return acc;
+  }, mergeTarget);
+}
+
+export function assign_single_source(target: any, source: any) {
+  return Object.keys(source).reduce(function (acc, key) {
+    acc[key] = source[key];
+    return acc;
+  }, target);
+}
+
+export function decode(str: string, _: any, charset: string) {
+  const strWithoutPlus = str.replace(/\+/g, ' ');
+  if (charset === 'iso-8859-1') {
+    // unescape never throws, no try...catch needed:
+    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+  }
+  // utf-8
+  try {
+    return decodeURIComponent(strWithoutPlus);
+  } catch (e) {
+    return strWithoutPlus;
+  }
+}
+
+const limit = 1024;
+
+export const encode: (
+  str: any,
+  defaultEncoder: DefaultEncoder,
+  charset: string,
+  type: 'key' | 'value',
+  format: Format,
+) => string = (str, _defaultEncoder, charset, _kind, format: Format) => {
+  // This code was originally written by Brian White for the io.js core querystring library.
+  // It has been adapted here for stricter adherence to RFC 3986
+  if (str.length === 0) {
+    return str;
+  }
+
+  let string = str;
+  if (typeof str === 'symbol') {
+    string = Symbol.prototype.toString.call(str);
+  } else if (typeof str !== 'string') {
+    string = String(str);
+  }
+
+  if (charset === 'iso-8859-1') {
+    return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
+      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
+    });
+  }
+
+  let out = '';
+  for (let j = 0; j < string.length; j += limit) {
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+    const arr = [];
+
+    for (let i = 0; i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (
+        c === 0x2d || // -
+        c === 0x2e || // .
+        c === 0x5f || // _
+        c === 0x7e || // ~
+        (c >= 0x30 && c <= 0x39) || // 0-9
+        (c >= 0x41 && c <= 0x5a) || // a-z
+        (c >= 0x61 && c <= 0x7a) || // A-Z
+        (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
+      ) {
+        arr[arr.length] = segment.charAt(i);
+        continue;
+      }
+
+      if (c < 0x80) {
+        arr[arr.length] = hex_table[c];
+        continue;
+      }
+
+      if (c < 0x800) {
+        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      if (c < 0xd800 || c >= 0xe000) {
+        arr[arr.length] =
+          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      i += 1;
+      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+
+      arr[arr.length] =
+        hex_table[0xf0 | (c >> 18)]! +
+        hex_table[0x80 | ((c >> 12) & 0x3f)] +
+        hex_table[0x80 | ((c >> 6) & 0x3f)] +
+        hex_table[0x80 | (c & 0x3f)];
+    }
+
+    out += arr.join('');
+  }
+
+  return out;
+};
+
+export function compact(value: any) {
+  const queue = [{ obj: { o: value }, prop: 'o' }];
+  const refs = [];
+
+  for (let i = 0; i < queue.length; ++i) {
+    const item = queue[i];
+    // @ts-ignore
+    const obj = item.obj[item.prop];
+
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; ++j) {
+      const key = keys[j]!;
+      const val = obj[key];
+      if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
+        queue.push({ obj: obj, prop: key });
+        refs.push(val);
+      }
+    }
+  }
+
+  compact_queue(queue);
+
+  return value;
+}
+
+export function is_regexp(obj: any) {
+  return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+
+export function is_buffer(obj: any) {
+  if (!obj || typeof obj !== 'object') {
+    return false;
+  }
+
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}
+
+export function combine(a: any, b: any) {
+  return [].concat(a, b);
+}
+
+export function maybe_map<T>(val: T[], fn: (v: T) => T) {
+  if (isArray(val)) {
+    const mapped = [];
+    for (let i = 0; i < val.length; i += 1) {
+      mapped.push(fn(val[i]!));
+    }
+    return mapped;
+  }
+  return fn(val);
+}

package/src/internal/utils/log.ts

@@ -106,6 +106,7 @@ export const formatRequestDetails = (details: {
         ([name, value]) => [
           name,
           (
+            name.toLowerCase() === 'x-api-key' ||
             name.toLowerCase() === 'authorization' ||
             name.toLowerCase() === 'cookie' ||
             name.toLowerCase() === 'set-cookie'

package/src/resources/v1/admin/admin.ts

@@ -17,6 +17,12 @@ export class Admin extends APIResource {
   organizations: OrganizationsAPI.Organizations = new OrganizationsAPI.Organizations(this._client);
   models: ModelsAPI.Models = new ModelsAPI.Models(this._client);
 
+  /**
+   * @example
+   * ```ts
+   * await client.v1.admin.getUsers();
+   * ```
+   */
   getUsers(options?: RequestOptions): APIPromise<void> {
     return this._client.get('/api/v1/admin/users', {
       ...options,

package/src/resources/v1/admin/models.ts

@@ -6,6 +6,12 @@ import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
 
 export class Models extends APIResource {
+  /**
+   * @example
+   * ```ts
+   * await client.v1.admin.models.listAll();
+   * ```
+   */
   listAll(options?: RequestOptions): APIPromise<void> {
     return this._client.get('/api/v1/admin/models/all', {
       ...options,

package/src/resources/v1/admin/organization-invites.ts

@@ -7,6 +7,14 @@ import { RequestOptions } from '../../../internal/request-options';
 import { path } from '../../../internal/utils/path';
 
 export class OrganizationInvites extends APIResource {
+  /**
+   * Create organization invite
+   *
+   * @example
+   * ```ts
+   * await client.v1.admin.organizationInvites.create();
+   * ```
+   */
   create(body: OrganizationInviteCreateParams, options?: RequestOptions): APIPromise<void> {
     return this._client.post('/api/v1/admin/organization-invites', {
       body,
@@ -15,6 +23,12 @@ export class OrganizationInvites extends APIResource {
     });
   }
 
+  /**
+   * @example
+   * ```ts
+   * await client.v1.admin.organizationInvites.list();
+   * ```
+   */
   list(options?: RequestOptions): APIPromise<void> {
     return this._client.get('/api/v1/admin/organization-invites', {
       ...options,
@@ -22,6 +36,12 @@ export class OrganizationInvites extends APIResource {
     });
   }
 
+  /**
+   * @example
+   * ```ts
+   * await client.v1.admin.organizationInvites.delete('id');
+   * ```
+   */
   delete(id: string, options?: RequestOptions): APIPromise<void> {
     return this._client.delete(path`/api/v1/admin/organization-invites/${id}`, {
       ...options,
@@ -29,6 +49,12 @@ export class OrganizationInvites extends APIResource {
     });
   }
 
+  /**
+   * @example
+   * ```ts
+   * await client.v1.admin.organizationInvites.resend('id');
+   * ```
+   */
   resend(id: string, options?: RequestOptions): APIPromise<void> {
     return this._client.post(path`/api/v1/admin/organization-invites/${id}/resend`, {
       ...options,

package/src/resources/v1/admin/organizations/models/excluded.ts

@@ -7,6 +7,14 @@ import { RequestOptions } from '../../../../../internal/request-options';
 import { path } from '../../../../../internal/utils/path';
 
 export class Excluded extends APIResource {
+  /**
+   * @example
+   * ```ts
+   * await client.v1.admin.organizations.models.excluded.create(
+   *   'organizationId',
+   * );
+   * ```
+   */
   create(organizationID: string, options?: RequestOptions): APIPromise<void> {
     return this._client.post(path`/api/v1/admin/organizations/${organizationID}/models/excluded`, {
       ...options,
@@ -14,6 +22,14 @@ export class Excluded extends APIResource {
     });
   }
 
+  /**
+   * @example
+   * ```ts
+   * await client.v1.admin.organizations.models.excluded.list(
+   *   'organizationId',
+   * );
+   * ```
+   */
   list(organizationID: string, options?: RequestOptions): APIPromise<void> {
     return this._client.get(path`/api/v1/admin/organizations/${organizationID}/models/excluded`, {
       ...options,

package/src/resources/v1/admin/organizations/organizations.ts

@@ -10,6 +10,12 @@ import { RequestOptions } from '../../../../internal/request-options';
 export class Organizations extends APIResource {
   models: ModelsAPI.Models = new ModelsAPI.Models(this._client);
 
+  /**
+   * @example
+   * ```ts
+   * await client.v1.admin.organizations.list();
+   * ```
+   */
   list(options?: RequestOptions): APIPromise<void> {
     return this._client.get('/api/v1/admin/organizations', {
       ...options,

package/src/resources/v1/audio-recaps/audio-recaps.ts

@@ -11,6 +11,14 @@ import { path } from '../../../internal/utils/path';
 export class AudioRecaps extends APIResource {
   sections: SectionsAPI.Sections = new SectionsAPI.Sections(this._client);
 
+  /**
+   * Create a new audio recap
+   *
+   * @example
+   * ```ts
+   * await client.v1.audioRecaps.create();
+   * ```
+   */
   create(body: AudioRecapCreateParams, options?: RequestOptions): APIPromise<void> {
     return this._client.post('/api/v1/audio-recaps/create', {
       body,
@@ -19,6 +27,14 @@ export class AudioRecaps extends APIResource {
     });
   }
 
+  /**
+   * Get audio recap by ID
+   *
+   * @example
+   * ```ts
+   * await client.v1.audioRecaps.retrieve('recapId');
+   * ```
+   */
   retrieve(recapID: string, options?: RequestOptions): APIPromise<void> {
     return this._client.get(path`/api/v1/audio-recaps/${recapID}/get`, {
       ...options,
@@ -26,6 +42,14 @@ export class AudioRecaps extends APIResource {
     });
   }
 
+  /**
+   * Ask a question about the audio recap
+   *
+   * @example
+   * ```ts
+   * await client.v1.audioRecaps.askQuestion('recapId');
+   * ```
+   */
   askQuestion(
     recapID: string,
     body: AudioRecapAskQuestionParams,

package/src/resources/v1/audio-recaps/sections.ts

@@ -7,6 +7,16 @@ import { RequestOptions } from '../../../internal/request-options';
 import { path } from '../../../internal/utils/path';
 
 export class Sections extends APIResource {
+  /**
+   * Get specific audio recap section
+   *
+   * @example
+   * ```ts
+   * await client.v1.audioRecaps.sections.retrieve('sectionId', {
+   *   recapId: 'recapId',
+   * });
+   * ```
+   */
   retrieve(sectionID: string, params: SectionRetrieveParams, options?: RequestOptions): APIPromise<void> {
     const { recapId } = params;
     return this._client.get(path`/api/v1/audio-recaps/${recapId}/sections/${sectionID}`, {
@@ -15,6 +25,14 @@ export class Sections extends APIResource {
     });
   }
 
+  /**
+   * Get audio recap sections
+   *
+   * @example
+   * ```ts
+   * await client.v1.audioRecaps.sections.list('recapId');
+   * ```
+   */
   list(recapID: string, options?: RequestOptions): APIPromise<void> {
     return this._client.get(path`/api/v1/audio-recaps/${recapID}/sections`, {
       ...options,
@@ -24,6 +42,9 @@ export class Sections extends APIResource {
 }
 
 export interface SectionRetrieveParams {
+  /**
+   * Audio recap ID
+   */
   recapId: string;
 }
 

package/src/resources/v1/auth/auth.ts

@@ -2,7 +2,7 @@
 
 import { APIResource } from '../../../core/resource';
 import * as LoginAPI from './login';
-import { Login, LoginCreateParams, LoginVerify2faParams, LoginVerifyBackupCodeParams } from './login';
+import { Login, LoginAuthenticateParams, LoginVerify2faParams, LoginVerifyBackupCodeParams } from './login';
 import * as Number2faAPI from './number-2fa';
 import {
   Number2fa,
@@ -23,14 +23,48 @@ export class Auth extends APIResource {
   organizationInvites: OrganizationInvitesAPI.OrganizationInvites =
     new OrganizationInvitesAPI.OrganizationInvites(this._client);
 
-  forgotPassword(body: AuthForgotPasswordParams, options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/auth/forgot-password', {
+  /**
+   * Get current user profile
+   *
+   * @example
+   * ```ts
+   * await client.v1.auth.getProfile();
+   * ```
+   */
+  getProfile(options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/api/v1/auth/profile', {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Register new user
+   *
+   * @example
+   * ```ts
+   * await client.v1.auth.registerNewUser({
+   *   email: 'user@example.com',
+   *   name: 'John Doe',
+   *   organizationName: 'Acme Corp',
+   *   password: 'password123',
+   * });
+   * ```
+   */
+  registerNewUser(body: AuthRegisterNewUserParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post('/api/v1/auth/register', {
       body,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
+  /**
+   * @example
+   * ```ts
+   * await client.v1.auth.registerOrganization();
+   * ```
+   */
   registerOrganization(options?: RequestOptions): APIPromise<void> {
     return this._client.post('/api/v1/auth/register-organization', {
       ...options,
@@ -38,6 +72,14 @@ export class Auth extends APIResource {
     });
   }
 
+  /**
+   * Register new user with organization invite
+   *
+   * @example
+   * ```ts
+   * await client.v1.auth.registerWithInvite();
+   * ```
+   */
   registerWithInvite(body: AuthRegisterWithInviteParams, options?: RequestOptions): APIPromise<void> {
     return this._client.post('/api/v1/auth/register-with-invite', {
       body,
@@ -46,34 +88,109 @@ export class Auth extends APIResource {
     });
   }
 
-  resetPassword(body: AuthResetPasswordParams, options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/auth/reset-password', {
+  /**
+   * Request password reset
+   *
+   * @example
+   * ```ts
+   * await client.v1.auth.requestPasswordReset({
+   *   email: 'user@example.com',
+   * });
+   * ```
+   */
+  requestPasswordReset(body: AuthRequestPasswordResetParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post('/api/v1/auth/forgot-password', {
       body,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
-  retrieveProfile(options?: RequestOptions): APIPromise<void> {
-    return this._client.get('/api/v1/auth/profile', {
+  /**
+   * Reset password with token
+   *
+   * @example
+   * ```ts
+   * await client.v1.auth.resetPassword({
+   *   token: 'reset-token-uuid',
+   *   newPassword: 'newPassword123',
+   * });
+   * ```
+   */
+  resetPassword(body: AuthResetPasswordParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post('/api/v1/auth/reset-password', {
+      body,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
-  verifyResetToken(options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/auth/verify-reset-token', {
+  /**
+   * Verify password reset token
+   *
+   * @example
+   * ```ts
+   * await client.v1.auth.verifyResetToken({ token: 'token' });
+   * ```
+   */
+  verifyResetToken(query: AuthVerifyResetTokenParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/api/v1/auth/verify-reset-token', {
+      query,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 }
 
-export interface AuthForgotPasswordParams {}
+export interface AuthRegisterNewUserParams {
+  /**
+   * User email address
+   */
+  email: string;
+
+  /**
+   * User full name
+   */
+  name: string;
+
+  /**
+   * Organization name
+   */
+  organizationName: string;
+
+  /**
+   * User password
+   */
+  password: string;
+}
 
 export interface AuthRegisterWithInviteParams {}
 
-export interface AuthResetPasswordParams {}
+export interface AuthRequestPasswordResetParams {
+  /**
+   * Email address to send reset link
+   */
+  email: string;
+}
+
+export interface AuthResetPasswordParams {
+  /**
+   * Password reset token from email
+   */
+  token: string;
+
+  /**
+   * New password
+   */
+  newPassword: string;
+}
+
+export interface AuthVerifyResetTokenParams {
+  /**
+   * Password reset token
+   */
+  token: string;
+}
 
 Auth.Login = Login;
 Auth.Number2fa = Number2fa;
@@ -81,14 +198,16 @@ Auth.OrganizationInvites = OrganizationInvites;
 
 export declare namespace Auth {
   export {
-    type AuthForgotPasswordParams as AuthForgotPasswordParams,
+    type AuthRegisterNewUserParams as AuthRegisterNewUserParams,
     type AuthRegisterWithInviteParams as AuthRegisterWithInviteParams,
+    type AuthRequestPasswordResetParams as AuthRequestPasswordResetParams,
     type AuthResetPasswordParams as AuthResetPasswordParams,
+    type AuthVerifyResetTokenParams as AuthVerifyResetTokenParams,
   };
 
   export {
     Login as Login,
-    type LoginCreateParams as LoginCreateParams,
+    type LoginAuthenticateParams as LoginAuthenticateParams,
     type LoginVerify2faParams as LoginVerify2faParams,
     type LoginVerifyBackupCodeParams as LoginVerifyBackupCodeParams,
   };