@vitable-inc/vitable-connect 0.1.0

package/src/internal/utils/path.ts

@@ -0,0 +1,88 @@
+import { VitableConnectError } from '../../core/error';
+
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+export function encodeURIPath(str: string) {
+  return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+}
+
+const EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
+
+export const createPathTagFunction = (pathEncoder = encodeURIPath) =>
+  function path(statics: readonly string[], ...params: readonly unknown[]): string {
+    // If there are no params, no processing is needed.
+    if (statics.length === 1) return statics[0]!;
+
+    let postPath = false;
+    const invalidSegments = [];
+    const path = statics.reduce((previousValue, currentValue, index) => {
+      if (/[?#]/.test(currentValue)) {
+        postPath = true;
+      }
+      const value = params[index];
+      let encoded = (postPath ? encodeURIComponent : pathEncoder)('' + value);
+      if (
+        index !== params.length &&
+        (value == null ||
+          (typeof value === 'object' &&
+            // handle values from other realms
+            value.toString ===
+              Object.getPrototypeOf(Object.getPrototypeOf((value as any).hasOwnProperty ?? EMPTY) ?? EMPTY)
+                ?.toString))
+      ) {
+        encoded = value + '';
+        invalidSegments.push({
+          start: previousValue.length + currentValue.length,
+          length: encoded.length,
+          error: `Value of type ${Object.prototype.toString
+            .call(value)
+            .slice(8, -1)} is not a valid path parameter`,
+        });
+      }
+      return previousValue + currentValue + (index === params.length ? '' : encoded);
+    }, '');
+
+    const pathOnly = path.split(/[?#]/, 1)[0]!;
+    const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
+    let match;
+
+    // Find all invalid segments
+    while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
+      invalidSegments.push({
+        start: match.index,
+        length: match[0].length,
+        error: `Value "${match[0]}" can\'t be safely passed as a path parameter`,
+      });
+    }
+
+    invalidSegments.sort((a, b) => a.start - b.start);
+
+    if (invalidSegments.length > 0) {
+      let lastEnd = 0;
+      const underline = invalidSegments.reduce((acc, segment) => {
+        const spaces = ' '.repeat(segment.start - lastEnd);
+        const arrows = '^'.repeat(segment.length);
+        lastEnd = segment.start + segment.length;
+        return acc + spaces + arrows;
+      }, '');
+
+      throw new VitableConnectError(
+        `Path parameters result in path with invalid segments:\n${invalidSegments
+          .map((e) => e.error)
+          .join('\n')}\n${path}\n${underline}`,
+      );
+    }
+
+    return path;
+  };
+
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+export const path = /* @__PURE__ */ createPathTagFunction(encodeURIPath);

package/src/internal/utils/query.ts

@@ -0,0 +1,23 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { VitableConnectError } from '../../core/error';
+
+/**
+ * Basic re-implementation of `qs.stringify` for primitive types.
+ */
+export function stringifyQuery(query: object | Record<string, unknown>) {
+  return Object.entries(query)
+    .filter(([_, value]) => typeof value !== 'undefined')
+    .map(([key, value]) => {
+      if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+      }
+      if (value === null) {
+        return `${encodeURIComponent(key)}=`;
+      }
+      throw new VitableConnectError(
+        `Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`,
+      );
+    })
+    .join('&');
+}

package/src/internal/utils/sleep.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

package/src/internal/utils/uuid.ts

@@ -0,0 +1,17 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+export let uuid4 = function () {
+  const { crypto } = globalThis as any;
+  if (crypto?.randomUUID) {
+    uuid4 = crypto.randomUUID.bind(crypto);
+    return crypto.randomUUID();
+  }
+  const u8 = new Uint8Array(1);
+  const randomByte = crypto ? () => crypto.getRandomValues(u8)[0]! : () => (Math.random() * 0xff) & 0xff;
+  return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) =>
+    (+c ^ (randomByte() & (15 >> (+c / 4)))).toString(16),
+  );
+};

package/src/internal/utils/values.ts

@@ -0,0 +1,105 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { VitableConnectError } from '../../core/error';
+
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+
+export const isAbsoluteURL = (url: string): boolean => {
+  return startsWithSchemeRegexp.test(url);
+};
+
+export let isArray = (val: unknown): val is unknown[] => ((isArray = Array.isArray), isArray(val));
+export let isReadonlyArray = isArray as (val: unknown) => val is readonly unknown[];
+
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export function maybeObj(x: unknown): object {
+  if (typeof x !== 'object') {
+    return {};
+  }
+
+  return x ?? {};
+}
+
+// https://stackoverflow.com/a/34491287
+export function isEmptyObj(obj: Object | null | undefined): boolean {
+  if (!obj) return true;
+  for (const _k in obj) return false;
+  return true;
+}
+
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+export function hasOwn<T extends object = object>(obj: T, key: PropertyKey): key is keyof T {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function isObj(obj: unknown): obj is Record<string, unknown> {
+  return obj != null && typeof obj === 'object' && !Array.isArray(obj);
+}
+
+export const ensurePresent = <T>(value: T | null | undefined): T => {
+  if (value == null) {
+    throw new VitableConnectError(`Expected a value to be given but received ${value} instead.`);
+  }
+
+  return value;
+};
+
+export const validatePositiveInteger = (name: string, n: unknown): number => {
+  if (typeof n !== 'number' || !Number.isInteger(n)) {
+    throw new VitableConnectError(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new VitableConnectError(`${name} must be a positive integer`);
+  }
+  return n;
+};
+
+export const coerceInteger = (value: unknown): number => {
+  if (typeof value === 'number') return Math.round(value);
+  if (typeof value === 'string') return parseInt(value, 10);
+
+  throw new VitableConnectError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceFloat = (value: unknown): number => {
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') return parseFloat(value);
+
+  throw new VitableConnectError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceBoolean = (value: unknown): boolean => {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') return value === 'true';
+  return Boolean(value);
+};
+
+export const maybeCoerceInteger = (value: unknown): number | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceInteger(value);
+};
+
+export const maybeCoerceFloat = (value: unknown): number | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceFloat(value);
+};
+
+export const maybeCoerceBoolean = (value: unknown): boolean | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceBoolean(value);
+};
+
+export const safeJSON = (text: string) => {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return undefined;
+  }
+};

package/src/internal/utils.ts

@@ -0,0 +1,9 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './utils/values';
+export * from './utils/base64';
+export * from './utils/env';
+export * from './utils/log';
+export * from './utils/uuid';
+export * from './utils/sleep';
+export * from './utils/query';

package/src/lib/.keep

@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.

package/src/pagination.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/pagination instead */
+export * from './core/pagination';

package/src/resource.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/resource instead */
+export * from './core/resource';

package/src/resources/auth.ts

@@ -0,0 +1,115 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import * as AuthAPI from './auth';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+
+/**
+ * Issue short-lived access tokens for scoped API access
+ */
+export class Auth extends APIResource {
+  /**
+   * Issues a short-lived access token from the authenticated API key. Access tokens
+   * can optionally be bound to a specific employer or employee for scoped access.
+   * Tokens expire after 15 minutes.
+   *
+   * @example
+   * ```ts
+   * const response = await client.auth.issueAccessToken({
+   *   grant_type: 'client_credentials',
+   * });
+   * ```
+   */
+  issueAccessToken(
+    body: AuthIssueAccessTokenParams,
+    options?: RequestOptions,
+  ): APIPromise<AuthIssueAccessTokenResponse> {
+    return this._client.post('/v1/auth/access-tokens', { body, ...options });
+  }
+}
+
+/**
+ * - `employer` - employer
+ * - `employee` - employee
+ */
+export type Type = 'employer' | 'employee';
+
+export interface AuthIssueAccessTokenResponse {
+  /**
+   * The issued access token (vit*at*\*)
+   */
+  access_token: string;
+
+  /**
+   * Token lifetime in seconds
+   */
+  expires_in: number;
+
+  /**
+   * Token type, always 'Bearer'
+   */
+  token_type: string;
+
+  /**
+   * Entity the token is bound to, if any
+   */
+  bound_entity?: AuthIssueAccessTokenResponse.BoundEntity | null;
+}
+
+export namespace AuthIssueAccessTokenResponse {
+  /**
+   * Entity the token is bound to, if any
+   */
+  export interface BoundEntity {
+    /**
+     * Prefixed entity ID the token is bound to (empr*\* or empl*\*)
+     */
+    id: string;
+
+    /**
+     * - `employer` - employer
+     * - `employee` - employee
+     */
+    type: AuthAPI.Type;
+  }
+}
+
+export interface AuthIssueAccessTokenParams {
+  /**
+   * - `client_credentials` - client_credentials
+   */
+  grant_type: 'client_credentials';
+
+  /**
+   * Optional entity to bind the token to for scoped access
+   */
+  bound_entity?: AuthIssueAccessTokenParams.BoundEntity | null;
+}
+
+export namespace AuthIssueAccessTokenParams {
+  /**
+   * Optional entity to bind the token to for scoped access
+   */
+  export interface BoundEntity {
+    /**
+     * Prefixed entity ID to bind the token to (empr*\* for employer, empl*\* for
+     * employee)
+     */
+    id: string;
+
+    /**
+     * - `employer` - employer
+     * - `employee` - employee
+     */
+    type: AuthAPI.Type;
+  }
+}
+
+export declare namespace Auth {
+  export {
+    type Type as Type,
+    type AuthIssueAccessTokenResponse as AuthIssueAccessTokenResponse,
+    type AuthIssueAccessTokenParams as AuthIssueAccessTokenParams,
+  };
+}

package/src/resources/benefit-eligibility-policies.ts

@@ -0,0 +1,48 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+/**
+ * Define rules that determine which employees qualify for benefits
+ */
+export class BenefitEligibilityPolicies extends APIResource {
+  /**
+   * Retrieves a benefit eligibility policy by ID.
+   */
+  retrieve(policyID: string, options?: RequestOptions): APIPromise<BenefitEligibilityPolicyResponse> {
+    return this._client.get(path`/v1/benefit-eligibility-policies/${policyID}`, options);
+  }
+}
+
+export interface BenefitEligibilityPolicy {
+  id: string;
+
+  active: boolean;
+
+  classification: string;
+
+  created_at: string;
+
+  employer_id: string;
+
+  updated_at: string;
+
+  waiting_period: string;
+}
+
+/**
+ * Response containing a single benefit eligibility policy resource.
+ */
+export interface BenefitEligibilityPolicyResponse {
+  data: BenefitEligibilityPolicy;
+}
+
+export declare namespace BenefitEligibilityPolicies {
+  export {
+    type BenefitEligibilityPolicy as BenefitEligibilityPolicy,
+    type BenefitEligibilityPolicyResponse as BenefitEligibilityPolicyResponse,
+  };
+}

package/src/resources/employees.ts

@@ -0,0 +1,247 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import * as EnrollmentsAPI from './enrollments';
+import { EnrollmentsPageNumberPage } from './enrollments';
+import { APIPromise } from '../core/api-promise';
+import { PageNumberPage, type PageNumberPageParams, PagePromise } from '../core/pagination';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class Employees extends APIResource {
+  /**
+   * Retrieves detailed information for a specific employee by ID. Returns employee
+   * details including personal information and employment status.
+   */
+  retrieve(employeeID: string, options?: RequestOptions): APIPromise<EmployeeRetrieveResponse> {
+    return this._client.get(path`/v1/employees/${employeeID}`, options);
+  }
+
+  /**
+   * Retrieves a paginated list of benefit enrollments for an employee.
+   */
+  listEnrollments(
+    employeeID: string,
+    query: EmployeeListEnrollmentsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<EnrollmentsPageNumberPage, EnrollmentsAPI.Enrollment> {
+    return this._client.getAPIList(
+      path`/v1/employees/${employeeID}/enrollments`,
+      PageNumberPage<EnrollmentsAPI.Enrollment>,
+      { query, ...options },
+    );
+  }
+}
+
+export type EmployeesPageNumberPage = PageNumberPage<Employee>;
+
+export interface Employee {
+  /**
+   * Unique employee identifier with 'empl\_' prefix
+   */
+  id: string;
+
+  /**
+   * Timestamp when the employee was created
+   */
+  created_at: string;
+
+  /**
+   * Date of birth (YYYY-MM-DD)
+   */
+  date_of_birth: string;
+
+  /**
+   * Email address
+   */
+  email: string;
+
+  /**
+   * Benefit enrollments for this employee
+   */
+  enrollments: Array<Employee.Enrollment>;
+
+  /**
+   * Employee's legal first name
+   */
+  first_name: string;
+
+  /**
+   * Employee's legal last name
+   */
+  last_name: string;
+
+  /**
+   * Unique member identifier with 'mbr\_' prefix
+   */
+  member_id: string;
+
+  /**
+   * Employee status (active or terminated)
+   */
+  status: string;
+
+  /**
+   * Timestamp when the employee was last updated
+   */
+  updated_at: string;
+
+  /**
+   * Employee's residential address
+   */
+  address?: Employee.Address | null;
+
+  /**
+   * - `Full Time` - Full Time
+   * - `Part Time` - Part Time
+   * - `Temporary` - Temporary
+   * - `Intern` - Intern
+   * - `Seasonal` - Seasonal
+   * - `Individual Contractor` - Individual Contractor
+   */
+  employee_class?: EmployeeClass | null;
+
+  /**
+   * Gender identity, if provided
+   */
+  gender?: string | null;
+
+  /**
+   * Employee's hire date with the employer
+   */
+  hire_date?: string | null;
+
+  /**
+   * Phone number (10-digit US domestic string)
+   */
+  phone?: string | null;
+
+  /**
+   * Partner-assigned reference ID for the employee
+   */
+  reference_id?: string | null;
+
+  /**
+   * Name suffix (e.g., Jr., Sr., III)
+   */
+  suffix?: string | null;
+
+  /**
+   * Employee's termination date, if terminated
+   */
+  termination_date?: string | null;
+}
+
+export namespace Employee {
+  export interface Enrollment {
+    /**
+     * Unique enrollment identifier with 'enrl\_' prefix
+     */
+    id: string;
+
+    /**
+     * - `pending` - Pending
+     * - `enrolled` - Enrolled
+     * - `waived` - Waived
+     * - `inactive` - Inactive
+     */
+    status: EnrollmentsAPI.EnrollmentStatus;
+
+    /**
+     * Timestamp when the enrollment decision was made
+     */
+    answered_at?: string | null;
+  }
+
+  /**
+   * Employee's residential address
+   */
+  export interface Address {
+    /**
+     * Primary street address
+     */
+    address_line_1: string;
+
+    /**
+     * City name
+     */
+    city: string;
+
+    /**
+     * Two-letter state code (e.g., CA, NY)
+     */
+    state: string;
+
+    /**
+     * ZIP code (5 or 9 digit)
+     */
+    zipcode: string;
+
+    /**
+     * Secondary street address (apt, suite, etc.)
+     */
+    address_line_2?: string | null;
+  }
+}
+
+/**
+ * - `Full Time` - Full Time
+ * - `Part Time` - Part Time
+ * - `Temporary` - Temporary
+ * - `Intern` - Intern
+ * - `Seasonal` - Seasonal
+ * - `Individual Contractor` - Individual Contractor
+ */
+export type EmployeeClass =
+  | 'Full Time'
+  | 'Part Time'
+  | 'Temporary'
+  | 'Intern'
+  | 'Seasonal'
+  | 'Individual Contractor';
+
+/**
+ * Pagination metadata for list responses.
+ */
+export interface Pagination {
+  /**
+   * Items per page
+   */
+  limit: number;
+
+  /**
+   * Current page number
+   */
+  page: number;
+
+  /**
+   * Total number of items
+   */
+  total: number;
+
+  /**
+   * Total number of pages
+   */
+  total_pages: number;
+}
+
+/**
+ * Response containing a single employee resource.
+ */
+export interface EmployeeRetrieveResponse {
+  data: Employee;
+}
+
+export interface EmployeeListEnrollmentsParams extends PageNumberPageParams {}
+
+export declare namespace Employees {
+  export {
+    type Employee as Employee,
+    type EmployeeClass as EmployeeClass,
+    type Pagination as Pagination,
+    type EmployeeRetrieveResponse as EmployeeRetrieveResponse,
+    type EmployeeListEnrollmentsParams as EmployeeListEnrollmentsParams,
+  };
+}
+
+export { type EnrollmentsPageNumberPage };