@tryfinch/finch-api 1.0.0

package/pagination.ts

@@ -0,0 +1,401 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import { AbstractPage, APIResponse, APIClient, FinalRequestOptions, PageInfo } from './core';
+import * as HRIS from './resources/hris';
+import * as ATS from './resources/ats';
+
+export type SinglePageResponse<Item> = Item[];
+
+export class SinglePage<Item> extends AbstractPage<Item> {
+  items: Array<Item>;
+
+  constructor(
+    client: APIClient,
+    response: APIResponse<SinglePageResponse<Item>>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, options);
+
+    this.items = response || [];
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.items;
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  /**
+   * This page represents a response that isn't actually paginated at the API level
+   * so there will never be any next page params.
+   */
+  nextPageParams(): null {
+    return null;
+  }
+
+  nextPageInfo(): null {
+    return null;
+  }
+}
+
+export interface ResponsesPageResponse<Item> {
+  responses: Array<Item>;
+}
+
+export class ResponsesPage<Item> extends AbstractPage<Item> implements ResponsesPageResponse<Item> {
+  responses: Array<Item>;
+
+  constructor(
+    client: APIClient,
+    response: APIResponse<ResponsesPageResponse<Item>>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, options);
+
+    this.responses = response.responses;
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.responses;
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  /**
+   * This page represents a response that isn't actually paginated at the API level
+   * so there will never be any next page params.
+   */
+  nextPageParams(): null {
+    return null;
+  }
+
+  nextPageInfo(): null {
+    return null;
+  }
+}
+
+export interface IndividualsPageResponse {
+  /**
+   * The array of employees.
+   */
+  individuals: Array<HRIS.IndividualInDirectory>;
+
+  paging: HRIS.Paging;
+}
+
+export interface IndividualsPageParams {
+  /**
+   * Number of employees to return (defaults to all)
+   */
+  limit?: number;
+
+  /**
+   * Index to start from (defaults to 0)
+   */
+  offset?: number;
+}
+
+export class IndividualsPage
+  extends AbstractPage<HRIS.IndividualInDirectory>
+  implements IndividualsPageResponse
+{
+  paging: HRIS.Paging;
+  /** The array of employees. */
+  individuals: Array<HRIS.IndividualInDirectory>;
+
+  constructor(
+    client: APIClient,
+    response: APIResponse<IndividualsPageResponse>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, options);
+
+    this.paging = response.paging;
+    this.individuals = response.individuals;
+  }
+
+  getPaginatedItems(): HRIS.IndividualInDirectory[] {
+    return this.individuals;
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  nextPageParams(): Partial<IndividualsPageParams> | null {
+    const info = this.nextPageInfo();
+    if (!info) return null;
+    if ('params' in info) return info.params;
+    const params = Object.fromEntries(info.url.searchParams);
+    if (!Object.keys(params).length) return null;
+    return params;
+  }
+
+  nextPageInfo(): PageInfo | null {
+    const offset = this.paging.offset;
+    if (!offset) return null;
+
+    const length = this.individuals.length;
+    const currentCount = offset + length;
+
+    const totalCount = this.paging.count;
+    if (!totalCount) return null;
+
+    if (currentCount < totalCount) {
+      return { params: { offset: currentCount } };
+    }
+
+    return null;
+  }
+}
+
+export interface CandidatesPageResponse {
+  candidates: Array<ATS.Candidate>;
+
+  paging: HRIS.Paging;
+}
+
+export interface CandidatesPageParams {
+  /**
+   * Number of candidates to return (defaults to all)
+   */
+  limit?: number;
+
+  /**
+   * Index to start from (defaults to 0)
+   */
+  offset?: number;
+}
+
+export class CandidatesPage extends AbstractPage<ATS.Candidate> implements CandidatesPageResponse {
+  paging: HRIS.Paging;
+
+  candidates: Array<ATS.Candidate>;
+
+  constructor(
+    client: APIClient,
+    response: APIResponse<CandidatesPageResponse>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, options);
+
+    this.paging = response.paging;
+    this.candidates = response.candidates;
+  }
+
+  getPaginatedItems(): ATS.Candidate[] {
+    return this.candidates;
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  nextPageParams(): Partial<CandidatesPageParams> | null {
+    const info = this.nextPageInfo();
+    if (!info) return null;
+    if ('params' in info) return info.params;
+    const params = Object.fromEntries(info.url.searchParams);
+    if (!Object.keys(params).length) return null;
+    return params;
+  }
+
+  nextPageInfo(): PageInfo | null {
+    const offset = this.paging.offset;
+    if (!offset) return null;
+
+    const length = this.candidates.length;
+    const currentCount = offset + length;
+
+    const totalCount = this.paging.count;
+    if (!totalCount) return null;
+
+    if (currentCount < totalCount) {
+      return { params: { offset: currentCount } };
+    }
+
+    return null;
+  }
+}
+
+export interface ApplicationsPageResponse {
+  applications: Array<ATS.Application>;
+
+  paging: HRIS.Paging;
+}
+
+export interface ApplicationsPageParams {
+  /**
+   * Number of applications to return (defaults to all)
+   */
+  limit?: number;
+
+  /**
+   * Index to start from (defaults to 0)
+   */
+  offset?: number;
+}
+
+export class ApplicationsPage extends AbstractPage<ATS.Application> implements ApplicationsPageResponse {
+  paging: HRIS.Paging;
+
+  applications: Array<ATS.Application>;
+
+  constructor(
+    client: APIClient,
+    response: APIResponse<ApplicationsPageResponse>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, options);
+
+    this.paging = response.paging;
+    this.applications = response.applications;
+  }
+
+  getPaginatedItems(): ATS.Application[] {
+    return this.applications;
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  nextPageParams(): Partial<ApplicationsPageParams> | null {
+    const info = this.nextPageInfo();
+    if (!info) return null;
+    if ('params' in info) return info.params;
+    const params = Object.fromEntries(info.url.searchParams);
+    if (!Object.keys(params).length) return null;
+    return params;
+  }
+
+  nextPageInfo(): PageInfo | null {
+    const offset = this.paging.offset;
+    if (!offset) return null;
+
+    const length = this.applications.length;
+    const currentCount = offset + length;
+
+    const totalCount = this.paging.count;
+    if (!totalCount) return null;
+
+    if (currentCount < totalCount) {
+      return { params: { offset: currentCount } };
+    }
+
+    return null;
+  }
+}
+
+export interface JobsPageResponse {
+  jobs: Array<ATS.Job>;
+
+  paging: HRIS.Paging;
+}
+
+export interface JobsPageParams {
+  /**
+   * Number of jobs to return (defaults to all)
+   */
+  limit?: number;
+
+  /**
+   * Index to start from (defaults to 0)
+   */
+  offset?: number;
+}
+
+export class JobsPage extends AbstractPage<ATS.Job> implements JobsPageResponse {
+  paging: HRIS.Paging;
+
+  jobs: Array<ATS.Job>;
+
+  constructor(client: APIClient, response: APIResponse<JobsPageResponse>, options: FinalRequestOptions) {
+    super(client, response, options);
+
+    this.paging = response.paging;
+    this.jobs = response.jobs;
+  }
+
+  getPaginatedItems(): ATS.Job[] {
+    return this.jobs;
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  nextPageParams(): Partial<JobsPageParams> | null {
+    const info = this.nextPageInfo();
+    if (!info) return null;
+    if ('params' in info) return info.params;
+    const params = Object.fromEntries(info.url.searchParams);
+    if (!Object.keys(params).length) return null;
+    return params;
+  }
+
+  nextPageInfo(): PageInfo | null {
+    const offset = this.paging.offset;
+    if (!offset) return null;
+
+    const length = this.jobs.length;
+    const currentCount = offset + length;
+
+    const totalCount = this.paging.count;
+    if (!totalCount) return null;
+
+    if (currentCount < totalCount) {
+      return { params: { offset: currentCount } };
+    }
+
+    return null;
+  }
+}
+
+export interface OffersPageResponse {
+  offers: Array<ATS.Offer>;
+
+  paging: HRIS.Paging;
+}
+
+export interface OffersPageParams {
+  /**
+   * Number of offers to return (defaults to all)
+   */
+  limit?: number;
+
+  /**
+   * Index to start from (defaults to 0)
+   */
+  offset?: number;
+}
+
+export class OffersPage extends AbstractPage<ATS.Offer> implements OffersPageResponse {
+  paging: HRIS.Paging;
+
+  offers: Array<ATS.Offer>;
+
+  constructor(client: APIClient, response: APIResponse<OffersPageResponse>, options: FinalRequestOptions) {
+    super(client, response, options);
+
+    this.paging = response.paging;
+    this.offers = response.offers;
+  }
+
+  getPaginatedItems(): ATS.Offer[] {
+    return this.offers;
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  nextPageParams(): Partial<OffersPageParams> | null {
+    const info = this.nextPageInfo();
+    if (!info) return null;
+    if ('params' in info) return info.params;
+    const params = Object.fromEntries(info.url.searchParams);
+    if (!Object.keys(params).length) return null;
+    return params;
+  }
+
+  nextPageInfo(): PageInfo | null {
+    const offset = this.paging.offset;
+    if (!offset) return null;
+
+    const length = this.offers.length;
+    const currentCount = offset + length;
+
+    const totalCount = this.paging.count;
+    if (!totalCount) return null;
+
+    if (currentCount < totalCount) {
+      return { params: { offset: currentCount } };
+    }
+
+    return null;
+  }
+}

package/release-please-config.json

@@ -0,0 +1,12 @@
+{
+  "include-v-in-tag": true,
+  "bump-minor-pre-major": true,
+  "bump-patch-for-minor-pre-major": true,
+  "pull-request-header": "Automated Release PR",
+  "packages": {
+    ".": {}
+  },
+  "$schema": "https://raw.githubusercontent.com/stainless-api/release-please/main/schemas/config.json",
+  "release-type": "node",
+  "extra-files": ["version.ts"]
+}

package/resource.ts

@@ -0,0 +1,24 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import type { Finch } from './index';
+
+export class APIResource {
+  protected client: Finch;
+  constructor(client: Finch) {
+    this.client = client;
+
+    this.get = client.get.bind(client);
+    this.post = client.post.bind(client);
+    this.patch = client.patch.bind(client);
+    this.put = client.put.bind(client);
+    this.delete = client.delete.bind(client);
+    this.getAPIList = client.getAPIList.bind(client);
+  }
+
+  protected get: Finch['get'];
+  protected post: Finch['post'];
+  protected patch: Finch['patch'];
+  protected put: Finch['put'];
+  protected delete: Finch['delete'];
+  protected getAPIList: Finch['getAPIList'];
+}

package/resources/account.ts

@@ -0,0 +1,63 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import * as Core from '~/core';
+import { APIResource } from '~/resource';
+
+export class Account extends APIResource {
+  /**
+   * Disconnect an employer from your application and invalidate all `access_token`s
+   * associated with the employer. We require applications to implement the
+   * Disconnect endpoint for billing and security purposes.
+   */
+  disconnect(options?: Core.RequestOptions): Promise<Core.APIResponse<DisconnectResponse>> {
+    return this.post('/disconnect', options);
+  }
+
+  /**
+   * Read account information associated with an `access_token`
+   */
+  introspect(options?: Core.RequestOptions): Promise<Core.APIResponse<Introspection>> {
+    return this.get('/introspect', options);
+  }
+}
+
+export interface DisconnectResponse {
+  /**
+   * If the request is successful, Finch will return “success” (HTTP 200 status).
+   */
+  status: string;
+}
+
+export interface Introspection {
+  /**
+   * The client id of the application associated with the `access_token`.
+   */
+  client_id: string;
+
+  /**
+   * The Finch uuid of the company associated with the `access_token`.
+   */
+  company_id: string;
+
+  /**
+   * Whether the connection associated with the `access_token` uses the Assisted
+   * Connect Flow. (`true` if using Assisted Connect, `false` if connection is
+   * automated)
+   */
+  manual: boolean;
+
+  /**
+   * The payroll provider associated with the `access_token`.
+   */
+  payroll_provider_id: string;
+
+  /**
+   * An array of the authorized products associated with the `access_token`.
+   */
+  products: Array<string>;
+
+  /**
+   * The account username used for login associated with the `access_token`.
+   */
+  username: string;
+}

package/resources/ats/applications.ts

@@ -0,0 +1,55 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import * as Core from '~/core';
+import { APIResource } from '~/resource';
+import { isRequestOptions } from '~/core';
+import * as Stages from '~/resources/ats/stages';
+import { ApplicationsPage, ApplicationsPageParams } from '~/pagination';
+
+export class Applications extends APIResource {
+  /**
+   * Gets an application from an organization.
+   */
+  retrieve(applicationId: string, options?: Core.RequestOptions): Promise<Core.APIResponse<Application>> {
+    return this.get(`/ats/applications/${applicationId}`, options);
+  }
+
+  /**
+   * Gets all of an organization's applications.
+   */
+  list(query?: ApplicationListParams, options?: Core.RequestOptions): Core.PagePromise<ApplicationsPage>;
+  list(options?: Core.RequestOptions): Core.PagePromise<ApplicationsPage>;
+  list(
+    query: ApplicationListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<ApplicationsPage> {
+    if (isRequestOptions(query)) {
+      return this.list({}, query);
+    }
+    return this.getAPIList('/ats/applications', ApplicationsPage, { query, ...options });
+  }
+}
+
+export interface Application {
+  candidate_id: string;
+
+  id: string;
+
+  job_id: string;
+
+  offer_id: string | null;
+
+  rejected_at: string | null;
+
+  rejected_reason: Application.RejectedReason | null;
+
+  stage: Stages.Stage | null;
+}
+
+export namespace Application {
+  export interface RejectedReason {
+    text?: string | null;
+  }
+}
+
+export interface ApplicationListParams extends ApplicationsPageParams {}

package/resources/ats/ats.ts

@@ -0,0 +1,16 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import { APIResource } from '~/resource';
+import { Candidates } from './candidates';
+import { Applications } from './applications';
+import { Stages } from './stages';
+import { Jobs } from './jobs';
+import { Offers } from './offers';
+
+export class ATS extends APIResource {
+  candidates: Candidates = new Candidates(this.client);
+  applications: Applications = new Applications(this.client);
+  stages: Stages = new Stages(this.client);
+  jobs: Jobs = new Jobs(this.client);
+  offers: Offers = new Offers(this.client);
+}

package/resources/ats/candidates.ts

@@ -0,0 +1,74 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import * as Core from '~/core';
+import { APIResource } from '~/resource';
+import { isRequestOptions } from '~/core';
+import { CandidatesPage, CandidatesPageParams } from '~/pagination';
+
+export class Candidates extends APIResource {
+  /**
+   * Gets a candidate from an organization. A candidate represents an individual
+   * associated with one or more applications.
+   */
+  retrieve(candidateId: string, options?: Core.RequestOptions): Promise<Core.APIResponse<Candidate>> {
+    return this.get(`/ats/candidates/${candidateId}`, options);
+  }
+
+  /**
+   * Gets all of an organization's candidates. A candidate represents an individual
+   * associated with one or more applications.
+   */
+  list(query?: CandidateListParams, options?: Core.RequestOptions): Core.PagePromise<CandidatesPage>;
+  list(options?: Core.RequestOptions): Core.PagePromise<CandidatesPage>;
+  list(
+    query: CandidateListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<CandidatesPage> {
+    if (isRequestOptions(query)) {
+      return this.list({}, query);
+    }
+    return this.getAPIList('/ats/candidates', CandidatesPage, { query, ...options });
+  }
+}
+
+/**
+ * A candidate represents an individual associated with one or more applications.
+ */
+export interface Candidate {
+  /**
+   * Array of Finch uuids corresponding to `application`s for this individual
+   */
+  application_ids: Array<string>;
+
+  created_at: string;
+
+  emails: Array<Candidate.Emails>;
+
+  first_name: string | null;
+
+  full_name: string | null;
+
+  id: string;
+
+  last_activity_at: string;
+
+  last_name: string | null;
+
+  phone_numbers: Array<Candidate.PhoneNumbers>;
+}
+
+export namespace Candidate {
+  export interface Emails {
+    data?: string | null;
+
+    type?: string | null;
+  }
+
+  export interface PhoneNumbers {
+    data?: string | null;
+
+    type?: string | null;
+  }
+}
+
+export interface CandidateListParams extends CandidatesPageParams {}

package/resources/ats/index.ts

@@ -0,0 +1,7 @@
+// File generated from our OpenAPI spec by Stainless.
+
+export { Application, ApplicationListParams } from './applications';
+export { Candidate, CandidateListParams } from './candidates';
+export { Job, JobListParams } from './jobs';
+export { Offer, OfferListParams } from './offers';
+export { Stage, StagesSinglePage } from './stages';