@kombo-api/sdk 0.1.1

package/src/sdk/hris.ts

@@ -0,0 +1,541 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { hrisAddEmployeeDocument } from "../funcs/hrisAddEmployeeDocument.js";
+import { hrisCreateAbsence } from "../funcs/hrisCreateAbsence.js";
+import { hrisCreateEmployeeWithForm } from "../funcs/hrisCreateEmployeeWithForm.js";
+import { hrisDeleteAbsence } from "../funcs/hrisDeleteAbsence.js";
+import { hrisGetAbsences } from "../funcs/hrisGetAbsences.js";
+import { hrisGetAbsenceTypes } from "../funcs/hrisGetAbsenceTypes.js";
+import { hrisGetEmployeeDocumentCategories } from "../funcs/hrisGetEmployeeDocumentCategories.js";
+import { hrisGetEmployeeForm } from "../funcs/hrisGetEmployeeForm.js";
+import { hrisGetEmployees } from "../funcs/hrisGetEmployees.js";
+import { hrisGetEmployments } from "../funcs/hrisGetEmployments.js";
+import { hrisGetGroups } from "../funcs/hrisGetGroups.js";
+import { hrisGetLegalEntities } from "../funcs/hrisGetLegalEntities.js";
+import { hrisGetLocations } from "../funcs/hrisGetLocations.js";
+import { hrisGetPerformanceReviewCycles } from "../funcs/hrisGetPerformanceReviewCycles.js";
+import { hrisGetPerformanceReviews } from "../funcs/hrisGetPerformanceReviews.js";
+import { hrisGetTimeOffBalances } from "../funcs/hrisGetTimeOffBalances.js";
+import { hrisGetTimesheets } from "../funcs/hrisGetTimesheets.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";
+import { PageIterator, unwrapResultIterator } from "../types/operations.js";
+
+export class Hris extends ClientSDK {
+  /**
+   * Get employees
+   *
+   * @remarks
+   * Retrieve all employees.
+   *
+   * <Note>Not interested in most fields? You can use our [our Scopes feature](/scopes) to customize what data points are synced.</Note>
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getEmployees(
+    request?: operations.GetHrisEmployeesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<operations.GetHrisEmployeesResponse, { cursor: string }>
+  > {
+    return unwrapResultIterator(hrisGetEmployees(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get employee form
+   *
+   * @remarks
+   * Get the form for creating an employee. This form can be rendered dynamically on your frontend to allow your customers to create employees in their HRIS.
+   *
+   * Follow our [create employee guide here](/hris/features/create-employee) to learn how this form is generated and how you can use it.
+   *
+   * ### Example Form
+   * ```json
+   * {
+   *   "properties": {
+   *     "firstName": {
+   *       "type": "text",
+   *       "label": "First Name",
+   *       "required": true,
+   *       "description": "Employee's first name",
+   *       "unified_key": "first_name",
+   *       "min_length": 1,
+   *       "max_length": 100
+   *     },
+   *     "startDate": {
+   *       "type": "date",
+   *       "label": "Start Date",
+   *       "required": true,
+   *       "description": "Employee's start date",
+   *       "unified_key": "start_date"
+   *     },
+   *     "workLocation": {
+   *       "type": "object",
+   *       "label": "Work Location",
+   *       "required": false,
+   *       "description": "Employee's work location",
+   *       "unified_key": null,
+   *       "properties": {
+   *         "site": {
+   *           "type": "single_select",
+   *           "label": "Site",
+   *           "required": true,
+   *           "description": "Employee's site",
+   *           "unified_key": null,
+   *           "options": {
+   *             "type": "inline",
+   *             "entries": [
+   *               {
+   *                 "label": "Site 1",
+   *                 "id": "FXrER44xubBqA9DLgZ3PFNNx",
+   *                 "unified_value": "1",
+   *                 "remote_id": "site_1"
+   *               },
+   *               {
+   *                 "label": "Site 2",
+   *                 "id": "2rv75UKT2XBoQXsUb9agiTUm",
+   *                 "unified_value": "2",
+   *                 "remote_id": "site_2"
+   *               }
+   *             ]
+   *           }
+   *         },
+   *         "keyNumbers": {
+   *           "type": "array",
+   *           "label": "Key Numbers",
+   *           "required": false,
+   *           "description": "Employee's key numbers",
+   *           "unified_key": null,
+   *           "min_items": 2,
+   *           "max_items": 5,
+   *           "item_type": {
+   *             "type": "number",
+   *             "label": "Key Number",
+   *             "required": false,
+   *             "description": "The number of the keys which belong to the employee",
+   *             "unified_key": null,
+   *             "min": 0,
+   *             "max": 99
+   *           }
+   *         }
+   *       }
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  async getEmployeeForm(
+    request?: operations.GetHrisEmployeesFormRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.GetHrisEmployeesFormPositiveResponse> {
+    return unwrapAsync(hrisGetEmployeeForm(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create employee with form
+   *
+   * @remarks
+   * Create an employee, based on the form schema.
+   *
+   * <Note>
+   *   This endpoint requires the permission **Create and manage employees** to be enabled in [your scope config](/scopes).
+   * </Note>
+   *
+   * ### Example Request Body
+   *
+   * ```json
+   * {
+   *   "properties": {
+   *     "firstName": "John",
+   *     "startDate": "2025-01-01",
+   *     "workLocation": {
+   *       "site": "8e422bf8cav",
+   *       "keyNumbers": [
+   *         142,
+   *         525,
+   *         63
+   *       ]
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  async createEmployeeWithForm(
+    request?: models.PostHrisEmployeesFormRequestBody | undefined,
+    options?: RequestOptions,
+  ): Promise<models.PostHrisEmployeesFormPositiveResponse> {
+    return unwrapAsync(hrisCreateEmployeeWithForm(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Add document to employee
+   *
+   * @remarks
+   * Uploads an document file for the specified employee.
+   *
+   * <Note>
+   *   This endpoint requires the permission **Manage documents** to be enabled in [your scope config](/scopes).
+   * </Note>
+   *
+   * ### Example Request Body
+   *
+   * ```json
+   * {
+   *   "category_id": "3Cjwu7nA7pH5cX5X1NAPmb7M",
+   *   "document": {
+   *     "name": "Frank Doe Employment Contract.txt",
+   *     "data": "SGkgdGhlcmUsIEtvbWJvIGlzIGN1cnJlbnRseSBoaXJpbmcgZW5naW5lZXJzIHRoYXQgbG92ZSB0byB3b3JrIG9uIGRldmVsb3BlciBwcm9kdWN0cy4=",
+   *     "content_type": "text/plain"
+   *   }
+   * }
+   * ```
+   */
+  async addEmployeeDocument(
+    request: operations.PostHrisEmployeesEmployeeIdDocumentsRequest,
+    options?: RequestOptions,
+  ): Promise<models.PostHrisEmployeesEmployeeIdDocumentsPositiveResponse> {
+    return unwrapAsync(hrisAddEmployeeDocument(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get employee document categories
+   *
+   * @remarks
+   * Get employee document categories.
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getEmployeeDocumentCategories(
+    request?: operations.GetHrisEmployeeDocumentCategoriesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<
+      operations.GetHrisEmployeeDocumentCategoriesResponse,
+      { cursor: string }
+    >
+  > {
+    return unwrapResultIterator(hrisGetEmployeeDocumentCategories(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get groups
+   *
+   * @remarks
+   * Retrieve all "groups" (teams, departments, and cost centers).
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getGroups(
+    request?: operations.GetHrisGroupsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<operations.GetHrisGroupsResponse, { cursor: string }>
+  > {
+    return unwrapResultIterator(hrisGetGroups(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get employments
+   *
+   * @remarks
+   * Retrieve all employments.
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getEmployments(
+    request?: operations.GetHrisEmploymentsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<operations.GetHrisEmploymentsResponse, { cursor: string }>
+  > {
+    return unwrapResultIterator(hrisGetEmployments(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get work locations
+   *
+   * @remarks
+   * Retrieve all work locations.
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getLocations(
+    request?: operations.GetHrisLocationsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<operations.GetHrisLocationsResponse, { cursor: string }>
+  > {
+    return unwrapResultIterator(hrisGetLocations(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get absence types
+   *
+   * @remarks
+   * Retrieve all absence types.
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getAbsenceTypes(
+    request?: operations.GetHrisAbsenceTypesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<operations.GetHrisAbsenceTypesResponse, { cursor: string }>
+  > {
+    return unwrapResultIterator(hrisGetAbsenceTypes(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get time off balances
+   *
+   * @remarks
+   * Retrieve all time off balances.
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getTimeOffBalances(
+    request?: operations.GetHrisTimeOffBalancesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<operations.GetHrisTimeOffBalancesResponse, { cursor: string }>
+  > {
+    return unwrapResultIterator(hrisGetTimeOffBalances(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get absences
+   *
+   * @remarks
+   * Retrieve all absences.
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getAbsences(
+    request?: operations.GetHrisAbsencesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<operations.GetHrisAbsencesResponse, { cursor: string }>
+  > {
+    return unwrapResultIterator(hrisGetAbsences(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create absence
+   *
+   * @remarks
+   * Create a new absence.
+   *
+   * Check [this page](/hris/features/creating-absences) for a detailed guide.
+   *
+   * <Note>
+   *   This endpoint requires the permission **Manage absences** to be enabled in [your scope config](/scopes).
+   * </Note>
+   *
+   * ### Example Request Body
+   *
+   * ```json
+   * {
+   *   "employee_id": "wXJMxwDvPAjrJ4CyqdV9",
+   *   "absence_type_id": "3YKtQ7qedsrcCady1jSyAkY1",
+   *   "start_date": "2019-09-17",
+   *   "end_date": "2019-09-21",
+   *   "start_time": "08:30:00",
+   *   "end_time": "16:00:00",
+   *   "start_half_day": false,
+   *   "end_half_day": false,
+   *   "employee_note": "Visiting the aliens"
+   * }
+   * ```
+   */
+  async createAbsence(
+    request: models.PostHrisAbsencesRequestBody,
+    options?: RequestOptions,
+  ): Promise<models.PostHrisAbsencesPositiveResponse> {
+    return unwrapAsync(hrisCreateAbsence(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete absence
+   *
+   * @remarks
+   * Delete this absence.
+   *
+   * <Note>
+   *   This endpoint requires the permission **Manage absences** to be enabled in [your scope config](/scopes).
+   * </Note>
+   *
+   * ### Example Request Body
+   *
+   * ```json
+   * {
+   *   "absence_id": "wXJMxwDvPAjrJ4CyqdV9"
+   * }
+   * ```
+   */
+  async deleteAbsence(
+    request: operations.DeleteHrisAbsencesAbsenceIdRequest,
+    options?: RequestOptions,
+  ): Promise<models.DeleteHrisAbsencesAbsenceIdPositiveResponse> {
+    return unwrapAsync(hrisDeleteAbsence(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get legal entities
+   *
+   * @remarks
+   * Retrieve all legal entites.
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getLegalEntities(
+    request?: operations.GetHrisLegalEntitiesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<operations.GetHrisLegalEntitiesResponse, { cursor: string }>
+  > {
+    return unwrapResultIterator(hrisGetLegalEntities(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get timesheets
+   *
+   * @remarks
+   * Get timesheets
+   *
+   * Retrieve attendance data and timesheets from HRIS tools.
+   *
+   * <Warning>**Open Beta Feature:** This endpoint is currently in beta. Please reach out to our support team if you need assistance with implementation.</Warning>
+   *
+   * For a detailed explanation of the data model, validation rules, time zones, payable hours, approvals, and break patterns, see the [Time & Attendance guide](/hris/features/time-and-attendance).
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getTimesheets(
+    request?: operations.GetHrisTimesheetsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<operations.GetHrisTimesheetsResponse, { cursor: string }>
+  > {
+    return unwrapResultIterator(hrisGetTimesheets(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get performance review cycles
+   *
+   * @remarks
+   * Get performance review cycles
+   *
+   * Retrieve performance review cycles data from HRIS tools.
+   *
+   * <Warning>**Open Beta Feature:** This endpoint is currently in beta. Please reach out to our support team if you need assistance with implementation.</Warning>
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getPerformanceReviewCycles(
+    request?: operations.GetHrisPerformanceReviewCyclesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<
+      operations.GetHrisPerformanceReviewCyclesResponse,
+      { cursor: string }
+    >
+  > {
+    return unwrapResultIterator(hrisGetPerformanceReviewCycles(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get performance reviews
+   *
+   * @remarks
+   * Get performance reviews
+   *
+   * Retrieve performance review data from HRIS tools.
+   *
+   * <Warning>**Open Beta Feature:** This endpoint is currently in beta. Please reach out to our support team if you need assistance with implementation.</Warning>
+   *
+   * Top level filters use AND, while individual filters use OR if they accept multiple arguments. That means filters will be resolved like this: `(id IN ids) AND (remote_id IN remote_ids)`
+   */
+  async getPerformanceReviews(
+    request?: operations.GetHrisPerformanceReviewsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<
+      operations.GetHrisPerformanceReviewsResponse,
+      { cursor: string }
+    >
+  > {
+    return unwrapResultIterator(hrisGetPerformanceReviews(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/index.ts

@@ -0,0 +1,5 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export * from "./sdk.js";

package/src/sdk/sdk.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ClientSDK } from "../lib/sdks.js";
+import { Assessment } from "./assessment.js";
+import { Ats } from "./ats.js";
+import { Connect } from "./connect.js";
+import { General } from "./general.js";
+import { Hris } from "./hris.js";
+
+export class Kombo extends ClientSDK {
+  private _general?: General;
+  get general(): General {
+    return (this._general ??= new General(this._options));
+  }
+
+  private _hris?: Hris;
+  get hris(): Hris {
+    return (this._hris ??= new Hris(this._options));
+  }
+
+  private _ats?: Ats;
+  get ats(): Ats {
+    return (this._ats ??= new Ats(this._options));
+  }
+
+  private _assessment?: Assessment;
+  get assessment(): Assessment {
+    return (this._assessment ??= new Assessment(this._options));
+  }
+
+  private _connect?: Connect;
+  get connect(): Connect {
+    return (this._connect ??= new Connect(this._options));
+  }
+}

package/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/src/types/blobs.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export const blobLikeSchema: z.ZodType<Blob, z.ZodTypeDef, Blob> = z.custom<
+  Blob
+>(isBlobLike, {
+  message: "expected a Blob, File or Blob-like object",
+  fatal: 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/src/types/constdatetime.ts

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