@babelforce/manager-sdk 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to `@babelforce/manager-sdk` are documented here. This project adheres to
+[Semantic Versioning](https://semver.org/).
+
+## 0.2.0
+
+- Add the `tasks` resource (v3 task automations): `create`, `createFromTemplate`, `list` /
+  `listAll` (auto-paginated), `get`, `update`, `interrupt`, plus `tasks.schedules`
+  (`list` / `create` / `get` / `delete`).
+
+## 0.1.0
+
+Initial release.
+
+- `ManagerClient` facade with one-shot auth configuration.
+- Auth modes: API key (`X-Auth-Access-Id` / `X-Auth-Access-Token`), bearer, and OAuth2 password
+  grant with transparent token refresh.
+- `users` resource: auto-paginated `list()` / `listAll()`, `create`, `enable`, `disable`, `delete`.
+- Typed `ManagerApiError` for non-2xx responses.

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and do
+          not modify the License. You may add Your own attribution notices
+          within Derivative Works that You distribute, alongside or as an
+          addendum to the NOTICE text from the Work, provided that such
+          additional attribution notices cannot be construed as modifying
+          the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 babelforce GmbH
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,6 @@
+babelforce manager SDK
+Copyright 2026 babelforce GmbH
+
+This product includes software developed at babelforce GmbH.
+
+Licensed under the Apache License, Version 2.0 (see LICENSE).

package/README.md

@@ -0,0 +1,59 @@
+# @babelforce/manager-sdk
+
+TypeScript SDK for the babelforce **manager APIs** — auth, user & agent management, call
+reporting, metrics, and task automations.
+
+One client, configured once, exposes resource namespaces over the API. Authentication, paging, and
+error handling are handled for you.
+
+📖 **Docs:** https://babelforce.github.io/manager-sdk/
+
+## Install
+
+```bash
+npm install @babelforce/manager-sdk
+```
+
+ESM, ships with types. Node 18+ (for global `fetch`).
+
+## Usage
+
+```ts
+import { ManagerClient } from "@babelforce/manager-sdk";
+
+const mgr = await ManagerClient.connect({
+  environment: "production",
+  auth: { kind: "apiKey", accessId, accessToken }, // or { kind: "password", user, pass }
+});
+
+// list users (auto-paginated)
+for await (const user of mgr.users.list()) {
+  console.log(user.email);
+}
+
+await mgr.users.create({ email: "new.user@acme.com", roles: [] });
+await mgr.users.enable(["new.user@acme.com"]);
+```
+
+### Authentication
+
+- `{ kind: "apiKey", accessId, accessToken }` — sends `X-Auth-Access-Id` / `X-Auth-Access-Token`.
+- `{ kind: "bearer", token }` — a token you already hold.
+- `{ kind: "password", user, pass }` — OAuth2 password grant with transparent refresh.
+
+### Errors
+
+Non-2xx responses throw a `ManagerApiError` with `status`, `code`, and `body`.
+
+### Custom host
+
+```ts
+await ManagerClient.connect({
+  baseUrl: "https://acme.babelforce.com",
+  auth: { kind: "bearer", token },
+});
+```
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,395 @@
+import { Client } from '@hey-api/client-fetch';
+
+/**
+ * How the SDK authenticates against the manager API.
+ *
+ * - `apiKey` — the primary server-to-server mode; sends the `X-Auth-Access-Id` /
+ *   `X-Auth-Access-Token` header pair on every request.
+ * - `bearer` — a bearer token you already obtained.
+ * - `password` — OAuth2 password grant against `/oauth/token`; the token is fetched lazily on the
+ *   first request and refreshed transparently before it expires. Convenience for interactive/dev use.
+ */
+type Auth = {
+    kind: 'apiKey';
+    accessId: string;
+    accessToken: string;
+} | {
+    kind: 'bearer';
+    token: string;
+} | {
+    kind: 'password';
+    user: string;
+    pass: string;
+    clientId?: string;
+};
+interface TokenResponse {
+    access_token: string;
+    expires_in?: number;
+    token_type?: string;
+}
+/**
+ * Exchange a username/password for a bearer token via the manager OAuth2 password grant
+ * (`POST {baseUrl}/oauth/token`). Exposed for callers who want to manage tokens themselves.
+ */
+declare function passwordGrant(opts: {
+    baseUrl: string;
+    user: string;
+    pass: string;
+    clientId?: string;
+    fetch?: typeof fetch;
+}): Promise<TokenResponse>;
+
+/**
+ * Named babelforce environment the SDK can target. Use the `baseUrl` option to target other
+ * (e.g. per-customer or non-production) hosts.
+ */
+type Environment = 'production';
+
+/**
+ * A role associated with the Account
+ */
+type AccountRole = 'manager' | 'owner' | 'reporter' | 'user' | 'agent' | 'supervisor' | 'sales' | 'router' | 'scheduler';
+type CreateManagedUserRequest = {
+    password?: string;
+    email: string;
+    activated?: boolean;
+    /**
+     * A List of Roles which are associated with the current User
+     */
+    roles: Array<AccountRole>;
+};
+type ManagedUser = {
+    /**
+     * The unique Identifier (UUID) of the object
+     */
+    id: string;
+    email: string;
+    enabled?: boolean;
+    /**
+     * A List of Roles which are associated with the current User
+     */
+    roles: Array<AccountRole>;
+};
+type ManagedUserItemResponse = {
+    item: ManagedUser;
+    /**
+     * Whether the Request was successful or not
+     */
+    success: boolean;
+};
+
+interface ListUsersQuery {
+    /** Filter by email address. */
+    email?: string;
+}
+/** User management — `/api/v2/users`. */
+declare class UsersResource {
+    private readonly client;
+    constructor(client: Client);
+    /**
+     * List users, auto-paginating across pages.
+     *
+     * ```ts
+     * for await (const user of mgr.users.list()) console.log(user.email);
+     * ```
+     */
+    list(query?: ListUsersQuery): AsyncGenerator<ManagedUser>;
+    /** Collect every user into an array (convenience over {@link list}). */
+    listAll(query?: ListUsersQuery): Promise<ManagedUser[]>;
+    /** Create a user. */
+    create(user: CreateManagedUserRequest): Promise<ManagedUserItemResponse>;
+    /** Enable the given users (by email). */
+    enable(emails: string[]): Promise<void>;
+    /** Disable the given users (by email). */
+    disable(emails: string[]): Promise<void>;
+    /** Delete the given users (by email). */
+    delete(emails: string[]): Promise<void>;
+}
+
+/**
+ * a unique identifier
+ */
+type Id = string;
+/**
+ * a unique identifier
+ */
+type Uuid = string;
+/**
+ * Timestamp in milliseconds UTC
+ */
+type TimestampInMsUtc = number;
+/**
+ * Milliseconds
+ */
+type Milliseconds = number;
+type TaskType = string;
+type TaskCompletionSettings = {
+    /**
+     * True = tasks are not waiting for agent interactions when pending. False = task may wait forever in pending state until an agent or the system completes the task.
+     */
+    autoComplete?: boolean;
+};
+/**
+ * Time in milliseconds the agent has to accept a task before it is auto rejected.
+ */
+type AcceptTimeout = number;
+/**
+ * Time in milliseconds the agent has to complete a task before it is auto canceled.
+ */
+type CompleteTimeout = number;
+/**
+ * Time in milliseconds the task is delayed after rescheduling.
+ */
+type RescheduleDelay = number;
+/**
+ * A time in milliseconds after task scheduling, if it is reached the task will be canceled
+ */
+type ExpireIn = number;
+type SelectionEngine = 'legacy' | 'acd';
+type TaskSelectionSettings = {
+    /**
+     * True = agent selection is enabled False = No agent selection will be attempted
+     */
+    enable?: boolean;
+    /**
+     * True = the selected agent has to accept the task before it will be assigned to him. False = the agent will get the task forceably assigned
+     */
+    auto_accept?: boolean;
+    /**
+     * 0 = lowest priority ... 256 = higher priority ... max integer = highest priority
+     */
+    priority?: number;
+    expire_in?: ExpireIn;
+    accept_timeout?: AcceptTimeout;
+    complete_timeout?: CompleteTimeout;
+    reschedule_delay?: RescheduleDelay;
+    selection_engine?: SelectionEngine;
+    legacy_settings?: TaskSelectionLegacySettings;
+    acd_settings?: TaskSelectionAcdSettings;
+};
+type TaskSelectionLegacySettings = {
+    line_status?: string;
+    reachable_by_phone?: boolean;
+    max?: number;
+    call_id?: string;
+    exclusive?: boolean;
+};
+type TaskSelectionAcdSettings = {
+    line_status?: string;
+    reachable_by_phone?: boolean;
+    priority?: number;
+    timeout?: number;
+};
+type ActionSetting = {
+    transitions: TaskStateEvents;
+    /**
+     * When set to true, action events on_* will run asynchronously with further state transitions.action will not block
+     */
+    async?: boolean;
+    timeout?: Milliseconds;
+};
+type TaskStateEvents = 'on_scheduled' | 'on_rescheduled' | 'on_selecting' | 'on_accepted' | 'on_rejected' | 'on_assigned' | 'on_processing' | 'on_pending' | 'on_completed' | 'on_canceled' | 'on_failed';
+type TaskState = 'Scheduled' | 'Rescheduled' | 'Selecting' | 'Accepted' | 'Rejected' | 'Assigned' | 'Processing' | 'Pending' | 'Completed' | 'Canceled' | 'Failed';
+type Actions = {
+    on_scheduled?: Array<Action>;
+    on_rescheduled?: Array<Action>;
+    on_selecting?: Array<Action>;
+    on_accepted?: Array<Action>;
+    on_rejected?: Array<Action>;
+    on_assigned?: Array<Action>;
+    on_processing?: Array<Action>;
+    on_pending?: Array<Action>;
+    on_completed?: Array<Action>;
+    on_canceled?: Array<Action>;
+    on_failed?: Array<Action>;
+    settings?: Array<ActionSetting>;
+};
+type Action = {
+    action_type: string;
+    [key: string]: unknown | string;
+};
+type Body = unknown;
+/**
+ * true - an error occured during task execution, false - no errors during execution
+ */
+type _Error = boolean;
+/**
+ * defines when the task will be scheduled for execution. now - as soon as possible at 1654075565950 - at the given timestamp in 1w 3d 5h 10min 5sec  - in 1 week 3 days 5 hours 10 minutes and 5 seconds
+ */
+type ScheduledAt = string;
+type SubmitTask = {
+    id?: Uuid;
+    queue_id?: Id;
+    type?: TaskType;
+    body?: Body;
+    actions?: Actions;
+    task_completion?: TaskCompletionSettings;
+    selection_settings?: TaskSelectionSettings;
+    scheduled_at?: ScheduledAt;
+};
+type BaseTask = {
+    id?: Uuid;
+    queue_id?: Id;
+    session_id?: Id;
+    customer_id?: Id;
+    agent_id?: Id;
+    created_at?: TimestampInMsUtc;
+    body: Body;
+    type?: TaskType;
+    state?: TaskState;
+    actions?: Actions;
+    task_completion?: TaskCompletionSettings;
+    selection_settings?: TaskSelectionSettings;
+    scheduled_at?: ScheduledAt;
+};
+type Task = BaseTask & {
+    has_error?: _Error;
+};
+type InterruptionTargetStates = 'Completed' | 'Canceled' | 'Failed';
+type ManualActionRequest = {
+    reason: string;
+};
+type TemplateOverride = {
+    [key: string]: unknown;
+};
+type SubmitTaskBody = SubmitTask;
+type UpdateTaskBody = Task;
+type ManualAction = ManualActionRequest;
+type TaskTemplateOverrides = TemplateOverride;
+
+type PageMetadata = {
+    page?: number;
+    per_page?: number;
+    page_count?: number;
+    total_count?: number;
+};
+type TemplateStyle = 'flat' | 'hierarchy';
+/**
+ * A valid IANA timezone for examples see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones. Note: Be careful when setting fire times between the hours of the morning when “daylight savings” changes occur in your locale (for US locales, this would typically be the hour before and after 2:00 AM - because the time shift can cause a skip or a repeat depending on whether the time moves back or jumps forward. You may find this wikipedia entry helpful in determining the specifics to your locale https://secure.wikimedia.org/wikipedia/en/wiki/Daylight_saving_time_around_the_world
+ */
+type Timezone = string;
+type SubmitTaskSchedule = {
+    cron: string;
+    name: string;
+    task: {
+        [key: string]: unknown;
+    };
+    template_id?: string;
+    template_style?: TemplateStyle;
+    timezone?: Timezone;
+};
+type TaskSchedule = {
+    cron: string;
+    name?: string;
+    task?: {
+        [key: string]: unknown;
+    };
+    template_id?: string;
+    template_style?: TemplateStyle;
+    timezone?: Timezone;
+};
+type TaskScheduleList = {
+    _metadata?: PageMetadata;
+    records?: Array<TaskSchedule>;
+};
+type SubmitTaskScheduleBody = SubmitTaskSchedule;
+
+interface ListTasksQuery {
+    /** Server-side filter expression. */
+    filter?: string;
+    /** Page size (1..100); defaults to 100. */
+    pageSize?: number;
+}
+/** Task automations — `/api/v3/tasks`. */
+declare class TasksResource {
+    private readonly client;
+    /** Recurring task schedules — `/api/v3/tasks/schedules`. */
+    readonly schedules: TaskSchedulesResource;
+    constructor(client: Client);
+    /**
+     * List tasks, auto-paginating across pages.
+     *
+     * ```ts
+     * for await (const task of mgr.tasks.list({ filter: "state==active" })) { … }
+     * ```
+     */
+    list(query?: ListTasksQuery): AsyncGenerator<Task>;
+    /** Collect every task into an array. */
+    listAll(query?: ListTasksQuery): Promise<Task[]>;
+    /** Create a task. */
+    create(body: SubmitTaskBody): Promise<Task>;
+    /** Create a task from a template, with overrides. */
+    createFromTemplate(template: string, overrides: TaskTemplateOverrides): Promise<Task>;
+    /** Get a task by id. */
+    get(taskId: string): Promise<Task>;
+    /** Update a task. */
+    update(taskId: string, body: UpdateTaskBody): Promise<Task>;
+    /** Manager-interrupt a task, transitioning it to the given target state. */
+    interrupt(taskId: string, interruptTo: InterruptionTargetStates, action?: ManualAction): Promise<void>;
+}
+/** Recurring task schedules — `/api/v3/tasks/schedules`. */
+declare class TaskSchedulesResource {
+    private readonly client;
+    constructor(client: Client);
+    /** List task schedules. */
+    list(): Promise<TaskScheduleList>;
+    /** Create a task schedule. */
+    create(schedule: SubmitTaskScheduleBody): Promise<void>;
+    /** Get a task schedule by name. */
+    get(taskScheduleName: string): Promise<TaskSchedule>;
+    /** Delete a task schedule by name. */
+    delete(taskScheduleName: string): Promise<void>;
+}
+
+interface ManagerClientOptions {
+    /** Named environment whose host to use. Defaults to `production`. Ignored if `baseUrl` is set. */
+    environment?: Environment;
+    /** Explicit base URL override (e.g. a per-customer host). */
+    baseUrl?: string;
+    /** How to authenticate. */
+    auth: Auth;
+    /** Extra headers added to every request. */
+    headers?: Record<string, string>;
+    /** Custom fetch implementation (testing, proxies, retries). */
+    fetch?: typeof fetch;
+}
+/**
+ * The babelforce manager SDK client.
+ *
+ * One client, configured once, exposes resource namespaces over the manager API. The underlying
+ * generated clients and the v2/v3 host details are hidden behind this facade.
+ *
+ * ```ts
+ * const mgr = await ManagerClient.connect({
+ *   environment: "production",
+ *   auth: { kind: "apiKey", accessId, accessToken },
+ * });
+ * for await (const u of mgr.users.list()) console.log(u.email);
+ * ```
+ */
+declare class ManagerClient {
+    /** The underlying fetch client (escape hatch for advanced use). */
+    readonly client: Client;
+    /** User management — `/api/v2/users`. */
+    readonly users: UsersResource;
+    /** Task automations — `/api/v3/tasks`. */
+    readonly tasks: TasksResource;
+    private constructor();
+    /** Create and configure a client. */
+    static connect(options: ManagerClientOptions): Promise<ManagerClient>;
+}
+
+/** Error thrown by the SDK when the manager API returns a non-2xx response. */
+declare class ManagerApiError extends Error {
+    /** HTTP status code. */
+    readonly status: number;
+    /** API error code, when the response body carries one. */
+    readonly code?: string;
+    /** The parsed response body (object, string, or undefined). */
+    readonly body: unknown;
+    constructor(status: number, message: string, body: unknown, code?: string);
+    /** Build a {@link ManagerApiError} from a fetch Response and its (already-parsed) body. */
+    static from(response: Response, body: unknown): ManagerApiError;
+}
+
+export { type AccountRole, type Auth, type CreateManagedUserRequest, type Environment, type InterruptionTargetStates, type ListTasksQuery, type ListUsersQuery, type ManagedUser, type ManagedUserItemResponse, ManagerApiError, ManagerClient, type ManagerClientOptions, type SubmitTaskBody, type SubmitTaskScheduleBody, type Task, type TaskSchedule, TaskSchedulesResource, type TaskTemplateOverrides, TasksResource, type TokenResponse, type UpdateTaskBody, UsersResource, passwordGrant };

package/dist/index.js

@@ -0,0 +1,592 @@
+import { createClient, createConfig } from '@hey-api/client-fetch';
+
+// src/client.ts
+
+// src/auth.ts
+async function passwordGrant(opts) {
+  const base = opts.baseUrl.replace(/\/+$/, "");
+  const body = new URLSearchParams({
+    grant_type: "password",
+    username: opts.user,
+    password: opts.pass,
+    client_id: opts.clientId ?? "manager"
+  });
+  const doFetch = opts.fetch ?? fetch;
+  const resp = await doFetch(`${base}/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  const json = await resp.json().catch(() => ({}));
+  if (!resp.ok || !json.access_token) {
+    throw new Error(`password grant failed (status ${resp.status})`);
+  }
+  return json;
+}
+var TokenManager = class {
+  constructor(baseUrl, creds, fetchImpl) {
+    this.baseUrl = baseUrl;
+    this.creds = creds;
+    this.fetchImpl = fetchImpl;
+  }
+  baseUrl;
+  creds;
+  fetchImpl;
+  token;
+  expiresAt = 0;
+  async get() {
+    if (this.token && Date.now() < this.expiresAt - 3e4) return this.token;
+    const tok = await passwordGrant({ baseUrl: this.baseUrl, ...this.creds, fetch: this.fetchImpl });
+    this.token = tok.access_token;
+    this.expiresAt = Date.now() + (tok.expires_in ? tok.expires_in * 1e3 : 36e5);
+    return this.token;
+  }
+};
+function buildAuthConfig(auth, baseUrl, fetchImpl) {
+  switch (auth.kind) {
+    case "apiKey":
+      return {
+        headers: {
+          "X-Auth-Access-Id": auth.accessId,
+          "X-Auth-Access-Token": auth.accessToken
+        }
+      };
+    case "bearer":
+      return { auth: (scheme) => scheme.scheme === "bearer" ? auth.token : void 0 };
+    case "password": {
+      const tokens = new TokenManager(baseUrl, auth, fetchImpl);
+      return { auth: (scheme) => scheme.scheme === "bearer" ? tokens.get() : void 0 };
+    }
+  }
+}
+
+// src/environments.ts
+var HOSTS = {
+  production: "https://services.babelforce.com"
+};
+function resolveBaseUrl(environment) {
+  const host = HOSTS[environment];
+  if (!host) throw new Error(`unknown environment: ${String(environment)}`);
+  return host;
+}
+var client = createClient(createConfig({
+  baseUrl: "https://services.babelforce.com"
+}));
+
+// src/gen/manager/sdk.gen.ts
+var listUsers = (options) => {
+  return (options?.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        name: "X-Auth-Access-Id",
+        type: "apiKey"
+      },
+      {
+        name: "X-Auth-Access-Token",
+        type: "apiKey"
+      }
+    ],
+    url: "/api/v2/users",
+    ...options
+  });
+};
+var createUser = (options) => {
+  return (options?.client ?? client).post({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        name: "X-Auth-Access-Id",
+        type: "apiKey"
+      },
+      {
+        name: "X-Auth-Access-Token",
+        type: "apiKey"
+      }
+    ],
+    url: "/api/v2/users",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+var deleteUsers = (options) => {
+  return (options?.client ?? client).post({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        name: "X-Auth-Access-Id",
+        type: "apiKey"
+      },
+      {
+        name: "X-Auth-Access-Token",
+        type: "apiKey"
+      }
+    ],
+    url: "/api/v2/users/delete",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+var disableUsers = (options) => {
+  return (options?.client ?? client).post({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        name: "X-Auth-Access-Id",
+        type: "apiKey"
+      },
+      {
+        name: "X-Auth-Access-Token",
+        type: "apiKey"
+      }
+    ],
+    url: "/api/v2/users/disable",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+var enableUsers = (options) => {
+  return (options?.client ?? client).post({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        name: "X-Auth-Access-Id",
+        type: "apiKey"
+      },
+      {
+        name: "X-Auth-Access-Token",
+        type: "apiKey"
+      }
+    ],
+    url: "/api/v2/users/enable",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+
+// src/errors.ts
+var ManagerApiError = class _ManagerApiError extends Error {
+  /** HTTP status code. */
+  status;
+  /** API error code, when the response body carries one. */
+  code;
+  /** The parsed response body (object, string, or undefined). */
+  body;
+  constructor(status, message, body, code) {
+    super(message);
+    this.name = "ManagerApiError";
+    this.status = status;
+    this.body = body;
+    this.code = code;
+  }
+  /** Build a {@link ManagerApiError} from a fetch Response and its (already-parsed) body. */
+  static from(response, body) {
+    let code;
+    let message = `${response.status} ${response.statusText}`.trim();
+    if (body && typeof body === "object") {
+      const b = body;
+      if (typeof b.code === "string") code = b.code;
+      const detail = b.message ?? b.error ?? b.detail;
+      if (typeof detail === "string" && detail.length > 0) message = detail;
+    } else if (typeof body === "string" && body.length > 0) {
+      message = body;
+    }
+    return new _ManagerApiError(response.status, message, body, code);
+  }
+};
+
+// src/http.ts
+async function unwrap(result) {
+  const { data, error, response } = await result;
+  if (!response.ok) throw ManagerApiError.from(response, error ?? data);
+  return data;
+}
+async function* paginate(fetchPage) {
+  let page = 1;
+  for (; ; ) {
+    const { items, pagination } = await fetchPage(page);
+    for (const item of items) yield item;
+    if (!pagination || items.length === 0 || pagination.current >= pagination.pages) return;
+    page = pagination.current + 1;
+  }
+}
+
+// src/resources/users.ts
+var UsersResource = class {
+  constructor(client4) {
+    this.client = client4;
+  }
+  client;
+  /**
+   * List users, auto-paginating across pages.
+   *
+   * ```ts
+   * for await (const user of mgr.users.list()) console.log(user.email);
+   * ```
+   */
+  list(query = {}) {
+    const client4 = this.client;
+    return paginate(async () => {
+      const page = await unwrap(listUsers({ client: client4, query }));
+      return { items: page.items, pagination: page.pagination };
+    });
+  }
+  /** Collect every user into an array (convenience over {@link list}). */
+  async listAll(query = {}) {
+    const users = [];
+    for await (const user of this.list(query)) users.push(user);
+    return users;
+  }
+  /** Create a user. */
+  async create(user) {
+    return unwrap(createUser({ client: this.client, body: user }));
+  }
+  /** Enable the given users (by email). */
+  async enable(emails) {
+    await unwrap(enableUsers({ client: this.client, body: emailList(emails) }));
+  }
+  /** Disable the given users (by email). */
+  async disable(emails) {
+    await unwrap(disableUsers({ client: this.client, body: emailList(emails) }));
+  }
+  /** Delete the given users (by email). */
+  async delete(emails) {
+    await unwrap(deleteUsers({ client: this.client, body: emailList(emails) }));
+  }
+};
+function emailList(emails) {
+  return { emails };
+}
+var client2 = createClient(createConfig({
+  baseUrl: "https://services.babelforce.com"
+}));
+
+// src/gen/task-automation/sdk.gen.ts
+var managerInterruptOnTask = (options) => {
+  return (options.client ?? client2).post({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v3/tasks/{taskId}/interrupt/{interruptTo}",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+var submitTaskTemplate = (options) => {
+  return (options.client ?? client2).post({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v3/tasks/template/{template}",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+var tasks = (options) => {
+  return (options?.client ?? client2).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v3/tasks",
+    ...options
+  });
+};
+var submitTask = (options) => {
+  return (options.client ?? client2).post({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v3/tasks",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+var task = (options) => {
+  return (options.client ?? client2).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v3/tasks/{taskId}",
+    ...options
+  });
+};
+var updateTask = (options) => {
+  return (options.client ?? client2).put({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v3/tasks/{taskId}",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+var client3 = createClient(createConfig({
+  baseUrl: "https://services.babelforce.com"
+}));
+
+// src/gen/task-schedule/sdk.gen.ts
+var getTaskSchedules = (options) => {
+  return (options?.client ?? client3).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v3/tasks/schedules",
+    ...options
+  });
+};
+var submitTaskSchedule = (options) => {
+  return (options.client ?? client3).post({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v3/tasks/schedules",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+var deleteScheduleTask = (options) => {
+  return (options.client ?? client3).delete({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v3/tasks/schedules/{taskScheduleName}",
+    ...options
+  });
+};
+var getTaskSchedule = (options) => {
+  return (options.client ?? client3).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v3/tasks/schedules/{taskScheduleName}",
+    ...options
+  });
+};
+
+// src/resources/tasks.ts
+var TasksResource = class {
+  constructor(client4) {
+    this.client = client4;
+    this.schedules = new TaskSchedulesResource(client4);
+  }
+  client;
+  /** Recurring task schedules — `/api/v3/tasks/schedules`. */
+  schedules;
+  /**
+   * List tasks, auto-paginating across pages.
+   *
+   * ```ts
+   * for await (const task of mgr.tasks.list({ filter: "state==active" })) { … }
+   * ```
+   */
+  async *list(query = {}) {
+    const pageSize = query.pageSize ?? 100;
+    for (let page = 1; ; page++) {
+      const data = await unwrap(
+        tasks({ client: this.client, query: { filter: query.filter, page, page_size: pageSize } })
+      );
+      const records = data.records ?? [];
+      for (const task2 of records) yield task2;
+      const pages = data._metadata?.page_count;
+      if (records.length === 0) return;
+      if (pages != null) {
+        if (page >= pages) return;
+      } else if (records.length < pageSize) {
+        return;
+      }
+    }
+  }
+  /** Collect every task into an array. */
+  async listAll(query = {}) {
+    const out = [];
+    for await (const task2 of this.list(query)) out.push(task2);
+    return out;
+  }
+  /** Create a task. */
+  async create(body) {
+    return unwrap(submitTask({ client: this.client, body }));
+  }
+  /** Create a task from a template, with overrides. */
+  async createFromTemplate(template, overrides) {
+    return unwrap(submitTaskTemplate({ client: this.client, path: { template }, body: overrides }));
+  }
+  /** Get a task by id. */
+  async get(taskId) {
+    return unwrap(task({ client: this.client, path: { taskId } }));
+  }
+  /** Update a task. */
+  async update(taskId, body) {
+    return unwrap(updateTask({ client: this.client, path: { taskId }, body }));
+  }
+  /** Manager-interrupt a task, transitioning it to the given target state. */
+  async interrupt(taskId, interruptTo, action) {
+    await unwrap(
+      managerInterruptOnTask({ client: this.client, path: { taskId, interruptTo }, body: action })
+    );
+  }
+};
+var TaskSchedulesResource = class {
+  constructor(client4) {
+    this.client = client4;
+  }
+  client;
+  /** List task schedules. */
+  async list() {
+    return unwrap(getTaskSchedules({ client: this.client }));
+  }
+  /** Create a task schedule. */
+  async create(schedule) {
+    await unwrap(submitTaskSchedule({ client: this.client, body: schedule }));
+  }
+  /** Get a task schedule by name. */
+  async get(taskScheduleName) {
+    return unwrap(getTaskSchedule({ client: this.client, path: { taskScheduleName } }));
+  }
+  /** Delete a task schedule by name. */
+  async delete(taskScheduleName) {
+    await unwrap(deleteScheduleTask({ client: this.client, path: { taskScheduleName } }));
+  }
+};
+
+// src/client.ts
+var ManagerClient = class _ManagerClient {
+  /** The underlying fetch client (escape hatch for advanced use). */
+  client;
+  /** User management — `/api/v2/users`. */
+  users;
+  /** Task automations — `/api/v3/tasks`. */
+  tasks;
+  constructor(client4) {
+    this.client = client4;
+    this.users = new UsersResource(client4);
+    this.tasks = new TasksResource(client4);
+  }
+  /** Create and configure a client. */
+  static async connect(options) {
+    const baseUrl = options.baseUrl ?? resolveBaseUrl(options.environment ?? "production");
+    const authConfig = buildAuthConfig(options.auth, baseUrl, options.fetch);
+    const client4 = createClient(
+      createConfig({
+        baseUrl,
+        headers: { ...authConfig.headers, ...options.headers },
+        ...authConfig.auth ? { auth: authConfig.auth } : {},
+        ...options.fetch ? { fetch: options.fetch } : {}
+      })
+    );
+    return new _ManagerClient(client4);
+  }
+};
+
+export { ManagerApiError, ManagerClient, TaskSchedulesResource, TasksResource, UsersResource, passwordGrant };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@babelforce/manager-sdk",
+  "version": "0.2.1",
+  "description": "TypeScript SDK for the babelforce manager APIs — auth, user & agent management, call reporting, metrics, and task automations.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "generate": "node scripts/generate.mjs",
+    "typecheck": "tsc --noEmit",
+    "build": "tsup",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "prepublishOnly": "npm run typecheck && npm run build && npm test"
+  },
+  "dependencies": {
+    "@hey-api/client-fetch": "^0.13.1"
+  },
+  "devDependencies": {
+    "@hey-api/openapi-ts": "^0.64.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}