@vario-software/types 2026.12.3

package/app/Api.d.ts

@@ -0,0 +1,286 @@
+// -- Utility types --
+
+type ConvertPath<S extends string> =
+  S extends `${infer A}{${infer B}}${infer C}`
+    ? `${A}:${B}${ConvertPath<C>}`
+    : S;
+
+type ReversePath<S extends string> =
+  S extends `${infer A}:${infer B}/${infer C}`
+    ? `${A}{${B}}/${ReversePath<C>}`
+    : S extends `${infer A}:${infer B}`
+      ? `${A}{${B}}`
+      : S;
+
+type GetOperation<PathDef, M extends string> =
+  M extends keyof PathDef
+    ? Exclude<PathDef[M], undefined> extends infer Op
+      ? Op extends { responses: any } ? Op : never
+      : never
+    : never;
+
+type SuccessResponse<Op> =
+  Op extends { responses: { 200: { content: { 'application/json': infer R } } } } ? R :
+  Op extends { responses: { 201: { content: { 'application/json': infer R } } } } ? R :
+  Op extends { responses: { 200: { content: { '*/*': infer R } } } } ? R :
+  Op extends { responses: { 201: { content: { '*/*': infer R } } } } ? R :
+  Op extends { responses: { 200: { content: { 'application/*': infer R } } } } ? R :
+  Op extends { responses: { 201: { content: { 'application/*': infer R } } } } ? R :
+  never;
+
+type PathParams<Op> =
+  Op extends { parameters: { path: infer P } } ? P : Record<string, never>;
+
+type QueryParams<Op> =
+  Op extends { parameters: { query?: infer Q } }
+    ? [Q] extends [never] ? Record<string, never> : NonNullable<Q>
+    : Record<string, never>;
+
+type RequestBody<Op> =
+  Op extends { requestBody: { content: { 'application/json': infer B } } } ? B :
+  Op extends { requestBody?: { content: { 'application/json': infer B } } } ? B :
+  any;
+
+type MethodEndpoints<Paths, M extends string> = {
+  [P in keyof Paths as
+    GetOperation<Paths[P], M> extends never ? never :
+    [SuccessResponse<GetOperation<Paths[P], M>>] extends [never] ? never :
+    ConvertPath<P & string>
+  ]: GetOperation<Paths[P], M>;
+};
+
+// -- Per-method endpoint maps (used only for path autocomplete constraints) --
+
+type GetEndpoints<Paths> = MethodEndpoints<Paths, 'get'>;
+type PostEndpoints<Paths> = MethodEndpoints<Paths, 'post'>;
+type PutEndpoints<Paths> = MethodEndpoints<Paths, 'put'>;
+type DeleteEndpoints<Paths> = MethodEndpoints<Paths, 'delete'>;
+
+// -- Direct O(1) lookup types (via ReversePath, no mapped type iteration) --
+
+type DirectLookup<Paths, P extends string> =
+  ReversePath<P> extends keyof Paths ? Paths[ReversePath<P>] : never;
+
+type DirectOperation<Paths, P extends string, M extends string> =
+  GetOperation<DirectLookup<Paths, P>, M>;
+
+type DirectPathParams<Paths, P extends string> =
+  DirectLookup<Paths, P> extends infer Def
+    ? [Def] extends [never] ? Record<string, any>
+      : PathParams<GetOperation<Def, 'get'>> extends Record<string, never>
+        ? PathParams<GetOperation<Def, 'post'>> extends Record<string, never>
+          ? PathParams<GetOperation<Def, 'put'>> extends Record<string, never>
+            ? PathParams<GetOperation<Def, 'delete'>>
+            : PathParams<GetOperation<Def, 'put'>>
+          : PathParams<GetOperation<Def, 'post'>>
+        : PathParams<GetOperation<Def, 'get'>>
+    : Record<string, any>;
+
+type ExtractBody<Op> =
+  Op extends { requestBody: { content: { 'application/json': infer B } } } ? B :
+  Op extends { requestBody?: { content: { 'application/json': infer B } } } ? B :
+  never;
+
+type DirectRequestBody<Paths, P extends string> =
+  DirectLookup<Paths, P> extends infer Def
+    ? [Def] extends [never] ? any
+      : ExtractBody<GetOperation<Def, 'post'>> | ExtractBody<GetOperation<Def, 'put'>> extends infer B
+        ? [B] extends [never] ? any : B | string
+        : any
+    : any;
+
+type DirectMethods<Paths, P extends string> =
+  DirectLookup<Paths, P> extends infer Def
+    ? [Def] extends [never] ? string
+      : ([GetOperation<Def, 'get'>] extends [never] ? never : 'GET')
+        | ([GetOperation<Def, 'post'>] extends [never] ? never : 'POST')
+        | ([GetOperation<Def, 'put'>] extends [never] ? never : 'PUT')
+        | ([GetOperation<Def, 'delete'>] extends [never] ? never : 'DELETE')
+    : string;
+
+type DirectQueryParams<Paths, P extends string> =
+  DirectLookup<Paths, P> extends infer Def
+    ? [Def] extends [never] ? Record<string, any>
+      : QueryParams<GetOperation<Def, 'get'>> extends Record<string, never>
+        ? QueryParams<GetOperation<Def, 'post'>> extends Record<string, never>
+          ? QueryParams<GetOperation<Def, 'put'>> extends Record<string, never>
+            ? QueryParams<GetOperation<Def, 'delete'>>
+            : QueryParams<GetOperation<Def, 'put'>>
+          : QueryParams<GetOperation<Def, 'post'>>
+        : QueryParams<GetOperation<Def, 'get'>>
+    : Record<string, any>;
+
+// -- Shared option shapes for generic overloads --
+
+type GenericGetOptions<Paths, P extends string> = ErpBaseOptions & {
+  method: 'GET';
+  pathParams?: DirectPathParams<Paths, P>;
+  params?: QueryParams<DirectOperation<Paths, P, 'get'>>;
+};
+
+type GenericPostOptions<Paths, P extends string> = ErpBaseOptions & {
+  method: 'POST';
+  pathParams?: DirectPathParams<Paths, P>;
+  params?: QueryParams<DirectOperation<Paths, P, 'post'>>;
+  body?: DirectRequestBody<Paths, P>;
+};
+
+type GenericPutOptions<Paths, P extends string> = ErpBaseOptions & {
+  method: 'PUT';
+  pathParams?: DirectPathParams<Paths, P>;
+  params?: QueryParams<DirectOperation<Paths, P, 'put'>>;
+  body?: DirectRequestBody<Paths, P>;
+};
+
+type GenericDeleteOptions<Paths, P extends string> = ErpBaseOptions & {
+  method: 'DELETE';
+  pathParams?: DirectPathParams<Paths, P>;
+  params?: QueryParams<DirectOperation<Paths, P, 'delete'>>;
+};
+
+type GenericFallbackOptions<Paths, P extends string> = ErpBaseOptions & {
+  method?: DirectMethods<Paths, P>;
+  pathParams?: DirectPathParams<Paths, P>;
+  params?: DirectQueryParams<Paths, P>;
+  body?: DirectRequestBody<Paths, P>;
+};
+
+// -- Public types --
+
+export interface ErpFetchResponse<T>
+{
+  data: T;
+  response: any;
+}
+
+export interface ErpBaseOptions
+{
+  saveResponse?: boolean;
+  resolveOn?: 'end' | 'response';
+  timeout?: number;
+  suppressLogs?: boolean;
+  secretsToMask?: string[];
+  followRedirects?: boolean;
+  headers?: Record<string, string>;
+  executeAsAppUser?: boolean;
+}
+
+export interface TypedErpApiFetch<Paths = Record<string, any>>
+{
+  // Path-constrained overloads (for path autocomplete + full response typing)
+  <P extends keyof GetEndpoints<Paths>>(
+    path: P,
+    options: ErpBaseOptions & {
+      method: 'GET';
+      pathParams?: PathParams<DirectOperation<Paths, P & string, 'get'>>;
+      params?: QueryParams<DirectOperation<Paths, P & string, 'get'>>;
+    },
+  ): Promise<ErpFetchResponse<SuccessResponse<DirectOperation<Paths, P & string, 'get'>>>>;
+
+  <P extends keyof PostEndpoints<Paths>>(
+    path: P,
+    options: ErpBaseOptions & {
+      method: 'POST';
+      pathParams?: PathParams<DirectOperation<Paths, P & string, 'post'>>;
+      params?: QueryParams<DirectOperation<Paths, P & string, 'post'>>;
+      body?: RequestBody<DirectOperation<Paths, P & string, 'post'>> | string;
+    },
+  ): Promise<ErpFetchResponse<SuccessResponse<DirectOperation<Paths, P & string, 'post'>>>>;
+
+  <P extends keyof PutEndpoints<Paths>>(
+    path: P,
+    options: ErpBaseOptions & {
+      method: 'PUT';
+      pathParams?: PathParams<DirectOperation<Paths, P & string, 'put'>>;
+      params?: QueryParams<DirectOperation<Paths, P & string, 'put'>>;
+      body?: RequestBody<DirectOperation<Paths, P & string, 'put'>> | string;
+    },
+  ): Promise<ErpFetchResponse<SuccessResponse<DirectOperation<Paths, P & string, 'put'>>>>;
+
+  <P extends keyof DeleteEndpoints<Paths>>(
+    path: P,
+    options: ErpBaseOptions & {
+      method: 'DELETE';
+      pathParams?: PathParams<DirectOperation<Paths, P & string, 'delete'>>;
+      params?: QueryParams<DirectOperation<Paths, P & string, 'delete'>>;
+    },
+  ): Promise<ErpFetchResponse<SuccessResponse<DirectOperation<Paths, P & string, 'delete'>>>>;
+
+  // Path-constrained GET default (no method required, defaults to GET)
+  <P extends keyof GetEndpoints<Paths>>(
+    path: P,
+    options?: ErpBaseOptions & {
+      pathParams?: PathParams<DirectOperation<Paths, P & string, 'get'>>;
+      params?: QueryParams<DirectOperation<Paths, P & string, 'get'>>;
+    },
+  ): Promise<ErpFetchResponse<SuccessResponse<DirectOperation<Paths, P & string, 'get'>>>>;
+
+  // Generic per-method overloads (typed params/body per method, no path constraint)
+  <P extends string>(path: P, options: GenericGetOptions<Paths, P>): Promise<ErpFetchResponse<any>>;
+  <P extends string>(path: P, options: GenericPostOptions<Paths, P>): Promise<ErpFetchResponse<any>>;
+  <P extends string>(path: P, options: GenericPutOptions<Paths, P>): Promise<ErpFetchResponse<any>>;
+  <P extends string>(path: P, options: GenericDeleteOptions<Paths, P>): Promise<ErpFetchResponse<any>>;
+
+  // Fallback (no method specified)
+  <P extends string>(path: P, options?: GenericFallbackOptions<Paths, P>): Promise<ErpFetchResponse<any>>;
+}
+
+export interface VqlOptions
+{
+  statement: string;
+  variableSubstitutions?: any[];
+  limit?: number | null;
+  offset?: number | null;
+}
+
+export interface VqlResult
+{
+  data: Array<Record<string, any>>;
+  moreElements?: string;
+  nextOffset?: string;
+  [key: string]: any;
+}
+
+export interface TypedPathCallable<Paths, R>
+{
+  // Path-constrained overloads (for path autocomplete)
+  <P extends keyof GetEndpoints<Paths>>(path: P, options?: GenericFallbackOptions<Paths, P & string>): Promise<R>;
+  <P extends keyof PostEndpoints<Paths>>(path: P, options?: GenericFallbackOptions<Paths, P & string>): Promise<R>;
+  <P extends keyof PutEndpoints<Paths>>(path: P, options?: GenericFallbackOptions<Paths, P & string>): Promise<R>;
+  <P extends keyof DeleteEndpoints<Paths>>(path: P, options?: GenericFallbackOptions<Paths, P & string>): Promise<R>;
+
+  // Generic per-method overloads (typed params/body per method)
+  <P extends string>(path: P, options: GenericGetOptions<Paths, P>): Promise<R>;
+  <P extends string>(path: P, options: GenericPostOptions<Paths, P>): Promise<R>;
+  <P extends string>(path: P, options: GenericPutOptions<Paths, P>): Promise<R>;
+  <P extends string>(path: P, options: GenericDeleteOptions<Paths, P>): Promise<R>;
+
+  // Fallback (no method specified)
+  <P extends string>(path: P, options?: GenericFallbackOptions<Paths, P>): Promise<R>;
+}
+
+export interface TypedApiStatic<Paths = Record<string, any>>
+{
+  fetch: TypedErpApiFetch<Paths>;
+  getResponseStream: TypedPathCallable<Paths, import('stream').PassThrough>;
+  gateway: TypedPathCallable<Paths, void>;
+  redirectRequest: TypedPathCallable<Paths, import('stream').PassThrough>;
+  vql(options: VqlOptions): Promise<VqlResult>;
+
+  new(path: string, options?: ErpBaseOptions & {
+    method?: string;
+    pathParams?: Record<string, any>;
+    body?: any;
+    params?: Record<string, any>;
+  }): ApiInstance;
+
+  [key: string]: any;
+}
+
+export interface ApiInstance
+{
+  execute(): Promise<void>;
+  getData(): any;
+  getStatusCode(): number | undefined;
+  getResponseHeaders(): Record<string, string> | undefined;
+}

package/app/ErpApi.d.ts

@@ -0,0 +1,13 @@
+import type { paths as erpPaths } from '../schema/erp';
+import type { TypedApiStatic } from './Api';
+import type { Eav, Migration, TextEnum, Webhook, PermittedToken } from './modules';
+
+declare const Api: TypedApiStatic<erpPaths> & {
+  migration: Migration;
+  eav: Eav;
+  textenum: TextEnum;
+  webhook: Webhook;
+  permittedToken: PermittedToken;
+};
+
+export = Api;

package/app/HttpError.d.ts

@@ -0,0 +1,19 @@
+export declare class HttpError extends Error
+{
+  constructor(
+    message: string,
+    statusCode?: number,
+    logService?: string,
+    logInfo?: unknown,
+    logId?: unknown,
+    logLevel?: string,
+    errorData?: unknown,
+  );
+
+  statusCode?: number;
+  logLevel?: string;
+  logService?: string;
+  logId?: unknown;
+  logInfo?: unknown;
+  data?: unknown;
+}

package/app/Migrator.d.ts

@@ -0,0 +1,60 @@
+import type { Request } from 'express';
+import type { components } from '../schema/erp';
+import type { TypedApiStatic } from './Api';
+import type { VarioCloudApp } from './VarioCloudApp';
+import type { EavGroup } from './modules/Eav';
+import type { TextEnumGroupCreate } from './modules/TextEnum';
+
+export type SalesChannelBackend = components["schemas"]["erp-sales_channel-SalesChannelBackend"];
+export type SalesChannel = components["schemas"]["erp-sales_channel-SalesChannel"];
+type FinanceBookingBackend = components["schemas"]["erp-finance-FinanceBookingBackend"];
+type AppScriptingProxy = components["schemas"]["common-api-AppScriptingProxy"];
+type ImportMappingRuleSet = components["schemas"]["common-data_import-ImportMappingRuleSet"];
+
+export interface MigratorMethods
+{
+  log(message: string, level?: string): Promise<void>;
+  getEavGroup(groupKey: string): Promise<EavGroup>;
+  createEavGroup(eavGroup: EavGroup): Promise<EavGroup>;
+  changeEavGroup(groupKey: string, callback: (group: EavGroup) => EavGroup): Promise<EavGroup>;
+  deleteEavGroup(groupKey: string): Promise<EavGroup>;
+  removeDataFromEavGroup(groupKey: string, attributeKeys?: string[]): Promise<EavGroup>;
+  createTextEnumGroup(textEnumGroup: TextEnumGroupCreate): Promise<TextEnumGroupCreate>;
+  registerWebhook(destinationQueue: string, url: string, destinationOwner?: string): Promise<void>;
+  deregisterWebhook(destinationQueue: string, url: string, destinationOwner?: string): Promise<void>;
+  createSalesChannelBackend(label: string, validChannelTypes?: string[]): Promise<SalesChannelBackend>;
+  changeSalesChannelBackend(body: SalesChannelBackend): Promise<SalesChannelBackend>;
+  createSalesChannel(salesChannelBackend: { id: string }, label: string, description: string, channelType?: string): Promise<SalesChannel>;
+  getSalesChannels(): Promise<SalesChannel[]>;
+  findSalesChannelBackend(): Promise<SalesChannelBackend | undefined>;
+  getSalesChannelBackend(salesChannelBackendId: string): Promise<SalesChannelBackend>;
+  activateSalesChannelBackend(salesChannelBackend: { id: string }): Promise<void>;
+  createMultipartImportPreset(importMultipartPresetTemplate: Record<string, unknown>): Promise<{ id: string; [key: string]: unknown }>;
+  createFinanceBackend(label: string): Promise<FinanceBookingBackend>;
+  changeFinanceBackend(label: string, description: string): Promise<FinanceBookingBackend>;
+  updateMultipartImportPreset(id: string, importMultipartPresetTemplate: Record<string, unknown>): Promise<{ id: string; [key: string]: unknown }>;
+  addAppScriptingTrigger(triggerId: string, script: string | object): Promise<void>;
+  updateAppScriptingTrigger(triggerId: string, script: string | object, id?: string): Promise<void>;
+  getAppScriptingTriggerId(triggerId: string): Promise<string | undefined>;
+  getMultipartImportPreset(id: string): Promise<{ id: string; [key: string]: unknown }>;
+  getImportMappingRuleSet(id: string): Promise<ImportMappingRuleSet>;
+  getOrCreateScriptModuleGroup(): Promise<{ id: string; name: string }>;
+  getOrCreateImportScriptPresetting(name: string, script: string | object, existingInlineScript?: string | object): Promise<{ id: string }>;
+}
+
+export type MigratorCallback = (methods: MigratorMethods, results: Record<string, unknown>) => Promise<unknown>;
+
+export declare class Migrator
+{
+  constructor(key: string);
+
+  key: string;
+  req: Request;
+  app: VarioCloudApp;
+  migrationResults: Record<string, unknown>;
+  ApiAdapter: TypedApiStatic;
+  methods: MigratorMethods;
+
+  setMigration(key: string, callback: MigratorCallback): Promise<void>;
+  always(key: string, callback: MigratorCallback): Promise<void>;
+}

package/app/PromiseSingletonMap.d.ts

@@ -0,0 +1,4 @@
+export declare class PromiseSingletonMap
+{
+  run<T>(key: string, fn: () => Promise<T>): Promise<T>;
+}

package/app/VarioCloudApp.d.ts

@@ -0,0 +1,91 @@
+import type { Express, Router } from 'express';
+import type { paths as erpPaths } from '../schema/erp';
+import type { TypedApiStatic } from './Api';
+
+// -- Token & Cache Modules --
+
+export declare class OfflineToken
+{
+  constructor(app: VarioCloudApp, filename?: string);
+
+  app: VarioCloudApp;
+  filename: string;
+  database: { data: Record<string, string>; update(fn: (data: Record<string, string>) => void): Promise<void> };
+
+  init(): Promise<void>;
+  get(tenant: string): Promise<string | undefined>;
+  set(tenant: string, offlineToken: string): Promise<void>;
+  delete(tenant: string): Promise<void>;
+}
+
+export declare class AccessToken
+{
+  init(): Promise<void>;
+  get(tenant: string): Promise<string | null>;
+  set(tenant: string, accessToken: string, expiresAt: number): Promise<void>;
+  delete(tenant: string): Promise<void>;
+}
+
+export declare class BaseUrlCache
+{
+  constructor(app: VarioCloudApp);
+
+  app: VarioCloudApp;
+
+  init(): Promise<void>;
+  get(): Promise<string>;
+  set(value: string): Promise<void>;
+  delete(): Promise<void>;
+}
+
+// -- App Configuration --
+
+export interface ClientConfig
+{
+  clientId: string;
+  clientSecret: string;
+  appIdentifier: string;
+  appJWK: object | string;
+  [key: string]: any;
+}
+
+export interface AppOptions
+{
+  onUnhandledError?: (error: any) => void;
+  onMigrationError?: (error: any) => void;
+  onKeycloakError?: (error: any) => void;
+  log?: (message: string | object, loggerName?: string, level?: string) => void | Promise<void>;
+  offlineToken?: OfflineToken;
+  accessToken?: AccessToken;
+  baseUrlCache?: BaseUrlCache;
+  bodyParser?: import('body-parser').OptionsJson;
+  apiPrefix?: string;
+  [key: string]: any;
+}
+
+// -- VarioCloudApp --
+
+export declare class VarioCloudApp
+{
+  constructor(client: ClientConfig, options?: AppOptions);
+
+  onUnhandledError: (error: any) => void;
+  onMigrationError: (error: any) => void;
+  onKeycloakError?: (error: any) => void;
+
+  express: Express;
+  port: string | number;
+  uiPath: string | null;
+  uiPrefix: string;
+  version: string;
+  client: ClientConfig;
+  log: (message: string | object, loggerName?: string, level?: string) => void | Promise<void>;
+  offlineToken: OfflineToken;
+  accessToken: AccessToken;
+  baseUrlCache: BaseUrlCache;
+  erp: TypedApiStatic<erpPaths>;
+  apiServer: Router;
+  uiServer?: Router;
+
+  start(): Promise<VarioCloudApp>;
+}

package/app/context.d.ts

@@ -0,0 +1,44 @@
+import type { Request, Response } from 'express';
+import type { VarioCloudApp } from './VarioCloudApp';
+
+export interface AccessTokenPayload
+{
+  sub?: string;
+  iss?: string;
+  azp?: string;
+  aud?: string;
+  exp?: number;
+  iat?: number;
+  tenantSubdomain?: string;
+  isSuperUser?: boolean;
+  permissions?: string[];
+  tokenType?: string;
+  [key: string]: unknown;
+}
+
+export interface RequestContext
+{
+  req: Request;
+  res: Response;
+  app: VarioCloudApp;
+  requestId: string;
+  startTime: number;
+  appToken?: string;
+  accessToken?: AccessTokenPayload;
+  runAsAppUser?: boolean;
+  migration?: string;
+  parameter?: Record<string, string>;
+  permittedToken?: { context: Record<string, unknown>; [key: string]: unknown };
+  licenses?: string[];
+}
+
+export declare function getApp(): VarioCloudApp;
+export declare function getContext(): RequestContext;
+export declare function getAppToken(): string | undefined;
+export declare function getAccessToken(): AccessTokenPayload | undefined;
+export declare function getTenant(): string | undefined;
+export declare function getExternalUserId(): string | undefined;
+export declare function getRequest(): Request;
+export declare function getResponse(): Response;
+export declare function getRequestId(): string | undefined;
+export declare function runInContext(context: RequestContext, callback: () => void): void;

package/app/modules/Eav.d.ts

@@ -0,0 +1,16 @@
+import type { TypedApiStatic } from '../Api';
+import type { components } from '../../schema/erp';
+
+export type EavGroup = components["schemas"]["common-eav-EavGroup"];
+
+export declare class Eav
+{
+  constructor(ApiAdapter: TypedApiStatic);
+
+  getGroup(groupKey: string): Promise<EavGroup>;
+  setGroup(eavGroup: EavGroup): Promise<EavGroup>;
+  changeGroup(groupKey: string, callback: (group: EavGroup) => EavGroup): Promise<EavGroup>;
+  deleteGroup(groupKey: string): Promise<boolean>;
+  removeDataFromGroup(groupKey: string, attributeKeys?: string[]): Promise<boolean>;
+  getGroupIdByKey(groupKey: string): Promise<string | null>;
+}

package/app/modules/Migration.d.ts

@@ -0,0 +1,19 @@
+import type { TypedApiStatic } from '../Api';
+import type { components } from '../../schema/erp';
+
+export type MigrationRecord = components["schemas"]["common-api-AppMigration"];
+
+export declare class Migration
+{
+  constructor(ApiAdapter: TypedApiStatic);
+
+  get(identifier: string): Promise<MigrationRecord | undefined>;
+  getAll(options: { offset?: number; limit?: number; identifier?: string }): Promise<{
+    data: MigrationRecord[];
+    moreElements?: string;
+    nextOffset?: string;
+  }>;
+  getNote(key: string): Promise<unknown>;
+  set(identifier: string, note?: string | null): Promise<MigrationRecord>;
+  delete(id: string): Promise<unknown>;
+}

package/app/modules/PermittedToken.d.ts

@@ -0,0 +1,8 @@
+import type { TypedApiStatic } from '../Api';
+
+export declare class PermittedToken
+{
+  constructor(ApiAdapter: TypedApiStatic);
+
+  create(expiresAt: string, permissions: string[]): Promise<{ bearerToken: string; [key: string]: unknown }>;
+}

package/app/modules/TextEnum.d.ts

@@ -0,0 +1,31 @@
+import type { TypedApiStatic } from '../Api';
+import type { components } from '../../schema/erp';
+
+export type TextEnumGroup = components["schemas"]["common-api-TextEnumGroupGet"];
+export type TextEnumGroupCreate = components["schemas"]["common-api-TextEnumGroupCreate"];
+export type TextEnumEntry = components["schemas"]["common-api-TextEnumGet"];
+export type TextEnumEntryCreate = components["schemas"]["common-api-TextEnumCreate"];
+
+export declare class TextEnum
+{
+  constructor(ApiAdapter: TypedApiStatic);
+
+  get(key: string): Promise<TextEnumGroup | undefined>;
+  getAll(options: { offset?: number; limit?: number; key?: string }): Promise<{
+    data: TextEnumGroup[];
+    moreElements?: string;
+    nextOffset?: string;
+  }>;
+  setGroup(textEnumGroupTemplate: TextEnumGroupCreate): Promise<TextEnumGroup>;
+  setEnums(textEnumGroupKey: string, textEnums: TextEnumEntryCreate[]): Promise<void>;
+  createGroup(textEnumGroup: TextEnumGroupCreate): Promise<TextEnumGroup>;
+  getAllEnums(options: { offset?: number; limit?: number; groupId?: string }): Promise<{
+    data: TextEnumEntry[];
+    moreElements?: string;
+    nextOffset?: string;
+  }>;
+  removeEnums(textEnumGroup: TextEnumGroup): Promise<boolean>;
+  removeEnum(textEnum: { id: string }): Promise<void>;
+  createEnums(customGroupKey: string, textEnums: TextEnumEntryCreate[]): Promise<boolean>;
+  createEnum(textEnum: TextEnumEntryCreate): Promise<void>;
+}

package/app/modules/Webhook.d.ts

@@ -0,0 +1,9 @@
+import type { TypedApiStatic } from '../Api';
+
+export declare class Webhook
+{
+  constructor(ApiAdapter: TypedApiStatic);
+
+  register(destinationQueue: string, url: string, destinationOwner?: string): Promise<void>;
+  deregister(destinationQueue: string, url: string, destinationOwner?: string): Promise<void>;
+}

package/app/modules.d.ts

@@ -0,0 +1,5 @@
+export { Eav, EavGroup } from './modules/Eav';
+export { Migration, MigrationRecord } from './modules/Migration';
+export { TextEnum, TextEnumGroup, TextEnumGroupCreate, TextEnumEntry, TextEnumEntryCreate } from './modules/TextEnum';
+export { Webhook } from './modules/Webhook';
+export { PermittedToken } from './modules/PermittedToken';