tanss-api 0.1.0 → 0.2.1

package/README.md

@@ -77,6 +77,73 @@ await putApiV1TicketsTicketId({
 ```
 
 
+## 🏭 ERP integrations
+For the `/api/erp/v1/...` and `/api/v1/erp/...` endpoints, use the namespaced
+ERP client instead of the raw generated functions. It groups all 40+ ERP
+operations into resources (`companies`, `employees`, `tickets`, ...), returns
+response bodies directly, and throws an `ErpApiError` on non-2xx responses.
+
+> Requires a dedicated API token bound to an external API role of `ERP`,
+> `CENTRON`, or `SYSTEMHAUS_ONE` — a normal user login token will NOT work.
+> The token already includes the literal `Bearer ` prefix, send it verbatim.
+
+### Configure the ERP client
+```ts
+import { createErpClient } from 'tanss-api'
+
+const erp = createErpClient({
+  baseUrl: 'https://tanssserver.example.com',
+  token: process.env.TANSS_ERP_TOKEN!,
+})
+```
+
+Unlike the shared `client` singleton, each ERP client owns an isolated
+instance, so auth from other API areas can't leak into ERP requests.
+Rotate the token later with `erp.setToken(nextToken)`.
+
+### Make requests
+```ts
+import { createErpClient, ErpApiError } from 'tanss-api'
+
+const erp = createErpClient({
+  baseUrl: 'https://tanssserver.example.com',
+  token: process.env.TANSS_ERP_TOKEN!,
+})
+
+try {
+  // GET /api/erp/v1/companies/{id}
+  const company = await erp.companies.get(42)
+  console.log(company.content)
+
+  // Find a customer by its external ERP customer number
+  const matches = await erp.companies.searchByDisplayId('C-10042')
+
+  // Map ticket states/types before creating tickets via the sync
+  const statuses = await erp.tickets.statuses()
+  const types = await erp.tickets.types()
+
+  // POST /api/erp/v1/tickets
+  const ticket = await erp.tickets.create({
+    // ... TicketSaveWritable fields
+  })
+} catch (error) {
+  if (error instanceof ErpApiError) {
+    console.error(error.message, error.status, error.body)
+  } else {
+    throw error
+  }
+}
+```
+
+Available resources: `companies`, `employees`, `departments`, `categories`,
+`types`, `tickets`, `customers` (incl. `invoices`), `accountingTypes`,
+`checklists`, `catalog` (`projects`, `stocks`), and `offers` (ERP selections).
+
+> `erp.offers` (`/api/v1/offers/erpSelections*`) is the exception: those routes
+> authenticate with a normal user session token, not the ERP-role token. Pass
+> a user token to `createErpClient` when using that resource.
+
+
 ## 📜 License
 TANSS API and specification are licensed under a proprietary license by [HUCK IT GmbH][huck-imprint].
 

package/dist/erp/client.d.ts

@@ -0,0 +1,36 @@
+import type { Client, Config } from '../generated/client/types.gen';
+export interface CreateErpClientOptions {
+    /**
+     * Hostname of the TANSS instance, e.g. `https://tanss.example.com`.
+     */
+    baseUrl: string;
+    /**
+     * ERP integration token, sent verbatim in the `apiToken` header
+     * (including the `Bearer ` prefix).
+     *
+     * Must belong to an external API role of `ERP`, `CENTRON` or
+     * `SYSTEMHAUS_ONE`. A normal user login token will NOT work for the
+     * `/api/erp/v1/...` routes.
+     */
+    token: string;
+    /**
+     * Custom fetch implementation. Defaults to `globalThis.fetch`.
+     */
+    fetch?: typeof fetch;
+    /**
+     * Extra hey-api client config merged over the defaults.
+     */
+    config?: Omit<Config, 'baseUrl' | 'auth' | 'fetch'>;
+}
+/**
+ * Create an isolated hey-api client pre-configured for the ERP endpoints.
+ *
+ * Unlike the generated `client` singleton, the returned instance is not
+ * shared with other API areas, so `setConfig` calls elsewhere cannot leak a
+ * user token into ERP requests (or vice versa).
+ */
+export declare function createErpClientInstance(options: CreateErpClientOptions): Client;
+/**
+ * Update the token of an ERP client instance (e.g. after rotation).
+ */
+export declare function setErpClientToken(client: Client, token: string): void;

package/dist/erp/errors.d.ts

@@ -0,0 +1,41 @@
+export interface ErpApiErrorDetails {
+    status?: number;
+    body: unknown;
+    request?: Request;
+    response?: Response;
+}
+/**
+ * Error thrown by the ERP facade when TANSS answers with a non-2xx status.
+ *
+ * The generated SDK returns `{ data } | { error }` unions; the facade
+ * converts the error branch into this exception so callers can use plain
+ * `try/catch` instead of checking every response.
+ */
+export declare class ErpApiError extends Error {
+    readonly status?: number;
+    readonly body: unknown;
+    readonly request?: Request;
+    readonly response?: Response;
+    constructor(message: string, details: ErpApiErrorDetails);
+}
+type ErpResult<TData, TError> = {
+    data: TData | undefined;
+    error: TError | undefined;
+    request?: Request;
+    response?: Response;
+};
+/**
+ * Unwrap a generated-SDK result: return `data` on success, throw an
+ * `ErpApiError` (with HTTP status when available) otherwise.
+ */
+export declare function ensureErpData<TData, TError>(result: ErpResult<TData, TError>, context: string): TData;
+/**
+ * Assert a generated-SDK call without a response body succeeded,
+ * throwing an `ErpApiError` otherwise (for 204 No Content endpoints).
+ */
+export declare function ensureErpSuccess<TError>(result: {
+    error: TError | undefined;
+    request?: Request;
+    response?: Response;
+}, context: string): void;
+export {};

package/dist/erp/index.d.ts

@@ -0,0 +1,63 @@
+import type { Client } from '../generated/client/types.gen';
+import { type CreateErpClientOptions } from './client';
+import { type AccountingTypesResource } from './resources/accountingTypes';
+import { type CatalogResource } from './resources/catalog';
+import { type CategoriesResource, type CompanyTypesResource } from './resources/categories';
+import { type ChecklistsResource } from './resources/checklists';
+import { type CompaniesResource } from './resources/companies';
+import { type CustomersResource } from './resources/customers';
+import { type DepartmentsResource } from './resources/departments';
+import { type EmployeesResource } from './resources/employees';
+import { type OffersResource } from './resources/offers';
+import { type TicketsResource } from './resources/tickets';
+export type { CreateErpClientOptions } from './client';
+export { createErpClientInstance, setErpClientToken } from './client';
+export { ErpApiError } from './errors';
+/**
+ * Namespaced facade over the generated `/api/erp/v1/...`,
+ * `/api/v1/erp/...` and offer `erpSelections` endpoints.
+ *
+ * Obtain an instance via `createErpClient({ baseUrl, token })`.
+ *
+ * All methods return the success body directly and throw an `ErpApiError`
+ * on non-2xx responses — no `{ data, error }` union handling required.
+ *
+ * ```ts
+ * import { createErpClient } from 'tanss-api'
+ *
+ * const erp = createErpClient({
+ *   baseUrl: 'https://tanss.example.com',
+ *   token: process.env.TANSS_ERP_TOKEN!,
+ * })
+ *
+ * const company = await erp.companies.get(42)
+ * console.log(company.content)
+ * ```
+ */
+export declare class TanssErpClient {
+    readonly companies: CompaniesResource;
+    readonly employees: EmployeesResource;
+    readonly departments: DepartmentsResource;
+    readonly categories: CategoriesResource;
+    readonly types: CompanyTypesResource;
+    readonly tickets: TicketsResource;
+    readonly customers: CustomersResource;
+    readonly accountingTypes: AccountingTypesResource;
+    readonly checklists: ChecklistsResource;
+    readonly offers: OffersResource;
+    readonly catalog: CatalogResource;
+    /**
+     * The underlying isolated hey-api client. Useful for interceptors or
+     * escaping to raw generated SDK functions via `{ client }`.
+     */
+    readonly instance: Client;
+    constructor(client: Client);
+    /**
+     * Update the ERP token (e.g. after rotation) without rebuilding the client.
+     */
+    setToken(token: string): void;
+}
+/**
+ * Create a {@link TanssErpClient} with its own isolated hey-api instance.
+ */
+export declare function createErpClient(options: CreateErpClientOptions): TanssErpClient;

package/dist/erp/resources/accountingTypes.d.ts

@@ -0,0 +1,29 @@
+import type { Client } from '../../generated/client/types.gen';
+import type { GetApiErpV1AccountingtypesPricesResponse, GetApiErpV1AccountingtypesResponse, PostApiErpV1AccountingtypesData, PostApiErpV1AccountingtypesPricesData, PostApiErpV1AccountingtypesPricesResponse, PostApiErpV1AccountingtypesResponse } from '../../generated/types.gen';
+export type CreateAccountingTypeBody = PostApiErpV1AccountingtypesData['body'];
+export type CreateAccountingTypePriceBody = PostApiErpV1AccountingtypesPricesData['body'];
+/**
+ * Accounting types (Leistungsarten) and their default prices.
+ */
+export declare function createAccountingTypesResource(client: Client): {
+    /**
+     * List the accounting types configured in TANSS.
+     */
+    list(): Promise<GetApiErpV1AccountingtypesResponse>;
+    /**
+     * Create a new accounting type (Leistungsart).
+     */
+    create(body: CreateAccountingTypeBody): Promise<PostApiErpV1AccountingtypesResponse>;
+    prices: {
+        /**
+         * List the default (system-wide) accounting type prices.
+         */
+        list(): Promise<GetApiErpV1AccountingtypesPricesResponse>;
+        /**
+         * Save a new default price entry for an accounting type,
+         * optionally scoped to a linked entity.
+         */
+        create(body: CreateAccountingTypePriceBody): Promise<PostApiErpV1AccountingtypesPricesResponse>;
+    };
+};
+export type AccountingTypesResource = ReturnType<typeof createAccountingTypesResource>;

package/dist/erp/resources/catalog.d.ts

@@ -0,0 +1,18 @@
+import type { Client } from '../../generated/client/types.gen';
+import type { GetApiV1ErpProjectsResponse, GetApiV1ErpStocksResponse } from '../../generated/types.gen';
+/**
+ * ERP backend catalog (`/api/v1/erp/...`): projects and stocks resolved
+ * through the factory-configured ERP service. Returns an empty list when no
+ * ERP service is configured.
+ */
+export declare function createCatalogResource(client: Client): {
+    /**
+     * List projects from the configured ERP backend.
+     */
+    projects(): Promise<GetApiV1ErpProjectsResponse>;
+    /**
+     * List stocks (warehouses/inventories) from the configured ERP backend.
+     */
+    stocks(): Promise<GetApiV1ErpStocksResponse>;
+};
+export type CatalogResource = ReturnType<typeof createCatalogResource>;

package/dist/erp/resources/categories.d.ts

@@ -0,0 +1,59 @@
+import type { Client } from '../../generated/client/types.gen';
+import type { GetApiErpV1CompanyCategoriesCategoryIdResponse, GetApiErpV1CompanyCategoriesResponse, GetApiErpV1TypesResponse, GetApiErpV1TypesTypeIdResponse, PostApiErpV1CompanyCategoriesCategoryIdData, PostApiErpV1CompanyCategoriesCategoryIdResponse, PostApiErpV1TypesData, PostApiErpV1TypesResponse, PutApiErpV1CompanyCategoriesCategoryIdData, PutApiErpV1CompanyCategoriesCategoryIdResponse, PutApiErpV1TypesTypeIdData, PutApiErpV1TypesTypeIdResponse } from '../../generated/types.gen';
+export type CreateCompanyCategoryBody = PostApiErpV1CompanyCategoriesCategoryIdData['body'];
+export type UpdateCompanyCategoryBody = PutApiErpV1CompanyCategoriesCategoryIdData['body'];
+export type CreateCompanyTypeBody = PostApiErpV1TypesData['body'];
+export type UpdateCompanyTypeBody = PutApiErpV1TypesTypeIdData['body'];
+/**
+ * Company classifications: categories (Firmen-Kategorien) each grouping
+ * company types (Firmen-Typen).
+ */
+export declare function createCategoriesResource(client: Client): {
+    /**
+     * List all company categories with their associated company types.
+     */
+    list(): Promise<GetApiErpV1CompanyCategoriesResponse>;
+    /**
+     * Read the single company category identified by `categoryId`.
+     */
+    get(categoryId: number): Promise<GetApiErpV1CompanyCategoriesCategoryIdResponse>;
+    /**
+     * Create a new company category.
+     */
+    create(categoryId: string, body: CreateCompanyCategoryBody): Promise<PostApiErpV1CompanyCategoriesCategoryIdResponse>;
+    /**
+     * Update the company category identified by `categoryId`.
+     */
+    update(categoryId: number, body: UpdateCompanyCategoryBody): Promise<PutApiErpV1CompanyCategoriesCategoryIdResponse>;
+    /**
+     * Delete the company category identified by `categoryId`.
+     */
+    remove(categoryId: number): Promise<void>;
+};
+export type CategoriesResource = ReturnType<typeof createCategoriesResource>;
+/**
+ * Company types (Firmen-Typen) belonging to a category.
+ */
+export declare function createCompanyTypesResource(client: Client): {
+    /**
+     * List all company types configured in TANSS.
+     */
+    list(): Promise<GetApiErpV1TypesResponse>;
+    /**
+     * Read the single company type identified by `typeId`.
+     */
+    get(typeId: number): Promise<GetApiErpV1TypesTypeIdResponse>;
+    /**
+     * Create a new company type and assign it to a category.
+     */
+    create(body: CreateCompanyTypeBody): Promise<PostApiErpV1TypesResponse>;
+    /**
+     * Update the company type identified by `typeId`.
+     */
+    update(typeId: number, body: UpdateCompanyTypeBody): Promise<PutApiErpV1TypesTypeIdResponse>;
+    /**
+     * Delete the company type identified by `typeId`.
+     */
+    remove(typeId: number): Promise<void>;
+};
+export type CompanyTypesResource = ReturnType<typeof createCompanyTypesResource>;

package/dist/erp/resources/checklists.d.ts

@@ -0,0 +1,22 @@
+import type { Client } from '../../generated/client/types.gen';
+import type { GetApiErpV1ChecklistsData, GetApiErpV1ChecklistsResponse, PostApiErpV1ChecklistsAssignmentLinkTypeIdLinkIdChecklistIdResponse } from '../../generated/types.gen';
+export type ChecklistsQuery = GetApiErpV1ChecklistsData['query'];
+export interface AssignChecklistArgs {
+    linkTypeId: number;
+    linkId: number;
+    checklistId: number;
+}
+/**
+ * Checklists: pick a checklist and assign it to a ticket (or other entity).
+ */
+export declare function createChecklistsResource(client: Client): {
+    /**
+     * List checklists, optionally filtered by company and/or department.
+     */
+    list(query?: ChecklistsQuery): Promise<GetApiErpV1ChecklistsResponse>;
+    /**
+     * Assign a checklist to a ticket (`linkTypeId: 11`).
+     */
+    assign(args: AssignChecklistArgs): Promise<PostApiErpV1ChecklistsAssignmentLinkTypeIdLinkIdChecklistIdResponse>;
+};
+export type ChecklistsResource = ReturnType<typeof createChecklistsResource>;

package/dist/erp/resources/companies.d.ts

@@ -0,0 +1,46 @@
+import type { Client } from '../../generated/client/types.gen';
+import type { GetApiErpV1CompaniesDepartmentsResponse, GetApiErpV1CompaniesEmployeesData, GetApiErpV1CompaniesEmployeesDepartmentsResponse, GetApiErpV1CompaniesEmployeesResponse, GetApiErpV1CompaniesIdResponse, GetApiErpV1CompaniesSearchIdDisplayIdResponse, PostApiErpV1CompaniesData, PostApiErpV1CompaniesResponse, PutApiErpV1CompaniesIdData, PutApiErpV1CompaniesIdResponse } from '../../generated/types.gen';
+export type CreateCompanyBody = PostApiErpV1CompaniesData['body'];
+export type UpdateCompanyBody = PutApiErpV1CompaniesIdData['body'];
+export type CompaniesEmployeesQuery = GetApiErpV1CompaniesEmployeesData['query'];
+/**
+ * Company (customer) master data: CRUD plus the ERP lookup and
+ * employee/department views scoped to companies.
+ */
+export declare function createCompaniesResource(client: Client): {
+    /**
+     * Create a new company (customer) record from ERP master data.
+     */
+    create(body: CreateCompanyBody): Promise<PostApiErpV1CompaniesResponse>;
+    /**
+     * Read the company record identified by `id`.
+     */
+    get(id: number): Promise<GetApiErpV1CompaniesIdResponse>;
+    /**
+     * Update the company identified by `id` with ERP master-data changes.
+     */
+    update(id: number, body: UpdateCompanyBody): Promise<PutApiErpV1CompaniesIdResponse>;
+    /**
+     * Delete the company identified by `id` with its dependent data.
+     */
+    remove(id: number): Promise<void>;
+    /**
+     * Search customers by the external ERP customer number (`displayId`).
+     */
+    searchByDisplayId(displayId: string): Promise<GetApiErpV1CompaniesSearchIdDisplayIdResponse>;
+    /**
+     * List employees of the own company (or filter by `companyId` /
+     * `companyNumber`).
+     */
+    employees(query?: CompaniesEmployeesQuery): Promise<GetApiErpV1CompaniesEmployeesResponse>;
+    /**
+     * List the company departments (Abteilungen) configured in TANSS.
+     */
+    departments(): Promise<GetApiErpV1CompaniesDepartmentsResponse>;
+    /**
+     * Map of department lists keyed by employee ID for all active
+     * employees of the own company.
+     */
+    employeesDepartments(): Promise<GetApiErpV1CompaniesEmployeesDepartmentsResponse>;
+};
+export type CompaniesResource = ReturnType<typeof createCompaniesResource>;

package/dist/erp/resources/customers.d.ts

@@ -0,0 +1,24 @@
+import type { Client } from '../../generated/client/types.gen';
+import type { GetApiErpV1CustomersResponse, GetApiErpV1InvoicesData, GetApiErpV1InvoicesResponse, PostApiErpV1CustomersData, PostApiErpV1CustomersResponse } from '../../generated/types.gen';
+export type UpsertCustomersBody = PostApiErpV1CustomersData['body'];
+export type InvoicesQuery = GetApiErpV1InvoicesData['query'];
+/**
+ * Legacy PHP ERP bridge: customer master data sync and invoice reads.
+ */
+export declare function createCustomersResource(client: Client): {
+    /**
+     * Read the customer list through the legacy ERP backend bridge.
+     */
+    list(): Promise<GetApiErpV1CustomersResponse>;
+    /**
+     * Create or update customer data via the legacy ERP backend bridge.
+     *
+     * The endpoint takes a raw string body (no JSON wrapping).
+     */
+    upsert(body: UpsertCustomersBody): Promise<PostApiErpV1CustomersResponse>;
+    /**
+     * Read invoices for the given customer from the legacy ERP backend.
+     */
+    invoices(query?: InvoicesQuery): Promise<GetApiErpV1InvoicesResponse>;
+};
+export type CustomersResource = ReturnType<typeof createCustomersResource>;

package/dist/erp/resources/departments.d.ts

@@ -0,0 +1,17 @@
+import type { Client } from '../../generated/client/types.gen';
+import type { GetApiErpV1CompaniesDepartmentsResponse, GetApiErpV1DepartmentsDepartmentIdEmployeesResponse } from '../../generated/types.gen';
+/**
+ * Departments (Abteilungen): company-wide list plus the employees assigned
+ * to a single department.
+ */
+export declare function createDepartmentsResource(client: Client): {
+    /**
+     * List the company departments configured in TANSS.
+     */
+    list(): Promise<GetApiErpV1CompaniesDepartmentsResponse>;
+    /**
+     * List all employees of the given department.
+     */
+    employees(departmentId: number): Promise<GetApiErpV1DepartmentsDepartmentIdEmployeesResponse>;
+};
+export type DepartmentsResource = ReturnType<typeof createDepartmentsResource>;

package/dist/erp/resources/employees.d.ts

@@ -0,0 +1,26 @@
+import type { Client } from '../../generated/client/types.gen';
+import type { GetApiErpV1EmployeesEmployeeIdDepartmentsResponse, GetApiErpV1EmployeesIdResponse, PostApiErpV1EmployeesData, PostApiErpV1EmployeesResponse, PutApiErpV1EmployeesIdData, PutApiErpV1EmployeesIdResponse } from '../../generated/types.gen';
+export type CreateEmployeeBody = PostApiErpV1EmployeesData['body'];
+export type UpdateEmployeeBody = PutApiErpV1EmployeesIdData['body'];
+/**
+ * Employee master data: CRUD plus the departments an employee belongs to.
+ */
+export declare function createEmployeesResource(client: Client): {
+    /**
+     * Create a new employee record from the ERP payload.
+     */
+    create(body: CreateEmployeeBody): Promise<PostApiErpV1EmployeesResponse>;
+    /**
+     * Read the single employee record identified by `id`.
+     */
+    get(id: number): Promise<GetApiErpV1EmployeesIdResponse>;
+    /**
+     * Update the employee record identified by `id`.
+     */
+    update(id: number, body: UpdateEmployeeBody): Promise<PutApiErpV1EmployeesIdResponse>;
+    /**
+     * List all departments associated with the given employee.
+     */
+    departments(employeeId: number): Promise<GetApiErpV1EmployeesEmployeeIdDepartmentsResponse>;
+};
+export type EmployeesResource = ReturnType<typeof createEmployeesResource>;

package/dist/erp/resources/offers.d.ts

@@ -0,0 +1,40 @@
+import type { Client } from '../../generated/client/types.gen';
+import type { DeleteApiV1OffersErpSelectionsErpSelectionIdResponse, GetApiV1OffersErpSelectionsErpSelectionIdResponse, GetApiV1OffersErpSelectionsMatPickerData, GetApiV1OffersErpSelectionsMatPickerErpSelectionIdResponse, GetApiV1OffersErpSelectionsMatPickerResponse, PostApiV1OffersErpSelectionsData, PostApiV1OffersErpSelectionsResponse, PutApiV1OffersErpSelectionsErpSelectionIdData, PutApiV1OffersErpSelectionsErpSelectionIdResponse } from '../../generated/types.gen';
+export type CreateErpSelectionBody = PostApiV1OffersErpSelectionsData['body'];
+export type UpdateErpSelectionBody = PutApiV1OffersErpSelectionsErpSelectionIdData['body'];
+export type MatPickerQuery = GetApiV1OffersErpSelectionsMatPickerData['query'];
+/**
+ * Offer ERP selections (`/api/v1/offers/erpSelections*`): material
+ * selections used in offer templates.
+ *
+ * Note: unlike `/api/erp/v1/...`, these routes authenticate with a normal
+ * user session token (`ApiTokenAuth`), not the ERP-role token. Pass a user
+ * token to `createErpClient` when using this resource.
+ */
+export declare function createOffersResource(client: Client): {
+    /**
+     * Create a new ERP selection including its materials.
+     */
+    create(body: CreateErpSelectionBody): Promise<PostApiV1OffersErpSelectionsResponse>;
+    /**
+     * Fetch an ERP selection (including material) by id.
+     */
+    get(erpSelectionId: number): Promise<GetApiV1OffersErpSelectionsErpSelectionIdResponse>;
+    /**
+     * Update an ERP selection and save all attached materials.
+     */
+    update(erpSelectionId: number, body: UpdateErpSelectionBody): Promise<PutApiV1OffersErpSelectionsErpSelectionIdResponse>;
+    /**
+     * Delete an ERP selection.
+     */
+    remove(erpSelectionId: number): Promise<DeleteApiV1OffersErpSelectionsErpSelectionIdResponse>;
+    /**
+     * List materials for the "material picker".
+     */
+    matPicker(query: MatPickerQuery): Promise<GetApiV1OffersErpSelectionsMatPickerResponse>;
+    /**
+     * List materials of the picker scoped to a given ERP selection.
+     */
+    matPickerBySelection(erpSelectionId: number): Promise<GetApiV1OffersErpSelectionsMatPickerErpSelectionIdResponse>;
+};
+export type OffersResource = ReturnType<typeof createOffersResource>;

package/dist/erp/resources/tickets.d.ts

@@ -0,0 +1,27 @@
+import type { Client } from '../../generated/client/types.gen';
+import type { GetApiErpV1TicketsStatusResponse, GetApiErpV1TicketsTypesResponse, PostApiErpV1TicketsData, PostApiErpV1TicketsResponse, PostApiErpV1TicketsTicketIdUploadData, PostApiErpV1TicketsTicketIdUploadResponse } from '../../generated/types.gen';
+export type CreateErpTicketBody = PostApiErpV1TicketsData['body'];
+export type UploadTicketFileBody = NonNullable<PostApiErpV1TicketsTicketIdUploadData['body']>;
+/**
+ * Tickets as seen by ERP integrations: create tickets, resolve status/type
+ * mappings, and upload documents or images into a ticket.
+ */
+export declare function createTicketsResource(client: Client): {
+    /**
+     * Create a new ticket in the database.
+     */
+    create(body: CreateErpTicketBody): Promise<PostApiErpV1TicketsResponse>;
+    /**
+     * List all ticket states configured in TANSS (for status mapping).
+     */
+    statuses(): Promise<GetApiErpV1TicketsStatusResponse>;
+    /**
+     * List all active ticket types configured in TANSS.
+     */
+    types(): Promise<GetApiErpV1TicketsTypesResponse>;
+    /**
+     * Upload a document or image into the given ticket.
+     */
+    upload(ticketId: number, files: UploadTicketFileBody): Promise<PostApiErpV1TicketsTicketIdUploadResponse>;
+};
+export type TicketsResource = ReturnType<typeof createTicketsResource>;

package/dist/generated/types.gen.d.ts

@@ -1069,7 +1069,7 @@ export type TnsPhoneNumberFoundItem = {
      * * A company has the phone number 06154/6006-0
      * * You search for a number 06154/6006-123
      * * The system will try to replace the last 3 chars of the company, so that the number could be found as well,
-     * because 06154/6006-123 is an extension to 06154/6006-0
+     *   because 06154/6006-123 is an extension to 06154/6006-0
      *
      */
     charsLeftOut?: number;

package/dist/index.d.ts

@@ -1,2 +1,4 @@
+export type { CreateErpClientOptions } from './erp/index';
+export { createErpClient, ErpApiError, TanssErpClient } from './erp/index';
 export * from './generated';
 export { client } from './generated/client.gen';